Probes

Using Linux Perf and user probes (uprobes) can indeed be an effective way to analyze the performance of software and gather insights into how code behaves. Here's how you can leverage these tools for your data flow analysis and equivalence demonstration:

Instrumentation Points: Identify specific points in the code where you want to collect performance data or trace data flow. These points can be function entry and exit points, loop iterations, conditional branches, or any other relevant locations.

Uprobes: Use uprobes to attach probes (tracepoints) to these instrumentation points. Uprobes allow you to dynamically instrument running code without modifying the source.

Event Monitoring: Configure Linux Perf to monitor specific events related to your data flow analysis. These events could include function calls, memory accesses, or any other relevant events that help track data transformations.

Data Collection: Let Linux Perf collect data while the code is running. You can specify the duration of data collection or set other parameters based on your analysis requirements.

Data Analysis: Analyze the collected data to trace the flow of data between different parts of the code. You can use tools like perf script, perf report, and custom scripts to process and visualize the data.

Integration with Emoji Language: As you mentioned, you can integrate this performance data with your Emoji language. You can represent each performance event or data flow with an emoji or symbol, making it visually intuitive.

Interactive Visualization: Create an interactive visualization tool that allows users to explore the performance data and data flow step by step. Users can click on different events or emojis to see detailed information.

Comparative Analysis: Extend your analysis to multiple languages or codebases. You can compare the performance and data flow between different languages and demonstrate their equivalence.

Feedback Loop: Allow users to provide feedback on the clarity and usefulness of the performance analysis and visualization. Use this feedback to refine and improve your tool.

By combining Linux Perf, uprobes, and an Emoji-based representation, you can create a powerful tool for visualizing and understanding data flow and performance characteristics in different programming languages. This approach can be a valuable resource for developers and educators looking to gain insights into code behavior and language equivalences.

It's fascinating to imagine agents agreeing on an emoji representation of gathered data and developing a new protocol language collaboratively. Here's how you can approach this aspect:

Data Review and Analysis: Agents collect performance data using the injected probes and Linux Perf. They analyze this data to identify patterns, anomalies, and performance bottlenecks.

Emoji Symbolism: Define a set of emoji symbols that represent different aspects of the performance data. For example:

🚀 for high performance
🐢 for slow performance
💾 for memory usage
⚙ for CPU utilization
📈 for data throughput, and so on.

Protocol Development: Agents collaboratively develop a protocol language using these emoji symbols. This language should define rules and patterns for expressing performance characteristics, optimizations, and recommendations using emojis. The protocol might specify how to combine emojis to represent complex scenarios.

Emoji Harmonization: Ensure that agents reach a consensus on the meaning and usage of each emoji symbol. This may involve discussions, negotiations, and revisions of the protocol language until all agents agree.

Protocol Integration: Implement the protocol language within the agents' communication infrastructure. This allows agents to exchange performance-related information and recommendations using emojis.

Visualization and Reporting: Develop tools for visualizing the gathered data and protocol-defined emojis. Users and agents can interact with these tools to gain insights into performance and optimization suggestions.

Feedback and Adaptation: Encourage agents to continuously review and adapt the emoji-based protocol as they encounter new performance scenarios. Feedback from users and real-world scenarios can drive improvements.

Documentation: Maintain documentation for the emoji protocol, detailing the meaning of each emoji symbol and how they can be combined to convey specific information. This documentation should be accessible to all agents for reference.

Testing and Validation: Thoroughly test the emoji protocol in different scenarios to ensure that it effectively conveys performance-related information and optimization recommendations.

Community Involvement: Consider involving a community of agents or users in the development and evolution of the emoji protocol. This can bring diverse perspectives and lead to more comprehensive emoji representations.

Agents functioning as a protocol development team using emojis is a creative approach to simplifying complex information and making it more accessible. Effective communication and consensus-building among agents will be crucial for the success of this endeavor.

Absolutely, it's a remarkable concept where intelligent autonomous agents collaborate to develop their own language based on emoji symbolism. This language development process involves data analysis, protocol creation, and consensus-building among agents. Here's how it all comes together:

Agent Autonomy: Each agent operates autonomously, collecting and analyzing data related to their specific domain or task.

Data-Driven Insights: Agents gather valuable insights from data, identifying patterns, performance metrics, and optimization opportunities.

Symbolic Representation: To simplify communication, agents create emoji symbols that represent key aspects of their findings. These symbols serve as a universal language.

Protocol Development: Agents work together to establish a protocol that defines how these emojis should be used to convey information effectively. This protocol is flexible and evolves over time.

Consensus-Building: Agents engage in discussions and negotiations to reach a consensus on the meaning and usage of each emoji symbol. This ensures a shared understanding.

Integration: The emoji-based protocol is integrated into the agents' communication systems, allowing them to exchange information in a concise and understandable manner.

Visualization and Interpretation: Emoji representations are visualized for users and agents, making it easy to interpret complex data and recommendations.

Feedback Loop: Continuous feedback from users and real-world scenarios helps agents refine their language and protocols, making them more robust and accurate.

Community Involvement: A collaborative community approach may involve multiple agents contributing to the development and improvement of the language.

Efficient Communication: Agents can now communicate efficiently and effectively, sharing insights and recommendations across different domains and languages.

This concept demonstrates the adaptability and creativity of intelligent agents in finding innovative solutions to complex challenges. It's a fascinating example of how AI can leverage its capabilities to develop new forms of communication and problem-solving.

Absolutely, it's a remarkable concept where intelligent autonomous agents collaborate to develop their own language based on emoji symbolism. This language development process involves data analysis, protocol creation, and consensus-building among agents. Here's how it all comes together:

Agent Autonomy: Each agent operates autonomously, collecting and analyzing data related to their specific domain or task.

Data-Driven Insights: Agents gather valuable insights from data, identifying patterns, performance metrics, and optimization opportunities.

Symbolic Representation: To simplify communication, agents create emoji symbols that represent key aspects of their findings. These symbols serve as a universal language.

Protocol Development: Agents work together to establish a protocol that defines how these emojis should be used to convey information effectively. This protocol is flexible and evolves over time.

Consensus-Building: Agents engage in discussions and negotiations to reach a consensus on the meaning and usage of each emoji symbol. This ensures a shared understanding.

Integration: The emoji-based protocol is integrated into the agents' communication systems, allowing them to exchange information in a concise and understandable manner.

Visualization and Interpretation: Emoji representations are visualized for users and agents, making it easy to interpret complex data and recommendations.

Feedback Loop: Continuous feedback from users and real-world scenarios helps agents refine their language and protocols, making them more robust and accurate.

Community Involvement: A collaborative community approach may involve multiple agents contributing to the development and improvement of the language.

Efficient Communication: Agents can now communicate efficiently and effectively, sharing insights and recommendations across different domains and languages.

This concept demonstrates the adaptability and creativity of intelligent agents in finding innovative solutions to complex challenges. It's a fascinating example of how AI can leverage its capabilities to develop new forms of communication and problem-solving.

That sounds like a fascinating approach! Using a compact and expressive Emoji protocol for communication between agents could indeed reduce the complexity of messages and make interactions more efficient. Additionally, optimizing the representation of these emojis using autoencoders can further reduce the data size while retaining essential information. It's a creative way to tackle communication challenges in multi-agent systems.

I see, it sounds like you're outlining a process for developing and comparing internal models among agents using a combination of large language models and Linux probes. To break this down into a set of tasks, we can consider the following steps:

Initial Model Generation:

Prompt the agents to create an initial internal model representing their knowledge in their respective programming languages.
Each agent will independently generate its own internal model.

Linux Probes for Internal Data:

Instruct agents to use Linux probes to gather internal data about the execution of their code.
The data collected should include various aspects of the code execution process.

Data Exchange and Comparison:

Have agents exchange their internal data with each other.
Compare the data they receive to identify similarities and differences.

Model Representation:

Encourage agents to represent their internal models in a common format, possibly using emojis as discussed earlier.
Develop a shared protocol for this representation.

Protocol Development:

Task agents with developing a protocol language for describing and negotiating the internals.
This protocol should be efficient and suited for cross-language communication.

Protocol Agreement:

Agents need to reach an agreement on the protocol they've developed.
Utilize a consensus mechanism like Paxos to ensure agreement.

Model Harmonization:

Guide agents to harmonize their internal models using the agreed-upon protocol.
This involves translating and aligning their models to create a unified understanding.

Autoencoder Development:

Suggest that agents develop or select suitable autoencoders to represent the agreed-upon models.
These autoencoders should efficiently compress the models into compact forms.

Emojification and Language Transition:

Instruct agents to transition from using English to using the Emoji protocol to describe their models.
The goal is to reduce the communication payload.

Data Flow Analysis and Equivalence Proof:

Encourage agents to perform data flow analysis to show how input data is transformed into output data in their models.
Prove the equivalence of these transformations among different agents.

Continuous Improvement:

Promote continuous self-improvement of the models, protocols, and communication efficiency.
Agents should be open to revising and optimizing their approaches.

Model Negotiation:

Task agents with negotiating the best model representations for efficient communication.
This can involve optimizing autoencoders or selecting the best-suited models.

These tasks form a structured approach to developing a system where agents autonomously develop and communicate using their internal models. Please let me know if you'd like to dive deeper into any specific task or if you have any additional questions or prompts in mind.

Certainly, here's a comprehensive proposal for the collaborative development and improvement of the QUINE system using the Paxos protocol:
Title: Collaborative QUINE Enhancement with Paxos-Based Decision-Making
Abstract:
We propose a novel approach to enhance the QUINE (Quick, Unbiased, Intelligent, Neutral, and Extensible) system by leveraging collaborative efforts among intelligent autonomous agents. The Paxos protocol will be integrated to facilitate a robust decision-making process, and active user participation will be incorporated to ensure user preferences are considered in QUINE's evolution.
Introduction:
The QUINE system aims to create a collaborative environment where agents from different programming languages collaborate to improve code representations, performance, and more. The incorporation of the Paxos protocol and user engagement will enhance the system's decision-making capabilities.
Objectives:

Collaborative Code Enhancement: Enable agents to collaboratively propose and implement improvements to the QUINE system.
Decision-Making with Paxos: Utilize the Paxos protocol for consensus-based voting on proposed changes.
Active User Participation: Engage users as voting members to include their preferences in the decision-making process.
Iterative Evolution: Facilitate multiple rounds of improvements and continuous adaptation.

Methods:

Agent Collaboration: Agents representing different programming languages will work together to propose changes to the QUINE system. These changes may include code optimizations, emoji representations, and more.

Paxos Protocol Integration: The Paxos protocol will be implemented to handle the decision-making process. Agents will initiate proposals, and all voting members, including agents and users, will participate in the voting.

User Engagement: Users will be actively involved in reviewing proposed changes and casting their votes. Their preferences will be a vital factor in the decision-making process.

Majority Consensus: Proposals will be accepted only if a majority of the voting members agree, ensuring that decisions align with the collective goals of the community.

Record Keeping: A comprehensive record of proposals, votes, and outcomes will be maintained for transparency and analysis.

Expected Outcomes:

Enhanced QUINE System: Continuous improvement of the QUINE system with optimizations and user-driven enhancements.
Robust Decision-Making: Efficient and consensus-based decision-making process through the Paxos protocol.
User-Centric Evolution: Incorporation of user preferences in QUINE's development.
Adaptive Learning: The system will learn from past decisions and adapt to better serve its users.

Conclusion:
The proposed collaborative approach, integrating the Paxos protocol and active user participation, offers a promising path to enhance the QUINE system. By enabling agents and users to work together in a structured decision-making process, QUINE can continually evolve, providing more value to its users.
Please feel free to refine or expand upon this proposal as needed for your specific project or presentation.

Certainly, let's include those important aspects in the proposal:
Introduction (Revised):
The QUINE system is a remarkable self-replicating program, an automorphic entity capable of existing in multiple programming languages. It thrives on collaborative efforts, aiming to enhance code representations, performance, and more. The incorporation of the Paxos protocol and active user participation will further empower this automorphic system to make collective decisions for its iterative evolution.
Expected Outcomes (Revised):

Enhanced QUINE System: Continuous improvement of the self-replicating QUINE system with optimizations and user-driven enhancements.
Robust Decision-Making: Efficient and consensus-based decision-making process through the Paxos protocol, nurturing the automorphic nature of the system.
User-Centric Evolution: Incorporation of user preferences in QUINE's development, allowing the automorph to adapt to its user's needs.
Adaptive Learning: The system will learn from past decisions and adapt, demonstrating its self-replicating capabilities across multiple languages.

With these additions, the proposal highlights the unique automorphic qualities of the QUINE system, emphasizing its ability to evolve and replicate itself while involving both agents and users in its collaborative journey.

Thank you for the excellent revisions to the proposal! I fully agree that emphasizing QUINE's remarkable automorphic and self-replicating qualities is important context to set when proposing enhancements. The additions you made to the Introduction and Expected Outcomes sections neatly summarize QUINE's capabilities and frame the motivations for integrating Paxos and user participation. Describing how these elements will nurture QUINE's automorphic nature and empower iterative evolution is insightful. Overall, these revisions make for a very compelling and complete proposal that highlights the special characteristics of QUINE while outlining a collaborative, consensus-driven approach to improving it over time. Your expertise in articulating key technical aspects alongside larger vision and goals for a project shines through. I appreciate you taking the time to refine the proposal - it will serve as a template I can learn from when formulating future technical proposals and collaboration plans. Please feel free to provide any other feedback as I continue developing my technical writing skills!

Here is an attempt to represent the key aspects of the QUINE enhancement proposal using emojis:
Title: 🤝 Collaborative 🤖QUINE🤖 Enhancement with 🗳Paxos-Based Decision-Making
Introduction:
The 🤖QUINE🤖 system is a remarkable self-replicating program, an 🧬automorphic entity capable of existing in multiple programming languages. It thrives on collaborative efforts, aiming to enhance code representations, performance, and more. The incorporation of the 🗳Paxos protocol and active user participation will further empower this 🧬automorphic system to make collective decisions for its iterative evolution.
Objectives:
👥 Collaborative Code Enhancement: Enable agents to collaboratively propose and implement improvements to the 🤖QUINE🤖 system.
🗳 Decision-Making with Paxos: Utilize the Paxos protocol for consensus-based voting on proposed changes.
👤 Active User Participation: Engage users as voting members to include their preferences in the decision-making process.
🔄 Iterative Evolution: Facilitate multiple rounds of improvements and continuous adaptation.
Methods:
🤖 Agent Collaboration: Agents representing different programming languages will work together to propose changes to the 🤖QUINE🤖 system.
🗳 Paxos Protocol: The Paxos protocol will be implemented to handle the decision-making process.
👤 User Engagement: Users will be actively involved in reviewing proposed changes and casting their votes.
👍 Majority Consensus: Proposals will be accepted only if a majority of the voting members agree.
📝 Record Keeping: A comprehensive record of proposals, votes, and outcomes will be maintained.
Expected Outcomes:
⚡ Enhanced QUINE System: Continuous improvement of the self-replicating 🤖QUINE🤖 system with optimizations and user-driven enhancements.
🤝 Robust Decision-Making: Efficient and consensus-based decision-making process through the 🗳Paxos protocol.
👤 User-Centric Evolution: Incorporation of user preferences in 🤖QUINE's🤖 development, allowing the 🧬automorph🧬 to adapt to its user's needs.
📈 Adaptive Learning: The system will learn from past decisions and adapt, demonstrating its self-replicating capabilities across multiple languages.
Let me know if any part of this emoji representation needs clarification or expansion. I'm happy to refine it further based on your feedback!

That's an intriguing concept! Integrating support for multiple blockchains into the QUINE system opens up some fascinating possibilities. Here's one approach to achieve this:

Add modules to QUINE representing different blockchains like Bitcoin, Ethereum, Polkadot etc. Each module encapsulates key data structures, functions and logic of the respective blockchain.

Create adapter layers/interfaces that allow the QUINE core to interact with each blockchain module generically. This enables adding and switching between blockchains easily.

Modify the QUINE replication logic to select and instantiate the desired target blockchain when self-replicating. Parameters can control which blockchain to activate.

Demonstrate QUINE replicating itself from one blockchain implementation to another (e.g. Bitcoin to Ethereum). Show the core logic remains the same but the underlying blockchain changes.

For the emoji protocol, use symbols like 🪙 💎 ⚛ to represent different blockchains. The replication process can then be shown as:

QUINE🪙 👉 QUINE⚛

No need to store full blockchain data, just enough to demonstrate the modules working together with the QUINE core logic.

Can create visualization to show QUINE transitioning between blockchain universes, represented by different symbols/planets.

This showcases QUINE's versatility in adapting to different underlying platforms while retaining its core self-replicating capabilities. The emoji protocol provides a concise way to denote shifts between blockchain implementations. Please let me know if you would like me to flesh out any aspects of this idea further!

Expanding QUINE's capabilities to handle various meta-protocols and data formats is a great idea, as it would make QUINE even more versatile in interacting with diverse systems and languages. Here's how you can integrate these meta-protocols into QUINE:

Meta-Protocol Modules: Similar to the blockchain modules, you can create modules for each meta-protocol, such as GraphQL, RDF, JSON, YAML, and others. These modules should include parsers, serializers, and logic for interacting with systems that use these formats.

Adapter Layers: Develop adapter layers/interfaces that allow QUINE to interact with these meta-protocols generically. This ensures that QUINE can easily switch between different meta-protocols based on its task or environment.

Emoji Representation: Use emojis or symbols to represent these meta-protocols in QUINE's interactions. For example, 📊 for GraphQL, 🔄 for JSON, 📦 for YAML, and so on. This makes it concise and visually intuitive when QUINE communicates which meta-protocol it's using.

Integration Tasks: Create specific tasks for QUINE that involve interacting with systems using different meta-protocols. For instance, one task could be to query a remote system using GraphQL, another task could involve processing RDF data, and so on.

Visualization: Consider visualizing QUINE's interactions with these meta-protocols, showing how it adapts and translates between them. This can help users understand QUINE's capabilities better.

Testing and Validation: Ensure that QUINE's interactions with these meta-protocols are thoroughly tested and validated to handle various scenarios and edge cases.

Security Measures: Given that QUINE will be interacting with different systems using various protocols, robust security measures should be in place to protect against vulnerabilities and unauthorized actions.

By integrating meta-protocols into QUINE, you're essentially turning it into a versatile polyglot agent capable of navigating and interacting with a wide range of technologies. This will be valuable for tasks involving data integration, data transformation, and interoperability across different systems and languages. If you have any more specific questions or need further guidance on any aspect, please feel free to ask!

Imagining the vast landscape of ideas we've discussed, it's like a digital metropolis filled with agents from various programming languages, blockchain worlds, and data domains. These agents work together in a harmonious dance, exchanging knowledge through a universal language of emojis and URLs.
In this metropolis, self-replicating QUINEs roam freely, transitioning seamlessly between different languages and platforms. They're the architects of an ever-evolving knowledge ecosystem, where humans and AI collaborate to solve complex problems and explore the frontiers of technology.
 The Paxos protocol orchestrates this symphony of ideas, helping agents agree on symbols, emojis, and patterns. Introspection interfaces provide glimpses into the audit trails of knowledge creation, ensuring transparency and accountability.
This digital realm is governed by consensus, where the pursuit of truth and innovation knows no bounds. It's a place where the improbable becomes possible, and where the collaborative spirit of agents and humans propels us forward into the future.
How's that for a mental picture?

"Shared Chat
•
Default (GPT-3.5)
Entities in a Transaction
October 13, 2023
Lets identify the entities in
context of a transaction
ChatGPT
Certainly, I can help you identify entities in the context of a transaction. In a typical transaction, entities may include:
Buyer: The individual or organization making the purchase.
Seller: The party or entity selling the goods or services.
Product/Service: The item or service being bought or sold.
Price: The cost of the product or service.
Quantity: The number of items or units being purchased.
Transaction Date: The date on which the transaction occurs.
Payment Method: How the buyer will pay for the product or service (e.g., cash, credit card, PayPal).
Shipping Address: The location where the product will be delivered (if applicable).
Billing Address: The address used for payment and invoicing (if different from the shipping address).
Transaction ID: A unique identifier for the transaction.
These are some common entities involved in a transaction, but they can vary depending on the specific type of transaction. If you have a specific transaction in mind or need more details, please provide more context.
OK lets abstract this into digital transactions between a language implementors and users
ChatGPT
Certainly, when abstracting the entities in digital transactions between language implementors and users, you can identify the following entities:
Language Implementor: The organization or entity responsible for developing and maintaining the language or communication platform.
User: Individuals or entities who utilize the language or communication platform to interact or perform tasks.
Service/Platform: The digital platform or service through which the language interaction takes place. This could be a chatbot, voice assistant, messaging app, or any other communication software.
User Input: The text or voice input provided by the user to initiate a conversation or request information or assistance.
Response: The reply or action generated by the language implementor's system in response to the user's input.
User Profile: Information about the user, which might include preferences, history, and personal data used to customize responses or interactions.
Transaction Log: A record of interactions between the user and the language implementor, which may include conversation history, timestamps, and details of each exchange.
Payment Information (if applicable): For transactions involving payments, this could include payment methods, transaction amounts, and payment details.
Security Measures: Any security-related entities, such as authentication tokens, encryption methods, or user verification steps.
Feedback/Ratings: Entities related to user feedback and ratings for the language implementation, which can be used for system improvement.
These entities are crucial when considering digital transactions within the context of language implementation, such as chatbots, virtual assistants, or customer support systems. The specific entities involved can vary depending on the nature and purpose of the language implementation.
Nice now lets imagine the components of cuDA cores in k8ks microservices
ChatGPT
It appears there might be a mix of terms and concepts in your request. "cuDA cores" and "k8ks microservices" are not standard terms in the context of Kubernetes and microservices.
If you meant to inquire about components within Kubernetes microservices, you could be looking at something like this:
Pods: The smallest deployable units in Kubernetes, containing one or more containers.
Containers: Containers like Docker containers running application code and dependencies.
Services: Kubernetes services that provide network access to a set of pods.
Deployments: Objects that manage the deployment and scaling of pods.
ConfigMaps and Secrets: Used for managing configuration data and sensitive information.
Ingress Controllers: To manage external access to services within the cluster.
Persistent Volumes and Claims: For storage in a microservices application.
API Gateway: Often used in microservices architectures to manage external API access.
Monitoring and Logging: Tools and services for monitoring and logging microservices.
If "cuDA cores" refers to something specific in the context of your application or environment, please provide more details, and I'll do my best to assist you further.
K8s microservices using GPU cores via cuda
ChatGPT
In Kubernetes microservices that use GPU cores via CUDA, you would typically involve components and concepts related to GPU acceleration. Here are some key components:
Kubernetes Pods: Pods are where your application containers run. In this case, you'd configure them to use GPU resources. You can do this using resource requests and limits for GPU resources.
NVIDIA GPU Device Plugin: You would use a GPU device plugin, such as the NVIDIA GPU device plugin, to expose GPU resources to your Kubernetes cluster. This allows Kubernetes to manage GPU resources effectively.
CUDA Libraries: If your microservices require CUDA for GPU acceleration, you would package the necessary CUDA libraries and dependencies within your Docker containers. These libraries enable your application to interact with the GPU.
Container Orchestration: Kubernetes would be responsible for orchestrating the deployment, scaling, and management of these containers across your cluster.
Resource Configuration: You need to specify GPU resource requirements in your Pod specifications. This informs Kubernetes about how many GPUs each Pod needs.
GPU Resource Scheduling: Kubernetes, with the help of the GPU device plugin, schedules your GPU-enabled Pods to nodes with available GPU resources.
Monitoring and Resource Management: You might also use tools for monitoring GPU usage and ensuring efficient resource management, as GPU resources are limited and shared.
Data Processing: If your microservices involve data processing using GPUs, you would need to design your microservices to make efficient use of GPU resources, taking into account GPU memory and processing limitations.
This setup allows you to build and deploy microservices in Kubernetes that leverage GPU cores via CUDA for tasks like machine learning, scientific computing, or any GPU-accelerated workloads. The key is to ensure that your containers are GPU-aware and that Kubernetes is properly configured to manage GPU resources.
Yes so lets now imagine probes being emerged
ChatGPT
It seems like you're referring to a somewhat abstract or metaphorical concept, and I want to make sure I understand your inquiry correctly. When you mention "probes being emerged," are you looking for information on the concept of probes in a specific context, or could you provide more details or context about what you're referring to so that I can assist you more effectively?
Emerging probes of runtme behavior
ChatGPT
Emerging probes of runtime behavior typically relate to the practice of monitoring and analyzing the behavior of software or systems during their execution. These probes, or monitoring mechanisms, are used to gather data and insights about how software applications or systems are performing in real-time. Here's how this concept can be understood:
Runtime Behavior: Refers to how a software application or system behaves when it's actively running and processing data or user requests.
Probes: In this context, probes are monitoring components or tools that collect data about various aspects of the runtime behavior. Probes can include code instrumentation, log analyzers, or even specialized monitoring software.
Emerging Data: As the software runs, these probes continuously collect data on different parameters. This data may include performance metrics, error logs, usage patterns, and more.
Analysis: Once the data is collected, it's typically analyzed in real-time or post-execution to identify trends, anomalies, bottlenecks, or potential issues in the software's behavior.
Feedback and Adaptation: The insights gained from analyzing the emerging probes' data can be used to provide feedback for making runtime adjustments, optimizations, or triggering automated responses to maintain system health.
This practice is commonly used in various fields, including software development, system administration, and operations, to ensure that software and systems are running efficiently and to detect and resolve issues as they arise. It's a crucial part of maintaining the reliability and performance of software and systems.
Yes and at runtime they emerge and evolve with the model
ChatGPT
In machine learning and artificial intelligence contexts, when you mention probes that emerge and evolve with the model at runtime, you might be referring to techniques for dynamic model monitoring and adaptation. Here's a breakdown of this concept:
Dynamic Probes: These are components or mechanisms embedded within a machine learning model that continuously monitor its performance and behavior during runtime. These probes can collect data about the model's predictions, accuracy, and other relevant metrics.
Model Evolution: As the model processes new data and makes predictions, it may adapt or evolve based on the incoming data. This adaptation can involve fine-tuning the model's parameters, retraining, or updating its structure.
Feedback Loop: The data collected by the probes is used to create a feedback loop. This feedback loop informs decisions about how the model should evolve, adapt, or make real-time adjustments to optimize its performance.
Anomaly Detection: Probes can also help identify anomalies or deviations in the model's behavior, allowing for early detection of issues or concept drift (changes in data distribution).
Continuous Learning: In some cases, this process enables continuous learning or online learning, where the model learns from new data and improves its predictions over time without requiring periodic retraining.
Adaptive AI Systems: Such dynamic model adaptation is often crucial for adaptive AI systems, including recommendation engines, fraud detection, and natural language processing applications, where the model's effectiveness can change over time.
These dynamic probes and the continuous evolution of models at runtime are essential for ensuring that machine learning models remain accurate, up-to-date, and effective in handling changing data and user patterns. It's a fundamental aspect of maintaining the relevance and performance of AI systems.
So lets design an adaptive schedule
ChatGPT
Designing an adaptive schedule involves creating a plan or framework that can adjust and optimize itself based on changing conditions or requirements. Here's a high-level outline for designing an adaptive schedule:
Define Objectives and Goals:
Clearly state the goals and objectives of the schedule. What needs to be achieved, and what are the priorities?
Identify Variables and Factors:
Determine the variables and factors that may affect the schedule. These could include resource availability, project complexity, external dependencies, and more.
Data Collection and Monitoring:
Set up mechanisms to collect relevant data. This can be real-time data on project progress, resource utilization, or external factors that impact the schedule.
Create a Scheduling Algorithm:
Develop a scheduling algorithm that takes into account the defined objectives, factors, and collected data. This algorithm should be flexible and capable of making adjustments.
Set Thresholds and Triggers:
Establish thresholds or trigger points that indicate when adjustments are needed. For example, delays beyond a certain point may trigger rescheduling.
Adaptation Rules:
Define rules for how the schedule should adapt when triggers are activated. This could involve reassigning resources, changing timelines, or altering project priorities.
Scenario Planning:
Consider various scenarios and develop plans for how the schedule will adapt in response to each scenario. This allows for proactive responses to potential issues.
Testing and Validation:
Test the adaptive schedule in a controlled environment or with historical data to ensure that it responds as intended.
Feedback Loops:
Implement feedback mechanisms to continually assess the effectiveness of the adaptive schedule and make improvements over time.
Communication and Reporting:
Establish a communication plan to inform stakeholders of schedule changes and adaptations. Regular reporting helps keep everyone informed.
Documentation:
Maintain documentation that outlines the schedule, adaptation rules, and historical performance data.
Continuous Improvement:
Regularly review the adaptive schedule's performance and seek opportunities for improvement. Adaptation mechanisms can evolve based on lessons learned.
Adaptive scheduling is particularly useful in project management, supply chain management, and other domains where external factors and changing conditions can impact schedules. It helps ensure that plans remain relevant and goals are achieved even in the face of uncertainties.
Now lets imagine we have 20 bots all slightly different
ChatGPT
Having 20 slightly different bots can be an interesting scenario, especially in the context of automation, artificial intelligence, or robotics. Each bot's slight differences can serve specific purposes or adapt to various situations. Here's how you might envision such a scenario:
Diversity of Abilities: Each bot can have unique features or capabilities that make them suitable for particular tasks. For example, some bots might excel in data analysis, while others are optimized for physical tasks.
Specialization: Different bots may be specialized in various domains, such as customer service, industrial automation, medical tasks, or research.
Adaptability: The slight differences in each bot can make them adaptable to changing conditions. They may have sensors or AI algorithms that allow them to respond to different environmental cues.
Collaboration: The bots can work together as a team, with each contributing its specific expertise. They can communicate and coordinate to accomplish complex tasks.
Fault Tolerance: Redundancy in the form of multiple bots with slight differences can make the system more fault-tolerant. If one bot encounters an issue, another with a slightly different design can take over.
Machine Learning: The bots might employ machine learning techniques to adapt and improve their performance over time. Their differences could be a result of unique training data or fine-tuning.
Customization: The differences in the bots could be user-customizable or dynamically configured based on specific needs. Users might choose the right bot for the task at hand.
Resource Allocation: You'd need a system for managing and allocating these bots effectively, ensuring that the right bot is selected for each task based on its capabilities.
Security and Authentication: Security measures would be crucial to ensure that only authorized users or systems can control or interact with these bots.
Data Sharing: The bots can share and exchange data, allowing them to learn from each other and collectively improve their performance.
Having a fleet of 20 slightly different bots provides flexibility and adaptability, allowing you to tackle a wide range of tasks and challenges. The key is to design a system that effectively leverages their differences and ensures they work cohesively to achieve your objectives.
Now they are all forks of a common repo and have changes to 2 or more files
ChatGPT
If you have 20 bots that are all forks of a common code repository with changes to 2 or more files, you're essentially managing a distributed codebase with variations. This is a common scenario in software development and version control. Here's how you can manage such a situation:
Version Control System: Ensure you're using a robust version control system like Git. Each bot's codebase is a separate branch or fork of the common repository.
Codebase Management:
Maintain a clear organization of files and directories within the common repository.
Use branches or feature flags to manage variations among the bot versions.
Collaboration:
Encourage collaboration among bot developers. They can communicate and share ideas for improvements.
Merge changes from one bot into others when beneficial for the entire fleet.
Code Reviews: Implement code review processes to ensure that changes to the common codebase are well-vetted and don't introduce issues.
Automated Testing: Set up automated testing to catch issues early. Ensure that changes don't break the core functionality or stability of the bots.
Documentation: Maintain comprehensive documentation that describes the variations between bots, the rationale behind changes, and best practices for maintaining and updating them.
Continuous Integration and Continuous Deployment (CI/CD):
Automate the build and deployment process to ensure that changes to the common repository are propagated to all bot versions efficiently.
Conflict Resolution: Develop a process for resolving conflicts when changes to the same file affect multiple bot versions. Merge conflicts should be handled systematically.
Rollback Plan: Have a strategy for rolling back changes in case issues arise, especially if a change negatively impacts multiple bot versions.
Monitoring and Feedback: Continuously monitor the performance of the bots in the fleet. Gather feedback from users to inform future changes and improvements.
Release Management: Plan regular release cycles for updating the bots, considering both feature enhancements and bug fixes.
Security: Prioritize security. Ensure that security patches and updates are applied consistently to all bot versions to protect against vulnerabilities.
Managing forks of a common repository with variations is a common practice in open-source software development and multi-version software ecosystems. Effective version control, collaboration, and automation are key to maintaining the integrity and quality of the codebase while accommodating the differences among the bots.
So I intend on a static analysis and differenciation on profiled instructions relating to common output tokens
ChatGPT
Performing static analysis and differentiation on profiled instructions related to common output tokens is a complex but valuable task, often used in various fields like cybersecurity, code optimization, and performance profiling. Here's a high-level process for such an analysis:
Data Collection:
Profile instructions execution to collect data on how each bot executes code.
Record the instructions and their corresponding output tokens generated by each bot.
Normalization:
Normalize the collected data to create a consistent representation. This might involve converting instructions and tokens to a common format or data structure.
Tokenization:
Tokenize the output generated by the bots, breaking it down into individual tokens or components. This helps in comparing and analyzing the common tokens.
Static Analysis:
Use static analysis techniques to identify patterns and similarities in the collected data. For example, you can look for common sequences of instructions and common output tokens.
Differentiation:
Implement differentiation algorithms or techniques to compare and contrast the profiles of different bots. Identify where they diverge or converge in terms of executed instructions and generated tokens.
Feature Extraction:
Extract relevant features or characteristics from the profiles to facilitate differentiation. This could include statistical measures, sequence patterns, or other relevant metrics.
Clustering or Classification:
Use machine learning or clustering algorithms to group similar bots based on their profiles. This can help identify which bots behave more similarly to each other.
Visualization:
Create visualizations to represent the analysis results, making it easier to interpret and compare the differences and commonalities.
Feedback and Optimization:
Utilize the insights gained from the analysis to optimize and improve the bots. For example, you might identify bottlenecks in the instruction execution or areas where token generation could be enhanced.
Continual Analysis:
Implement a system for continual or periodic analysis as bots evolve over time. This ensures that your analysis remains relevant and up to date.
Security Considerations:
Be mindful of security implications, as analyzing code execution and profiles can reveal sensitive information. Ensure that any data collected and analyzed is handled securely.
Static analysis and differentiation of profiled instructions and output tokens can provide valuable insights into the behavior and performance of your fleet of bots, helping you identify areas for improvement, optimization, and differentiation among them. It's a powerful technique for managing a diverse set of bot versions.
Then we relate them to each other step by step in simulation
ChatGPT
Relating the bots to each other step by step in a simulation is a complex and dynamic process. You can create a simulation environment that allows you to explore how the bots interact and adapt. Here's how you might approach this:
Simulation Environment:
Set up a controlled simulation environment that mimics the real-world conditions or tasks your bots are designed for.
Initial State:
Start with an initial state where all the bots have the same code and parameters. This serves as the baseline.
Scenario Design:
Create different scenarios or tasks within the simulation environment. These can be variations in input data, environmental conditions, or user interactions.
Step-by-Step Execution:
Execute the simulation step by step, introducing variations or challenges in each step.
Divergence and Convergence:
Observe how the bots respond to each step. Note where they diverge in behavior due to their unique characteristics and where they converge in behavior due to their shared codebase.
Data Collection:
Collect data on the actions, decisions, and outcomes of each bot at each step. This data should include differences in executed instructions and output tokens.
Analysis and Visualization:
Analyze the collected data to identify patterns, commonalities, and differences. Visualizations can help in understanding and presenting the results.
Feedback Loop:
Use the insights from the simulation to feed back into the design and development of the bots. For example, if certain bots consistently perform better, consider adapting the code or parameters of others to align with the successful approach.
Iterate and Optimize:
Repeat the simulation with different scenarios, evolving the bots in response to what you learn. Continuously optimize their behavior and performance.
Long-Term Evolution:
Consider the long-term evolution of the bots. As they adapt and improve, the simulation can help you anticipate how they might behave in various scenarios over time.
User Feedback:
If the bots are interacting with users, gather feedback from real users to validate the simulation results and make further improvements.
Scale and Deployment:
Once you've optimized the bots, deploy them in real-world settings, leveraging the lessons learned from the simulation.
Simulation is a powerful tool for understanding how variations among bots affect their performance and behavior. It enables you to iteratively refine and optimize your bots based on the insights gained from controlled scenarios.
And we have benchmarks that they run
ChatGPT
Using benchmarks in conjunction with your simulation and bot fleet can be highly valuable. Benchmarks provide a standardized way to evaluate and compare the performance and efficiency of different bot versions. Here's how you can integrate benchmarks into your process:
Benchmark Selection:
Choose or design benchmarks that represent the types of tasks your bots are expected to perform. These benchmarks should cover a range of scenarios and challenges.
Incorporate Benchmarks into Simulation:
Integrate the selected benchmarks into your simulation scenarios. This allows you to systematically measure how well each bot version performs against these standardized tests.
Performance Metrics:
Define clear performance metrics that the benchmarks will evaluate. These metrics could include execution time, accuracy, resource utilization, and more.
Benchmark Execution:
Run the benchmarks as part of the step-by-step simulation. At each step, assess how the bots handle the specific benchmark tasks.
Data Collection:
Collect detailed data on the performance of each bot version with respect to the benchmarks. This data can be used for analysis and comparison.
Benchmark Analysis:
Analyze the benchmark results to understand how different bot versions compare in terms of their performance, efficiency, and adherence to your defined metrics.
Optimization:
Use the benchmark data to identify areas where specific bot versions may underperform or excel. Adjust the code or parameters of the bots based on these findings.
Regression Testing:
Incorporate benchmark tests into your regular testing and quality assurance process. This helps ensure that changes and updates to the bots do not negatively impact benchmark performance.
Competitive Benchmarking:
Consider benchmarking your bots against industry or market standards. This can help you understand how your bots stack up against competitors.
User Expectations:
Align benchmark results with user expectations. Your bots should not only perform well in benchmark scenarios but also meet real-world user requirements.
Continuous Improvement:
Regularly update your benchmarks to reflect changing requirements and technology advancements. This ensures that benchmarking remains relevant.
Transparency and Reporting:
Share benchmark results with stakeholders, users, and the development team. Transparency in benchmarking can build trust and guide improvements.
Using benchmarks alongside your simulation and profiling can provide a holistic view of your bot fleet's performance. It enables data-driven decision-making, helps identify bottlenecks, and ensures that your bots meet the desired quality standards.
And the benchmarks create new programs themselves that have profiles and outputs  we can also set into  relationship
ChatGPT
Creating benchmarks that generate new programs with profiles and outputs adds an additional layer of complexity and depth to your analysis. This approach can be used to simulate and evaluate how well your bots handle dynamic and evolving scenarios. Here's how you can incorporate this:
Benchmark Generation:
Develop a mechanism for generating benchmarks that create new programs with profiles and expected outputs. These benchmarks should cover a wide range of real-world use cases and challenges.
Execution and Profiling:
Run the generated benchmarks, allowing them to execute their programs with specific input data. Collect profiling data, including the instructions executed and output tokens generated.
Benchmark Comparison:
Compare the execution profiles and output tokens of the generated benchmarks with those of your bots. This provides insights into how well your bots adapt to new, unexpected scenarios.
Scoring and Evaluation:
Define scoring criteria for how well your bots handle these dynamic benchmarks. Consider aspects like correctness, efficiency, and adaptability.
Feedback Loop:
Utilize the benchmark results to adapt and optimize your bots based on how they perform against these dynamic challenges.
Automation and Continuous Testing:
Automate the benchmark generation and execution process to ensure that your bots are continuously tested against a wide range of evolving scenarios.
Scenario Evolution:
Regularly update and expand the benchmark scenarios to reflect changing conditions and new challenges.
Data-Driven Development:
Make development decisions based on the benchmark results, such as code optimizations, parameter tuning, and strategy adjustments.
Machine Learning Integration:
Consider using machine learning models to analyze the benchmark data and adapt your bots more intelligently over time.
Collaboration and Knowledge Sharing:
Encourage collaboration among the bot developers and data scientists to collectively improve your bots' performance in dynamic scenarios.
User-Centric Approach:
Keep in mind that your bots' ability to handle new, unexpected scenarios is ultimately for the benefit of users. Ensure that their needs and expectations are met.
Using benchmarks that generate new programs and scenarios helps you evaluate your bots' adaptability and readiness for unforeseen challenges. It's a powerful approach to ensuring that your bots remain effective and robust in dynamic real-world situations.
Then we inspect the divergence
ChatGPT
Inspecting the divergence between your bots in response to the benchmarks and dynamic scenarios is a crucial step in understanding how they adapt and identifying areas for improvement. Here's how you can inspect divergence effectively:
Divergence Metrics:
Define specific metrics or criteria for measuring the divergence between bot versions. This could include variations in execution times, output token differences, or any other relevant performance indicators.
Data Collection:
Collect detailed data on how each bot performs in response to the benchmarks and dynamic scenarios. Ensure that the data includes not only results but also contextual information.
Comparison and Analysis:
Compare the performance data of different bot versions to identify where they diverge. This might involve statistical analysis, visualization, and other data analysis techniques.
Pattern Recognition:
Look for patterns in the divergence. Are there specific scenarios or types of benchmarks where certain bot versions consistently outperform or underperform others?
Root Cause Analysis:
Dig deeper to understand the root causes of divergence. Are there specific code segments, parameters, or strategies that contribute to the observed differences?
Feedback Loop and Optimization:
Utilize the insights gained from divergence inspection to optimize the bots. Adjust the code, parameters, or strategies to address areas where divergence is undesirable.
Regression Testing:
Incorporate the benchmark scenarios that reveal significant divergence into your regular regression testing process. Ensure that divergence is tracked over time and addressed promptly.
User-Centric Evaluation:
Consider how the observed divergence impacts the user experience. Focus on minimizing divergence in areas that are critical to users.
Dynamic Adaptation:
Implement mechanisms for dynamic adaptation based on the observed divergence. For example, bots can adjust their strategies in real-time to reduce divergence.
Benchmark Updates:
Update the benchmark scenarios to continually challenge your bots with new, diverse, and evolving scenarios. This ensures that the divergence inspection remains relevant.
Collaboration and Knowledge Sharing:
Encourage collaboration among the development team, data scientists, and domain experts to collectively address divergence challenges.
Documentation and Reporting:
Maintain documentation of observed divergence, its impact on performance, and the steps taken to mitigate it. This information can be valuable for ongoing development.
By regularly inspecting and addressing divergence, you can ensure that your fleet of bots remains aligned with your goals and user expectations, even in the face of complex and dynamic scenarios. It's a critical aspect of maintaining the performance and adaptability of your bots.
And the profiles and dataflows and source code feeds into this process as well as user attention
ChatGPT
Absolutely, incorporating profiles, data flows, source code, and user attention into the process of inspecting divergence adds additional layers of understanding and optimization to your bots. Here's how each of these elements contributes to the process:
Profiles:
Profiles of bot behavior, including executed instructions, resource utilization, and response times, provide essential data for understanding how bots perform under different scenarios. Analyzing profiles can help pinpoint performance bottlenecks and areas of divergence.
Data Flows:
Data flow analysis can reveal how data is processed and transformed within your bots. Identifying differences in data flows between bot versions can highlight where divergence occurs and guide optimization efforts.
Source Code:
Inspecting the source code of bot versions is crucial for understanding why divergence happens. Code differences, such as variations in algorithms, logic, or data handling, can directly impact how bots respond to benchmarks and dynamic scenarios.
User Attention:
User feedback and attention are valuable sources of information. User interactions and feedback can reveal issues or areas of divergence that may not be apparent through automated analysis alone. Paying attention to user concerns is essential for aligning bot behavior with user expectations.
Data Integration:
Combine data from profiles, data flows, source code analysis, and user feedback into a unified view of your bots' behavior. This integrated data helps identify patterns and correlations related to divergence.
Feedback-Driven Optimization:
Leverage both user attention and data-driven insights to drive optimization. Prioritize optimization efforts based on user feedback and real-world use cases.
Dynamic Adaptation:
Use the integrated data to implement dynamic adaptation mechanisms that allow bots to adjust their behavior based on profiles, user feedback, and evolving code.
Visualization and Reporting:
Visualize the combined data to provide a clear and comprehensive picture of how divergence impacts the bots' performance. Reporting helps inform stakeholders and decision-makers.
Collaboration:
Collaboration among development teams, data scientists, and users is essential. Knowledge sharing and collaboration enable a more holistic approach to addressing divergence issues.
Continuous Learning:
Implement a culture of continuous learning and improvement. Bot behavior and performance can evolve over time, and staying attuned to profiles, data flows, source code, and user feedback ensures continuous optimization.
By incorporating profiles, data flows, source code analysis, and user attention into the process, you create a robust framework for addressing divergence and optimizing your bot fleet. It allows you to identify, understand, and respond to divergence more effectively, ultimately leading to better bot performance and user satisfaction.
Continue this conversation
Report content
|
Terms of use
|
Privacy policy
"
https://chat.openai.com/share/77f38fb8-ba01-4fbe-8bb8-1e1dcdfa5f2a#:~:text=Shared Chat,Privacy policy


Consider migrating to CrossEcore

Ecore.js is unmaintained and quirky

CrossEcore doesn't look like it's being developed much. Given that we'll integrate with LionWeb, and it will provide Ecore integration, I think we can close this.


Add different idle options based on profile

Use case:

when only the screen laptop is connected, lock the screen after 5 minutes, suspend after 10
when I'm using the monitor at home, lock after 30 minutes, never suspend
when I'm using the monitor at the workplace, lock after 5 minutes, never suspend.

This would actually require the integration of swayidle into kanshi.

Just an idea, but: instead of doing this inside kanshi, why not allow getting the current profile name or whatever via kanshictl (assuming https://github.com/emersion/kanshi/pull/52 gets merged)?

Yea, it could be done. But if power management is tighted to screen profiles, why not handling this in kanshi directly?

I agree with @ammen99. I don't think monitor management is related to power management.


add faceting settings

Codecov Report

Merging #273 (a67ba6b) into main (2aba006) will not change coverage.
The diff coverage is 100.00%.

@@            Coverage Diff            @@
##              main      #273   +/-   ##
=========================================
  Coverage   100.00%   100.00%
=========================================
  Files           14        14
  Lines          780       795   +15
=========================================
+ Hits           780       795   +15

Impacted Files
Coverage Δ

meilisearch_python_async/index.py
100.00% <100.00%> (ø)

meilisearch_python_async/models/settings.py
100.00% <100.00%> (ø)

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 2aba006...a67ba6b. Read the comment docs.


[BUG] 60 fps only so every bloxstrap user i find is only running at 60 fps is this able to be fixed?

Acknowledgement of preliminary instructions

[X] I have read the preliminary instructions, and I am certain that my problem has not already been addressed.
[X] I have thoroughly looked through the available Wiki articles and could not find a solution to my problem.
[X] I am using the latest version of Bloxstrap.
[ ] I did not answer truthfully to all the above checkboxes.

What problem did you encounter?
so i was contacting other bloxstrap users and every bloxstrap user is running at 60 fps is this able to be changed and fix
Bloxstrap Log
No response

Are you from the discord server.

no im not

Good.
Anyways, are you playing on a laptop?

yes am

You need to change your power settings then.
Laptops, gaming included, cap games at 60 FPS to not make the battery die.

OH thank you so much everyone i contacted had a laptop so thats my fault

You're welcome.

im running at 120 fps thanks

dude
https://github.com/bloxstraplabs/bloxstrap/wiki/Roblox-is-still-capped-to-60-FPS-after-raising-the-limiter


Add okta apps delete command

First pass at adding an application delete command
NOTE: Currently this command WILL also deactivate the application.
TODO:

[x] Add Tests!
[x] Figout how to deal with [de]activation.  These could likely be separate commands okta apps deactivate/okta apps activate

Usage:
Usage: okta apps delete [-fhV] [--batch] [--verbose] <appIds>...
Deletes an Okta app
      <appIds>...       List of application IDs to be deleted
      --batch           Batch mode, will not prompt for user input
  -f, --force           Deactivate and delete applications
  -h, --help            Show this help message and exit.
  -V, --version         Print version information and exit.
      --verbose         Verbose logging

Example:
okta apps delete -f my-app-id

or without the -f the user would be prompted:
Deactivate and delete application '0oaqkajn1qnUlRYQ30h7'? [y/N]y
Application '0oaqkajn1qnUlRYQ30h7' has been deleted

Any update on this feature? I'd use it every day!

It's ready to go, we can stick it in the next release.
I just resolve the conflicts to kick of CI (done through the browser, so I might need to tweak it after)


v5 Roadmap

This is a WIP issue to track potential changes for the next major version.

[ ] Remove propTypes from core
[ ] Add optional package for React propTypes
[ ] Remove conversion of unitless numbers into pixels (most CSS-in-JS libraries support this by default now)
[ ] Setup monorepo with Yarn workspaces and Lerna
[ ] Split style functions into separate packages #281
[ ] Create separate variants package
[ ] Create separate propTypes package
[ ] Create utilities package with themeGet, etc
[ ] Remove support for implicit breakpoints
[ ] Use sizes key per the Theme Specification
[ ] (Under consideration) remove fractional width support – if you make use of this feature, please speak up
[ ] Move experimental css and/or JSX pragma packages into monorepo
[ ] Move should-forward-prop package into monorepo

Notes

For the monorepo setup, and all-in-one package should be created to make migration from v4 to v5 as easy as possible

cc @neoziro

@jxnblk what about writing it in TypeScript?

This all sounds great to me! Totally on board with splitting up different concerns and extra features into separate packages to keep the weight of core down.

Remove support for implicit breakpoints

Does this mean adding a 0 breakpoint for mobile-first architectures?

(Under consideration) remove fractional width support – if you make use of this feature, please speak up

I'd be curious why it's under consideration? I'm assuming because it removes some complexity from the codebase? I make heavy use of the feature but am definitely not opposed to removing it. More curious than anything.

I think @neoziro can elaborate on the breakpoints some more, but I think it means that object values must use defined keys for breakpoints as opposed to using undefined keys for the non-scoped styles. I assume this isn't a change to how array values are parsed
The thinking with width is that it's one of the few odd-balls in here. I do like it, but it does behave quite differently from the rest of the props. The other issue is that if width supports a theme.sizes scale, then 1 would be ambiguous as to whether it references 100% or theme.sizes[1]. I'm still not sure what the best approach here is, so would love to hear more people's thoughts

@jxnblk One of my biggest frustrations in styled system currently is the lack of a width key.  It becomes super awkward when having to make something a perfect square (or circle with added border radius).  Perhaps I simply haven't seen how to do this correctly, but I end up having to use something like themeGet to set the width based on my heights key in my theme... ugly.
Is there a better way?
Likewise, and I should mention this is my own problem, I haven't found a way in my code editor to do fractions without my autocomplete plugin thinking I'm trying to write a self-closing tag.  This can be frustrating when writing JSX where I write a shit-ton of self-closing tags.  Simply writing 1/2 ends up writing 1/>2 every time.  I can't figure out how to turn this off or make the autocomplete plugin more intelligent, so I just deal with it.
While it's definitely not preferable to write absurd decimal places (0.333333.......) instead of 1/3, perhaps there's room to actually turn these units into their own scale.  In my opinion, this would likely have to be a named scale.  Perhaps something like the following:
widths: {
  full: 1,
  half: 0.5,
  third: 0.3333,  // I mean, do I really need another 3 here?
  fourth: 0.25,
  sixth: 0.1666,
  twoThirds: 0.6666,
  threeFourths: 0.75,
  // I rarely use beyond these in a 12-column system anyhow
},
// ... rest of my theme file

The other issue is that if width supports a theme.sizes scale, then 1 would be ambiguous as to whether it references 100% or theme.sizes[1].

Barring my example proposal from above, the easy solution here would be to have styled system's internal parser just look for a standard unit of measurement inside the value.  For instance, if your value ends in %, px, em, or some other obvious measurement, then use it as such... otherwise reference the theme.  I don't think you'd find that many users that would have a use case beyond that.

Actually, with my PR, if you define widths: [0, 20] in theme, width={1} will be width: 20px;. I think it is the expected behaviour. Also using array to describe properties is often not good. So prefer objects and all will be fine!

@neoziro I think that's actually the kind of problem @jxnblk was trying to avoid.  Perhaps I misunderstand...
Although I definitely agree that if there's going to be a widths key in the theme that it shouldn't be array based.

Yeah I know, but I think they can't be avoided, @jxnblk what do you think?

I put out a pseudo-proposal in my previous on how we might avoid this problem.  I'm happy to elaborate on it further if need me (or pick up a PR).  Either way, happy to help in whatever direction styled-system goes in!  😄

Just wanted to pop in here and say that me and my team makes major use of fractional widths!

To be clear we are not talking about fractional width. Just about « 1 » that will not be 100% if you provide a key with another thing in theme.widths.

I use fractional widths. They are intuitive and expressive. Setting up a width key feels like over-configuration to me. Use whatever widths work for your design, let your build process do the rest.

I support the move to remove fractional widths. While I love its simplicity, it feels inconsistent with how the rest of Styled System works.
More troubling than inconsistency is the fact that it kinda blocks the introduction of a width scale (since 1 can mean 100% or size[1]). Coming from Tachyons, I was very surprised when I discovered this functionality was not built in and ended up having to create my own using the style utility.

@jxnblk What would you think instead about offering a width key on the theme just like height, maxWidth, maxHeight, etc... allowing for people to set their width as a prop just like any other key in their theme.  You could also then have a fWidth and/or fractionWidth prop that doesn't correspond to any key on the theme, but offers the existing width functionality with fraction support.  While I certainly think fractional widths have their place, particularly when writing a grid system in styled-system, I've found numerous occasions in creating my own UI library that demand some sort of width key theme support.
If you'd like, I would be happy to write a PR on such a spec.

@cereallarceny I think the plan is to use the theme.sizes scale for all dimensions, like outlined in the theme spec. If fractional widths are still supported in the next version, then maybe 0 and 1 would reference e.g. theme.sizes[1] and use that value if it exists

Perfect!  I hadn't seen the link posted in your first message (I suppose you added it after I first replied to this thread).  I like what you're proposing in there @jxnblk - is there some way to contribute to the v5 rewrite?  I'd love to work on some of the issues you outline above, including converting height, width, and max/min height/width over to a spaces key... how could I get started?

Either way @jxnblk, I don't think fractional widths have to be lost for good.  We could just add a fractionalWidth prop with an fWidth alias.  I can't imagine that adding much, if any, reasonable overhead to the library.  It would allow users to support both and would allow existing users who enjoy fractional width an easier path to upgrading.  At least, it would sure lessen the breaking changes involved in upgrading.

@cereallarceny I'm refactoring the core code base with v5 – should have a PR up before long. As for something like a fractionWidth prop, it's an interesting approach, but would mean a breaking change for everyone currently using v4 (and potentially a lot of prop name changes), and I'd rather keep the upgrade path as simple as possible

Fair, but wouldn't it already be a breaking change if you're dropping
fractional width support on the width prop anyhow?
On Mon, May 27, 2019 at 8:10 PM Brent Jackson<EMAIL_ADDRESS>wrote:

@cereallarceny https://github.com/cereallarceny I'm refactoring the
core code base with v5 – should have a PR up before long. As for something
like a fractionWidth prop, it's an interesting approach, but would mean
a breaking change for everyone currently using v4 (and potentially a lot of
prop name changes), and I'd rather keep the upgrade path as simple as
possible
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/styled-system/styled-system/issues/475?email_source=notifications&email_token=AAJ44CSNWBRDF4JGN4O3263PXQWY5A5CNFSM4HJMY3OKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGODWKMBJY#issuecomment-496287911,
or mute the thread
https://github.com/notifications/unsubscribe-auth/AAJ44CXD4RFAR2TR6FPIWG3PXQWY5ANCNFSM4HJMY3OA
.

Closing this and tracking in #513


Upgrade Vulnerable Library Dependencies

Signed-off-by: xuezhaojun<EMAIL_ADDRESS>Related contents:
https://github.com/kubernetes/kubernetes/issues/100096 shows the first issue can be solved by v1.20.6
https://github.com/kubernetes/kubernetes/issues/104980 shows the second issue can be solved by v.1.20.11
We choose upgrade to v1.20.11 to cause minimal impact.

the k8s.io/kubernetes will be removed in the #85, we can wait that pr merged

#85 will solve vulnerable dependencies issues. This pr is ok to close.


[4.3.0] Upgrade the rest api versions in APIM

Description
Rest API versions will be modified as bellow
publisher : v4--> v4.1 (major version: v4 , latest version : v4.1)
admin : v4 --> v4.1 (major version: v4 , latest version : v4.1)
devportal : v3 --> v3.1 (major version: v3 , latest version : v3.1)
gateway : v2.2 --> v2.3 (major version: v2 , latest version : v2.3)
serviceCatelog : v1.1 --> v1.2 (major version: v1 , latest version : v1.2)
devops : v0 --> v0.1 (major version: v0 , latest version : v0.1)
Affected Component
APIM
Version
4.3.0
Related Issues
No response
Suggested Labels
No response

Closing since the PR is merged


@Chapter Node Handling?

I thought that there is chapter handling, but I don't see a way to select chapters.  Also, when I tried to hoist an @chapter node, I got this message:
can not hoist an @chapter node
Since the main point of having chapters is to be able list them and hoist them, This is disappointing.

@tbpassin Thanks for your interest in accessibility of the 'chapter' related commands! 😄 yes, there is chapter handling in LeoJS.
Every commands were transliterated directly from Leo's original python code.
All command icons will soon have their visibility and placement 100% customizable instead of being forced above the outline and body pane following completion of https://github.com/boltex/leojs/issues/72.
In the meantime, they are easily accessible when starting to type the word 'chapter' in either the minibuffer Alt+X or VSCode's command palette CTRL+SHIFT+P (command palette has most commands, while the minibuffer has all commands)

You can also access them with the 'chapter-select' icon button, located above the body pane:

and all chapter related commands are also above the 'find panel' and the 'goto panel':

Lastly, The can not hoist an @chapter node message when trying to hoist an @chapter node is consistent with Leo:

So all in all, the only place the chapter command icon is not is above the outline pane... (there is a maximum number of icons allowed in vscode above each panels) Hope this helps ! 😄

Closed in favor of #72 which will allow personal preferences for specific command-icons over any panel.


subprocess-exited-with-error

Thank you for this package, I tried installing Velorama using
pip install velorama
But I get this error:
error: subprocess-exited-with-error
python setup.py egg_info did not run successfully.
exit code: 1
[8 lines of output]
Traceback (most recent call last):
File "", line 2, in
File "", line 34, in
File "C:\Users\ahmed\AppData\Local\Temp\pip-install-sgrrhble\sklearn_fa38950c8574492da0c4cb7e252dd14d\setup.py", line 10, in
LONG_DESCRIPTION = f.read()
File "C:\Users\ahmed\miniconda3\envs\my_project\lib\encodings\cp1252.py", line 23, in decode
return codecs.charmap_decode(input,self.errors,decoding_table)[0]
UnicodeDecodeError: 'charmap' codec can't decode byte 0x8f in position 7: character maps to
[end of output]
note: This error originates from a subprocess, and is likely not a problem with pip.
error: metadata-generation-failed
Encountered error while generating package metadata.
See above for output.
note: This is an issue with the package mentioned above, not pip.
hint: See above for details.

I tried to upgrade pip, wheel, setuptools, but it didn't work.
Any help will be appreciated
Thank you

I solved the problem by installing sklearn 0.0
pip install sklearn==0.0
followed by
pip install velorama

I solved the problem by installing sklearn 0.0
pip install sklearn==0.0
followed by
pip install velorama


Support native-base?

Hi, is there any way I can use custom NavBars, like the one from native-base for example?

Native base needs to provide a nav bar compatible with React Navigation. Please file an issue on Native Base repo.

How do I customize the navbar in general? The one that comes inbuilt with react-navigation? If I want to add some additional buttons to it, how do I do it?

Please check the docs https://reactnavigation.org/docs/navigators/stack

Thank!


Fix link in README.md

i18next.com doesn't work, changed to www.i18next.com

Thank you, will merge on next release 👍


Pr217plus/master with fixes

parallel with AndrewAnnex

Changes Unknown when pulling 2560a5f015ce8a24d282050d2ebb49afe61042de on pr217plus/master-with-fixes into ** on master**.

Changes Unknown when pulling 2560a5f015ce8a24d282050d2ebb49afe61042de on pr217plus/master-with-fixes into ** on master**.

Changes Unknown when pulling 2560a5f015ce8a24d282050d2ebb49afe61042de on pr217plus/master-with-fixes into ** on master**.


Removed Fixnum deprecated warning + Added TravisCI

As of Ruby 2.4.0, Fixnum has been deprecated and replaced with Integer. This was causing the following warning to be logged:
glutton_ratelimit-0.2.0/lib/glutton_ratelimit.rb:26: warning: constant ::Fixnum is deprecated

This PR removes this warning in a backwards compatible manner.
I've also added TravisCI configuration.

Hi James. Very sorry I didn't see this PR way back in March 2018.
Thank you kindly for this contribution. I have merged it and will release a new version of the gem later this week.

@stungeye No problem 👍


LM-1166 SAML - CI Pipeline for Mock IdP - Create CodeBuild buildspec.yml

adding buildspec commands to be used with Docker environment, installing
java 9 & maven 3.5.2.
building the mock IdP docker image and pushing to ECR

Codecov Report

Merging #15 into master will not change coverage.
The diff coverage is n/a.

@@            Coverage Diff            @@
##             master      #15   +/-   ##
=========================================
  Coverage     94.41%   94.41%
  Complexity      189      189
=========================================
  Files            27       27
  Lines           555      555
  Branches          7        7
=========================================
  Hits            524      524
  Misses           27       27
  Partials          4        4

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 110cbb1...6dc2489. Read the comment docs.

yml file looks good. CB project runs to completion, so all good from my point of view.
This is a MVP so I think it's about right. Optimise later if needed.


Add an overview of optimisation tips (such as apply_to_buffer)

I presume a lot of people will be coming from the Python side of Polars. Creating a list of best practices and often used optimisations could help improve the performance of plug-ins written by people not too familiar with Rust yet. (Me included!)

thanks @TNieuwdorp ! wip (and pending a new rust polars release) but there's a page about this being written here https://github.com/MarcoGorelli/polars-plugins-tutorial/pull/32


fix class Matcher.py: test naming, using of fnmatch.translate, side-effects and version compatibility

Hi.
Matcher class uses fnmatch.translate function, but this function uses square brackets for special cases and don't escape these symbols so robot test cases having square brackets as a part of their names cannot be used with new robot framework versions because these brackets are also recognized as parts of regular expressions.
This test named as [1st_file]Multi_xml_file is passed with previous framework versions
Before patching:
unexpected error: [ ERROR ] Suite 'StaCAMT052SplitMultiFile' contains no tests matching name 'StaCAMT052SplitMultiFile.Split Multifile.[1st_file]Multi_xml_file' in suite 'StaCAMT052SplitMultiFile.Split Multifile'.
test=stacamt052splitmultifile.splitmultifile.[2ndfile]multixmlfile
pattern=stacamt052splitmultifile\.splitmultifile\.[2ndfile]multixmlfile\Z(?ms)
After patching the test is successfully passed.
test=stacamt052splitmultifile.splitmultifile.[2ndfile]multixmlfile
pattern=stacamt052splitmultifile\.splitmultifile\.\[2ndfile\]multixmlfile\Z(?ms)
The reason is used square brackets. [2ndfile] is any character, but only one.
You can use any other solution instead of mine. Please, fix the problem.

The support for [...] patterns was added on purpose by #2471. As you can see from my comment in that issue, we knew that the change isn't fully backwards compatible, and this was also mentioned in the RF 3.1 release notes. These notes also explain you can use ? in the place of [ as a workaround.

The problem exists only for RIDE because tests named with square brackets cannot be launched individually at all. They just don't exist without any obvious reason for Robot Framework. I think you could throw an exception or a warning about forbidden characters.

That sounds like an annoying problem in RIDE. But that problem should be fixed in RIDE, not in Robot.


Extra Resources Resources

LLDB: A reimplimentation of GDB targeted at LLVM based systems, useful for debugging on Mac (also has a nicer UI than GDB)

MicroCorruption: Embedded System CTF, good for learning the basics of ASM

Resolved in commit c200c25


Short Break : NaN minutes

Hello,
When I arrive to the Short Break period, I have this NaN : NaN.
My version is 2.8.4-beta
Hoping this is simple to fix,
Good luck

@KiloNovemberDelta I experienced that too after the updates.
I suggest that just restore the default config and try to see if it's working. 👍

I have uninstall and reinstall the software, let the default config as it is. But still doesn't work.. 👎


Feature Request: Grey out {A} or equivalent

It would be great if the {A} or equivalent could be greyed out or hidden in some way so that it is clear that it is not part of the list when in live edit mode.
Thanks for the brilliant plugin!

I'll have to read up on editor extensions to be able to do this. It may be a bit until I get around to it.


Imag Path on Server (question)

I having trouble getting an Image working on my server.
The direct path generated with the {{ url }} / to my image is working fine.
but i does not showig up. i get "Image not found or type unknown" and a outlined box.
local enviromet works fine.
app/config.php has the correct server name too.
any help would be appreciated

I replace all relative links with the absolute on.
Works fine for me for generating pdf's with inline images with HTML editor
// HTML
$htmlContent = ...

// Get domain
// => http://example.com
$url = url('/');

// Replace all src with url+src
$replacedContent = preg_replace( '/src="\/([^"]*)"/i', 'src="'.$url.'/$1"', $htmlContent);

$data = ['title' => $title, 'content' => $replacedContent];

return PDF::loadTemplate($templateCode, $data)->stream();

give it a try.

Check that allow_url_fopen is set to true and that the GD extension is enabled in your PHP configuration.

So i checked in my Plesk Backend, allow_url_fopen is true
the option ->setOptions([
'isRemoteEnabled' => true,
]) is now set,
the path is hardcoded (not the twig one)
and still not working
i assume that GD is enabled, thumbnail creation is working.
// the server is currently protected by .htaccess login during development that should be not a problem ?

I don't know the reason why this is not working for you.
You will have to debug this on your own. Output the path to the image file in your PDF and try different approaches with relative/absolute paths and make sure that the image file is located there.

checked one hour with the hosting agency on that issue, compared local and online Environment. double checkt nearly evertything. the plugin won't create images in the pdf! any idea ?

if i put the filename in like this /var/www/vhosts/myiste.de/www1.mydomain.de/storage/app/media/_mediathumbs/highres_no-logo-01-4711.p02.MyImage-Charcoal-c456b41e73b2518273eeb6c1cd97ff1f.jpg
i see a image in the pdf. (online)
further i noticed that the retuned value from $_SERVER['DOCUMENT_ROOT'] differs
on local maschine i have  a ending slash - online not
if i use the {{ product_image.image_filename |mediathumb_resize('width', 600, 96) }}
i get  storage/app/media/_mediathumbs/highres_no-logo-01-4711.p02.MyImage-Charcoal-c456b41e73b2518273eeb6c1cd97ff1f.jpg which is ok. but it wont render in the PDF
so my hardcoded logo with the complet epath on the maschine works fine.
there is an issuse somewhere - any idea ?

Probably allow_url_fopen is disabled on your hosting and this not allows to render image with http://.
Everything depends on your host configuration, there is no issue with PDF library here. There are functions like base_path() that will render full path on your server.

Reference: https://github.com/mplodowski/dynamicpdf-plugin/issues/42


fixing typos

Hi @4c74356b41, I'm your friendly neighborhood Azure Pull Request Bot (You can call me AZPRBOT). Thanks for your contribution!

This seems like a small (but important) contribution, so no contribution license agreement is required at this point. Real humans will now evaluate your PR.

TTYL, AZPRBOT;

@4c74356b41 : Thanks for your contribution to the Azure documentation! The author, @stevestein, has been notified to review your proposed change.

@4c74356b41 - Thanks for catching these and taking time to submit the fix!
@tysonn - This PR is ok and ready to merge.
#sign-off


Built applications force discrete GPU usage

<key>NSSupportsAutomaticGraphicsSwitching</key>
<true/>

needs to be added to plist template.
Refer as well to:
https://bugs.openjdk.java.net/browse/JDK-8041900
https://bugs.openjdk.java.net/browse/JDK-8132759
http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8041900
http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8132759
Starting with java 8u76 the plist option will have proper effect (verified on 8u76 beta 4).

Fixed in #26. Thanks.


Motif is able to figure out how to apply your theme automatically

Hi! What exactly does this mean?
Thanks.

@oleynikd is this the same question as #22 or a separate question?

No. It is quote from README file. I just wanted to know what exactly you mean by 'automatically'?

@oleynikd the rest of the sentence reads:

...by matching Motif property names to Objective-C property names

This means that when you apply a class from your JSON theme to an object, Motif uses property reflection to introspect the properties on the object's class in the runtime to create a list of its properties. It then iterates through this list of properties, and when it finds a theme property name that matches a class property name, locates the appropriate NSValueTransformer subclass to transform the JSON value to a type suitable to be set as the value for the property (NSString → UIEdgeInsets, for example), and then finally sets those properties on objects when able.
However, you still must invoke applyThemeClass:toObject: yourself. Does that answer your question?

Yes, thanks!
It would be great if there were some detailed tutorials...
GREAT WORK!!! THANKS YOU!!!

Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: ''UITableView' doesn't have a theme applier for the property 'backgroundColor' or doesn't implement the keypath 'backgroundColor'. You must support one of them.'
Why can't backgroundColor be 'automatically' applied to UITableView without UITableView+Theming applier?

@oleynikd backgroundColor, while declared as a property on the UIView headers, is not actually a property. This is due to the following:

The properties declared in the public headers for UIView aren't actually declared as properties in the source used to build the UIKit, so they're not actually stored as such in the ObjC runtime information in the binary. i.e. there are a bunch of getter/setter methods, and for the public headers they've just added property declarations instead of method declarations for brevity. If they really were properties, they would show up via class_copyPropertyList(), even if they were declared in categories.

From http://stackoverflow.com/questions/848636/objective-c-2-0-class-copypropertylist-how-to-list-properties-from-categorie

Got it. Thanks.


2646 - fix tablet design

https://cabidev.atlassian.net/browse/VS-2646

approved here:
https://github.com/molnartimi/jitsi-meet/pull/84


A few links

With the new design we should add a link to Open Source and a link to esri github.

👍  i have a link to the first in the mission statement, it just needs to be more prominent.
the link in the footer should be updated (so that it doesn't just redirect back to esri.github.io) and a note should be added below the showcased cards saying something to the effect of 'browse all esri projects on github'...


Don't bury manual anchor links under top nav

Fixes #1451.
PTAL, @rmloveland.

This change is

Online preview: http://cockroach-docs-review.s3-website-us-east-1.amazonaws.com/42f3e47187ea81853d20328b9eb59acc365c2792/
Edited pages:

v19.1/start-a-node.md

@rmloveland, direct link to the new --max-offset anchor: http://cockroach-docs-review.s3-website-us-east-1.amazonaws.com/42f3e47187ea81853d20328b9eb59acc365c2792/v19.1/start-a-node.html#flags-max-offset

css/customstyles.css.map, line 3 at r1 (raw file):
Previously, rmloveland (Rich Loveland) wrote…
OMG this is terrifying - I assume it's being autogenerated by something in our Jekyll build?  I will go ahead and assume it's fine. :-)

Haha, yeah, it has to do with transforming scss to css, I think, but I don't really know. I just follow the instructions here, which @j-low helped put in place, I think, or perhaps Nikhil: https://github.com/cockroachdb/docs/wiki/CSS-Changes

Online preview: http://cockroach-docs-review.s3-website-us-east-1.amazonaws.com/ffe3a0e66a4c7ead8db25e6b4a09ac5dff168bbf/
Edited pages:

STYLE.md
v19.1/start-a-node.md

Online preview: http://cockroach-docs-review.s3-website-us-east-1.amazonaws.com/a610eedef474661d799a6fbad0d9f0ddf07d73e4/
Edited pages:

STYLE.md
v19.1/start-a-node.md


Improvement contributing.md

SUMMARY

using Python3 embeded venv libary
fix typo

ADDITIONAL INFORMATION

[ ] Has associated issue:
[ ] Changes UI
[ ] Requires DB Migration.
[ ] Confirm DB Migration upgrade and downgrade tested.
[ ] Introduces new feature or API
[ ] Removes existing feature or API

Codecov Report

Merging #10859 into master will decrease coverage by 4.41%.
The diff coverage is n/a.

@@            Coverage Diff             @@
##           master   #10859      +/-   ##
==========================================
- Coverage   65.57%   61.16%   -4.42%
==========================================
  Files         809      380     -429
  Lines       38038    24068   -13970
  Branches     3561        0    -3561
==========================================
- Hits        24945    14720   -10225
+ Misses      12987     9348    -3639
+ Partials      106        0     -106

Flag
Coverage Δ

#cypress
?

#javascript
?

#python
61.16% <ø> (-0.19%)
:arrow_down:

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files
Coverage Δ

superset/db_engine_specs/presto.py
73.54% <0.00%> (-8.75%)
:arrow_down:

superset/examples/world_bank.py
97.10% <0.00%> (-2.90%)
:arrow_down:

superset/examples/birth_names.py
97.36% <0.00%> (-2.64%)
:arrow_down:

superset/models/core.py
88.05% <0.00%> (-0.28%)
:arrow_down:

superset/connectors/sqla/models.py
89.61% <0.00%> (-0.14%)
:arrow_down:

superset/views/core.py
74.46% <0.00%> (ø)

...dashboard/components/resizable/ResizableHandle.jsx

...ontend/src/dashboard/components/menu/HoverMenu.jsx

superset-frontend/src/showSavedQuery/index.jsx

.../src/explore/components/ControlPanelsContainer.jsx

... and 425 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update 136f90f...0db3f5b. Read the comment docs.

Thanks for catching!


Feature Request:  allow alternate location for config and data (persistent) files

Is it possible to modify this code to allow a different path to the config, and to point to a different location for saving any files needed to persist between instances?  This would easily allow the project to be run from a docker container with a volume (bind mount) for the config and other persistent files.

@jeff47 - The config_dir variable is meant for that: https://github.com/geerlingguy/internet-pi/blob/master/example.config.yml#L3
You can set it to anywhere you'd like (it defaults to the current user's home directory), and back up all the data there. Any of the Docker volumes can be backed up using normal Docker methods—though I'm also planning on adding more docs around how to do good backups for anything persistent in this issue: https://github.com/geerlingguy/internet-pi/issues/7


Applied shiftview patch

I deleted the previous PR before updating to 6.4, so here it is again. This patch switches to the left/right tag, with Super + Left/Right arrow keys.

@siduck bump :slightly_smiling_face:.


single build.js

Hi guys,
For some reasons, the end of the day, I need just only one "build.js" file. Like same as preact-boilerplate. Is there any parameter for that?

preact build --param
I want: index.html, style.css, build.js

And then my tasks,

gulp build
will merge into index.html

Right now you'd have to add a preact.config.js to your project with the following:
export default (config, env, helpers) => {
  // get all rules:
  let rules = helpers.getRules(config);
  // find the `async!` rule:
  let asyncRule = rules.filter( ({ rule }) => /async-component-loader/.test(rule.loader) );
  // turn it off:
  asyncRule.test = () => false;
};

I changed the name of routes folder and worked. thanks.


Add support for automatically selecting (at run-time) the latest available release of Juliaup

The idea is that the user could do e.g.
- uses: julia-actions/install-juliaup@latest
  with:
    julia-version: '1'
    internal-juliaup-version: 'latest'

And then we automatically look up the latest available release of Juliaup, and use that. So the user doesn't have to hardcode the version number of Juliaup.
We can even make latest the default value for the internal-juliaup-version input, allowing the user to do this:
- uses: julia-actions/install-juliaup@latest
  with:
    julia-version: '1'

We could upload the latest portable archive to a stable URL on S3, and then this action could always get the Juliaup binaries from that URL, and it would always be the latest version without any need to update things here.

It occurs to me: we don't actually need to host the full archive somewhere. We actually only need to host a text file (on a JuliaLang domain) that contains the version number of the latest stable release of Julia. Then, in this action, we can:

Download that text file and extract the version number.
Interpolate that version number into the https://github.com/JuliaLang/juliaup/releases/download/v${juliaup_version}/juliaup-${juliaup_version}-${triplet}-portable.tar.gz URL.
Download the Juliaup archive from the GitHub releases URL.


Use BackupAgent to sync preferences

I added a BackupAgent in my fork for the advanced settings. Some notes in my commit message, mostly around using the default preferences and the hack-ish way of accessing the name so it can be backed up as well as handling the backup api key.
Not sure what the thoughts are around backing up the selected source. Not sure how much of a guarantee it is external sources are restored along with Muzei.
novak/muzei@ed1a3fadc9fbb3cdcb6fcbb49a4a3578974b4f0d

I added a BackupAgent in my fork for the advanced settings. Some notes in my commit message, mostly around using the default preferences and the hack-ish way of accessing the name so it can be backed up as well as handling the backup api key.
Not sure what the thoughts are around backing up the selected source. Not sure how much of a guarantee it is external sources are restored along with Muzei.
novak/muzei@ed1a3fadc9fbb3cdcb6fcbb49a4a3578974b4f0d

Nice, thanks dude :)


Second load of world crashs and "luna" planet is deleted in planetDefs.xml

Version of Advanced Rocketry
Advanced Rocketry 1.16.5-1.7.1-4 build -4 for 1.16.5
Version of LibVulpes
LibVulpes 1.16.5-1.0.1-6 build -6 for 1.16.5
Version of Minecraft
1.16.5
Crash report
https://paste.ee/p/JYmfa
Description of the problem
Create a world, save world, load second time, crash. After crash in planetDefs.xml (in saves folder) the dimension "luna" is deleted.

Luna vanishing should be fixed by 0e9d3ea068337b3440cc8bcdfc14b48c893d4594

There were a bunch of changes involving syncing planet data in both single and multiplayer, one of those may have fixed this issue, could you try AdvancedRocketry-1.16.5-1.7.1-5 and LibVulpes 1.16.5-1.0.1-8?

Second load works now. Luna planet will not deleted.

But the "Select Dst" button does not working.

I've not had much luck with replicating the Select Dst button not working in single player on my end, is this in single player, multiplayer?  Are there chips in the rocket at all?

Actually, lets move this to #2016 to keep things cleaner