# packages

pkgId: 97efc8211c1102058594b9137d1c92987c3075fb3f3cde1fc0da3877e1332159
name: python-bech32
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Reference implementation for Bech32 and segwit addresses.
url: https://github.com/fiatjaf/bech32
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bech32-1.2.0-1.src.rpm
checksum_type: sha256
description:
  Since this implementation wasn't in a place that was easy to use for Python programmers I took it from from https://github.com/rustyrussell/lightning-payencode and published [on GitHub](https://github.com/fiatjaf/bech32) and [on PyPI](https://pypi.org/project/bech32/).
  The original version of this package is probably the one at https://github.com/sipa/bech32/tree/master/ref/python, but apparently Rusty Russel commented out the 90-length limit of bech32-encoded stuff so it could be used for Lightning invoices. Let's keep that change.


pkgId: 4e62c97263203f72d9f723dd57b0906ba4c51b7a6f877ffeb9413b3af0243099
name: python-bech32m
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Encoding/decoding Bech32 and Bech32m
url: https://pypi.org/project/bech32m/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bech32m-1.0.0-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install bech32m
  ```

  `bech32m` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: 6149a41831fab261cc38ce6a1c45e20995546dd1ba8a2f287a71c2e8ceb36a40
name: python-bedger
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: Edge monitoring software for secure and efficient device management.
url: https://pypi.org/project/bedger/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bedger-0.0.4-1.src.rpm
checksum_type: sha256
description:
  The `ConnectionManager` class manages connections to a UNIX socket for sending and receiving messages.
  It provides context management capabilities to ensure connections are properly opened and closed.


  - Context manager support for connection lifecycle management.
  - Error handling for socket-related issues.
  - Sends event messages with acknowledgment handling.


  Ensure you have the `bedger` package and its dependencies installed.

  ```bash
  pip install bedger
  ```


  The following example demonstrates how to use the `ConnectionManager` to send events:

  ```python
  import time
  import bedger.edge.config as config
  import bedger.edge.connection as connection
  import bedger.edge.entities as entities

  if __name__ == "__main__":
      events = [
          {"event_type": "EventA", "severity": entities.Severity.HIGH, "payload": {"key": "value1"}},
          {"event_type": "EventB", "severity": entities.Severity.LOW, "payload": {"key": "value2"}},
          {"event_type": "EventC", "severity": entities.Severity.CRITICAL, "payload": {"key": "value3"}},
      ]

      with connection.ConnectionManager(config.Config()) as conn:
          for event in events:
              time.sleep(1)
              conn.send_event(event["event_type"], event["severity"], event["payload"])
  ```




  Manages a connection to a UNIX socket for sending and receiving messages.


  - **`__init__(config: Config = Config())`**
    - Initializes the `ConnectionManager` with a specified configuration.
    - **Parameters:**
      - `config (Config)`: The configuration containing the socket path. Defaults to a new `Config` instance.


  - **`__enter__() -> ConnectionManager`**
    - Establishes the socket connection when entering the context.
    - **Returns:** The instance of the `ConnectionManager`.

  - **`__exit__(exc_type, exc_value, traceback) -> None`**
    - Closes the socket connection when exiting the context.


  - **`send_event(event_type: str, severity: str | Severity, payload: dict) -> None`**
    - Sends an event message through the socket.
    - **Parameters:**
      - `event_type (str)`: The type of event being sent.
      - `severity (str | Severity)`: The severity level of the event.
      - `payload (dict)`: The event's payload details.
    - **Raises:**
      - `SocketNotConnectedError`: If no active socket connection exists.
      - `SocketBrokenPipeError`: If the socket connection is lost during transmission.
      - `SocketCommunicationError`: If an error occurs during socket communication.


  The `ConnectionManager` raises custom errors from the `bedger.edge.errors` module for:
  - Permission issues (`SocketPermissionDeniedError`).
  - Missing socket files (`SocketFileNotFoundError`).
  - Connection problems (`SocketConnectionError`).
  - Communication errors (`SocketCommunicationError`, `SocketBrokenPipeError`).


  The class uses the `logging` module to log the following:
  - Connection attempts and successes.
  - Errors during connection, disconnection, and message sending.
  - Debug information for message preparation and acknowledgments.


  This project is licensed under the MIT License. See the LICENSE file for details.


pkgId: e75cb994e835851c9708ebbb41bf44f21a81a83570454f7741f00808b057f205
name: python-bedrock-bot
arch: src
version: 1.2.15
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/bedrock-bot/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bedrock-bot-1.2.15-1.src.rpm
checksum_type: sha256
description:
  This project is a basic CLI-based chat bot that uses Bedrock to resolve questions. It can take input from stdin, CLI arguments or interactively when no parameters have been passed.



  1. `pip install bedrock-bot`
  2. You will also need some AWS credentials available in your shell (any usual way works - CLI configured IAM user access key/secret keys, environment variables, etc)
  3. Bedrock requires you to opt in to models in order to use them



  ```bash
  Usage: bedrock [OPTIONS] [ARGS]...

  Options:
    -r, --region TEXT               The AWS region to use for requests. If no
                                    default region is specified, defaults to us-
                                    east-1
    --raw-output TEXT               Don't interpret markdown in the AI response
    -m, --model [Claude-3-Haiku|Claude-3-Sonnet|Mistral-Large]
                                    The model to use for requests
    -v, --verbose                   Enable verbose logging messages
    -i, --input-file FILENAME       Read in file(s) to be used in your queries
    --help                          Show this message and exit.
  ```

  Directly as a chat bot:

  ```bash
  $ bedrock

  Hello! I am an AI assistant powered by Amazon Bedrock and using the model Claude-3-Haiku. Enter 'quit' or 'exit' at any time to exit. How may I help you today?
  (You can clear existing context by starting a query with 'new>' or 'reset>')

  > Hi, what is your name?
  My name is Claude.
  ```

  Using CLI arguments:

  ```bash
  $ bedrock "Hi, what is your name?"

  Hello! I am an AI assistant powered by Amazon Bedrock and using the model Claude-3-Haiku. Enter 'quit' or 'exit' at any time to exit. How may I help you today?
  (You can clear existing context by starting a query with 'new>' or 'reset>')

  > Hi, what is your name?
  My name is Claude. It's nice to meet you!
  ```

  Using stdin (Note that you can only use this for one-shot questions as input is reserved by your pipe to stdin and is not an interactive TTY any more):

  ```bash
  $ echo "Hi, what is your name?" > input-file

  $ cat input-file | bedrock
  Hello! I am an AI assistant powered by Amazon Bedrock and using the model Claude-3-Haiku. Enter 'quit' or 'exit' at any time to exit. How may I help you today?
  (You can clear existing context by starting a query with 'new>' or 'reset>')

  > Hi, what is your name?

  My name is Claude. I'm an AI created by Anthropic. It's nice to meet you!


  Note that you can only do one-shot requests when providing input via stdin
  ```

  Asking about a file:

  ```bash
  $ bedrock --input-file bedrock_bot/models/base_model.py write unit tests using pytest for this file
  Hello! I am an AI assistant powered by Amazon Bedrock and using the model Claude-3-Haiku. Enter 'quit' or 'exit' at any time to exit. How may I help you today?
  (You can clear existing context by starting a query with 'new>' or 'reset>')

  > write unit tests using pytest for this file
  To write unit tests for the bedrock_bot/models/base_model.py file using pytest, you can create a test_base_model.py file in the tests directory. Here's an example of how you can structure the tests:


   import json
   from unittest.mock import patch, MagicMock
   import pytest
   from bedrock_bot.models.base_model import _BedrockModel, ConversationRole

   class TestBedrockModel:
       def setup_method(self):
           self.model = _BedrockModel("test-model-id")

       def test_reset(self):
           self.model.append_message(ConversationRole.USER, "Hello")
           assert len(self.model.messages) == 1
           self.model.reset()
           assert len(self.model.messages) == 0
  ...
  ```



  Shell auto-complete is also supported.



  1. `_BEDROCK_COMPLETE=zsh_source bedrock > ~/.bedrock-completion.zsh`
  2. Add the following to your `~/.zshrc`: `source ~/.bedrock-completion.zsh`



  1. `_BEDROCK_COMPLETE=bash_source bedrock > ~/.bedrock-completion.bash`
  2. Add the following to your `~/.bashrc`: `source ~/.bedrock-completion.bash`


pkgId: bb677cf0f1e69009b58c44521caf351108b4e9349e41db501a75c3adaa52a134
name: python-bedrock-llm
arch: src
version: 0.1.6
epoch: 0
release: 1
url: https://github.com/Phicks-debug/bedrock_llm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bedrock-llm-0.1.6-1.src.rpm
checksum_type: sha256
summary:
  A Python LLM framework for interacting with AWS Bedrock services, built on top of boto3. This library serves as a comprehensive tool for fast prototyping, building POCs, and deploying production-ready LLM applications with robust infrastructure support.

description:
  A Python library for building LLM applications using Amazon Bedrock Provider and boto3 library. It aims to create best practices and production-ready solutions for various LLM models, including Anthropic, Llama, Amazon Titan, MistralAI, and AI21.

  The library is structured into two main components:

  1. `bedrock_be`: Infrastructure and services for deploying LLM applications.
  2. `bedrock_llm`: LLM orchestration and interaction logic.

  This structure allows for seamless integration of LLM capabilities with robust deployment and infrastructure management.

  ![Conceptual Architecture](/assests/bedrock_llm.png)



  - Support for multiple LLM models through Amazon Bedrock
  - Efficient LLM orchestration with `bedrock_llm`
  - Infrastructure and deployment services with `bedrock_be`
  - Enhanced Agent-based interactions with:
    - Robust tool validation and execution
    - Comprehensive error handling and logging
    - Configurable memory management
    - Type-safe responses with `AgentResponse`
    - Support for multiple LLM tool-calling conventions (Claude, Llama, Mistral, etc.)
  - Asynchronous and synchronous function support
  - Performance monitoring and logging functionality
  - Support for Retrieval-Augmented Generation (RAG)
  - Multi-Agent systems (in progress)
  - Workflows, nodes, and event-based systems (coming soon)
  - Image generation, speech-to-text (STT), and text-to-speech (TTS) support (coming soon)



  You can install the Bedrock LLM library using pip:

  ```bash
  pip install bedrock-llm
  ```

  This library requires Python 3.9 or later.



  Before using the library, make sure you have your AWS credentials properly configured:

  1. Create or update your AWS credentials file at `~/.aws/credentials`:

      ```ini
      [bedrock]
      aws_access_key_id = YOUR_ACCESS_KEY
      aws_secret_access_key = YOUR_SECRET_KEY
      ```

  2. Create or update your AWS config file at `~/.aws/config`:

      ```ini
      [profile bedrock]
      region = us-east-1
      ```

  3. When initializing the client, specify the profile name:

      ```python
      from bedrock_llm import LLMClient, ModelName, ModelConfig

      
      client = LLMClient(
          region_name="us-east-1",
          model_name=ModelName.MISTRAL_7B,
          profile_name="bedrock"  # Specify your AWS profile name
      )
      ```

      You can verify your credentials by running:

      ```bash
      aws bedrock list-foundation-models --profile bedrock
      ```



  Here's a quick example of how to use the Bedrock LLM library:



  ```python
  from bedrock_llm import LLMClient, ModelName, ModelConfig


  client = LLMClient(
      region_name="us-east-1",
      model_name=ModelName.MISTRAL_7B
  )


  config = ModelConfig(
      temperature=0.1,
      top_p=0.9,
      max_tokens=512
  )


  prompt = "Who are you?"


  response, stop_reason = client.generate(config, prompt)


  cprint(response.content, "green")
  cprint(stop_reason, "red")
  ```



  ```python
  from bedrock_llm import Agent, ModelName
  from bedrock_llm.schema.tools import ToolMetadata, InputSchema, PropertyAttr

  agent = Agent(
      region_name="us-east-1",
      model_name=ModelName.CLAUDE_3_5_HAIKU
  )


  get_weather_tool = ToolMetadata(
      name="get_weather",
      description="Get the weather in specific location",
      input_schema=InputSchema(
          type="object",
          properties={
              "location": PropertyAttr(
                  type="string",
                  description="Location to search for, example: New York, WashingtonDC, ..."
              )
          },
          required=["location"]
      )
  )


  @Agent.tool(get_weather_tool)
  async def get_weather(location: str):
      return f"{location} is 20*C"


  async def main():
      prompt = input("User: ")

      async for token, stop_reason, response, tool_result in agent.generate_and_action_async(
          prompt=prompt,
          tools=["get_weather"]
      ):
          if token:
              print(token, end="", flush=True)
          if stop_reason:
              print(f"\n{stop_reason}")


  if __name__ == "__main__":
      import asyncio
      asyncio.run(main())
  ```



  The Agent class in `bedrock_llm` provides powerful capabilities for building LLM-powered applications:



  ```python
  from bedrock_llm import Agent, ToolMetadata
  from typing import Dict


  @Agent.tool(
      metadata=ToolMetadata(
          name="search",
          description="Search for information",
          input_schema={
              "type": "object",
              "properties": {
                  "query": {"type": "string", "description": "Search query"}
              },
              "required": ["query"]
          }
      )
  )
  async def search(query: str) -> Dict:
      
      pass
  ```



  The library provides comprehensive error handling with custom exceptions:

  ```python
  try:
      result = await agent.generate_and_action_async(
          prompt="Search for Python tutorials",
          tools=["search"]
      )
  except ToolExecutionError as e:
      print(f"Tool '{e.tool_name}' failed: {e.message}")
      if e.original_error:
          print(f"Original error: {e.original_error}")
  ```



  Configure memory limits to manage conversation history:

  ```python
  agent = Agent(
      region_name="us-west-2",
      model_name=ModelName.ANTHROPIC_CLAUDE_V2,
      memory_limit=100  # Keep last 100 messages
  )
  ```



  The library now provides type-safe responses using TypedDict:

  ```python
  async for response in agent.generate_and_action_async(...):
      token: Optional[str] = response["token"]
      stop_reason: Optional[StopReason] = response["stop_reason"]
      message: Optional[MessageBlock] = response["message"]
      tool_results: Optional[List] = response["tool_results"]
  ```



  Support for different LLM tool-calling conventions:

  - Claude/Llama style: Uses ToolUseBlock for tool execution
  - Mistral/Jamba style: Uses ToolCallBlock for function calling



  Use the `monitor` decorators for performance monitoring:

  ```python
  from bedrock_llm.monitor import Monitor

  @Monitor.monitor_async
  async def my_async_function():
      

  @Monitor.monitor_sync
  def my_sync_function():
      
  ```

  Use the `log` decorators for logging function calls:

  ```python
  from bedrock_llm.monitor import Logging

  @Logging.log_async
  async def my_async_function():
      

  @Logging.log_sync
  def my_sync_function():
      
  ```

  These decorators are optimized for minimal performance impact on your application.



  For a detailed overview of the library's architecture, please see [ARCHITECTURE.md](ARCHITECTURE.md).



  For more detailed usage instructions and API documentation, please refer to our [documentation](https://github.com/yourusername/bedrock_llm/wiki).

  You can also see some examples of how to use and build LLM flow using the libary

  - [basic](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/1_basic.py)
  - [stream response](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/2_stream_response.py)
  - [all support llm](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/3_all_llm.py)
  - [simple chat bot](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/4_chatbot.py)
  - [tool calling](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/5_tool_calling.py)
  - [agent](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/7_agent.py)

  and more to come, we are working on it :)



  python>=3.9
  pydantic>=2.0.0
  boto3>=1.18.0
  botocore>=1.21.0
  jinja2>=3.1.2
  psutil>=5.9.0
  pytz>=2023.3
  termcolor>=2.3.0
  databases[postgresql]>=0.7.0
  sqlalchemy>=2.0.0
  asyncpg>=0.27.0  # PostgreSQL async driver
  types-redis>=4.6.0
  types-pytz
  rx==3.2.0



  We welcome contributions! Please see our [contributing guidelines](CONTRIBUTING.md) for more details.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


pkgId: ff37cd7c9d8aee61205c490db9373584efd29c5c1cc82ace2fe8a3f633490867
name: python-bedrock-llm
arch: src
version: 0.1.95b0
epoch: 0
release: 1
url: https://github.com/Phicks-debug/bedrock_llm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bedrock-llm-0.1.95b0-1.src.rpm
checksum_type: sha256
summary:
  A Python LLM frameworkfor interacting with AWS Bedrock services, built on top of boto3. This library serves as a comprehensive tool for fast prototyping, building POCs, and deploying production-ready LLM applications with robust infrastructure support.

description:
  A Python library for building LLM applications using Amazon Bedrock Provider and boto3 library. It aims to create best practices and production-ready solutions for various LLM models, including Anthropic, Llama, Amazon Titan, MistralAI, and AI21.

  The library is structured into two main components:

  1. `bedrock_be`: Infrastructure and services for deploying LLM applications.
  2. `bedrock_llm`: LLM orchestration and interaction logic.

  This structure allows for seamless integration of LLM capabilities with robust deployment and infrastructure management.

  ![Conceptual Architecture](/assests/bedrock_llm.png)



  - Support for multiple LLM models through Amazon Bedrock
  - Efficient LLM orchestration with `bedrock_llm`
  - Infrastructure and deployment services with `bedrock_be`
  - Enhanced Agent-based interactions with:
    - Robust tool validation and execution
    - Comprehensive error handling and logging
    - Configurable memory management
    - Type-safe responses with `AgentResponse`
    - Support for multiple LLM tool-calling conventions (Claude, Llama, Mistral, etc.)
  - Asynchronous and synchronous function support
  - Performance monitoring and logging functionality
  - Support for Retrieval-Augmented Generation (RAG)
  - Optimized Pipeline System:
    - Modular node-based architecture
    - Batch processing with configurable parameters
    - In-memory caching with size management
    - Parallel processing with thread pools
    - Type-safe node connections
    - Event-driven data flow
    - Filter nodes for data validation
  - Multi-Agent systems (in progress)
  - Image generation, speech-to-text (STT), and text-to-speech (TTS) support (coming soon)



  You can install the Bedrock LLM library using pip:

  ```bash
  pip install bedrock-llm
  ```

  This library requires Python 3.9 or later.



  Before using the library, make sure you have your AWS credentials properly configured:

  1. Create or update your AWS credentials file at `~/.aws/credentials`:

      ```ini
      [bedrock]
      aws_access_key_id = YOUR_ACCESS_KEY
      aws_secret_access_key = YOUR_SECRET_KEY
      ```

  2. Create or update your AWS config file at `~/.aws/config`:

      ```ini
      [profile bedrock]
      region = us-east-1
      ```

  3. When initializing the client, specify the profile name:

      ```python
      from bedrock_llm import LLMClient, ModelName, ModelConfig

      
      client = LLMClient(
          region_name="us-east-1",
          model_name=ModelName.MISTRAL_7B,
          profile_name="bedrock"  # Specify your AWS profile name
      )
      ```

      You can verify your credentials by running:

      ```bash
      aws bedrock list-foundation-models --profile bedrock
      ```





  ```python
  from bedrock_llm import LLMClient, ModelName, ModelConfig


  client = LLMClient(
      region_name="us-east-1",
      model_name=ModelName.MISTRAL_7B
  )


  config = ModelConfig(
      temperature=0.1,
      top_p=0.9,
      max_tokens=512
  )


  prompt = "Who are you?"


  response, stop_reason = client.generate(config, prompt)


  cprint(response.content, "green")
  cprint(stop_reason, "red")
  ```



  ```python
  from bedrock_llm import Agent, ModelName
  from bedrock_llm.schema.tools import ToolMetadata, InputSchema, PropertyAttr

  agent = Agent(
      region_name="us-east-1",
      model_name=ModelName.CLAUDE_3_5_HAIKU
  )


  get_weather_tool = ToolMetadata(
      name="get_weather",
      description="Get the weather in specific location",
      input_schema=InputSchema(
          type="object",
          properties={
              "location": PropertyAttr(
                  type="string",
                  description="Location to search for, example: New York, WashingtonDC, ..."
              )
          },
          required=["location"]
      )
  )


  @Agent.tool(get_weather_tool)
  async def get_weather(location: str):
      return f"{location} is 20*C"


  async def main():
      prompt = input("User: ")

      async for token, stop_reason, response, tool_result in agent.generate_and_action_async(
          prompt=prompt,
          tools=["get_weather"]
      ):
          if token:
              print(token, end="", flush=True)
          if stop_reason:
              print(f"\n{stop_reason}")


  if __name__ == "__main__":
      import asyncio
      asyncio.run(main())
  ```



  ```python
  from bedrock_llm.pipeline import Pipeline, BatchNode, CachedNode


  pipeline = Pipeline("text-processor")


  batch_node = BatchNode(
      "batch-embeddings",
      embed_batch_func,
      batch_size=32
  )

  cache_node = CachedNode(
      "cached-process",
      process_func,
      cache_size=1000
  )


  pipeline.add_node(batch_node)
  pipeline.add_node(cache_node)
  batch_node.connect(cache_node)


  result = await pipeline.execute(input_data)
  ```



  The Agent class in `bedrock_llm` provides powerful capabilities for building LLM-powered applications:



  ```python
  from bedrock_llm import Agent, ToolMetadata
  from typing import Dict


  @Agent.tool(
      metadata=ToolMetadata(
          name="search",
          description="Search for information",
          input_schema={
              "type": "object",
              "properties": {
                  "query": {"type": "string", "description": "Search query"}
              },
              "required": ["query"]
          }
      )
  )
  async def search(query: str) -> Dict:
      
      pass
  ```



  The library provides comprehensive error handling with custom exceptions:

  ```python
  try:
      result = await agent.generate_and_action_async(
          prompt="Search for Python tutorials",
          tools=["search"]
      )
  except ToolExecutionError as e:
      print(f"Tool '{e.tool_name}' failed: {e.message}")
      if e.original_error:
          print(f"Original error: {e.original_error}")
  ```



  Configure memory limits to manage conversation history:

  ```python
  agent = Agent(
      region_name="us-west-2",
      model_name=ModelName.ANTHROPIC_CLAUDE_V2,
      memory_limit=100  # Keep last 100 messages
  )
  ```



  The library now provides type-safe responses using TypedDict:

  ```python
  async for response in agent.generate_and_action_async(...):
      token: Optional[str] = response["token"]
      stop_reason: Optional[StopReason] = response["stop_reason"]
      message: Optional[MessageBlock] = response["message"]
      tool_results: Optional[List] = response["tool_results"]
  ```



  Support for different LLM tool-calling conventions:

  - Claude/Llama style: Uses ToolUseBlock for tool execution
  - Mistral/Jamba style: Uses ToolCallBlock for function calling



  Use the `monitor` decorators for performance monitoring:

  ```python
  from bedrock_llm.monitor import Monitor

  @Monitor.monitor_async
  async def my_async_function():
      

  @Monitor.monitor_sync
  def my_sync_function():
      
  ```

  Use the `log` decorators for logging function calls:

  ```python
  from bedrock_llm.monitor import Logging

  @Logging.log_async
  async def my_async_function():
      

  @Logging.log_sync
  def my_sync_function():
      
  ```

  These decorators are optimized for minimal performance impact on your application.



  The Bedrock LLM library is architected for scalability, reliability, and extensibility. Key architectural components include:



  - **Client Layer**: Robust interfaces for Bedrock service interaction
    - Async/Sync clients with streaming support
    - Configurable retry logic
    - Memory management
    - Type-safe operations

  - **Model Layer**: Flexible model implementation framework
    - Support for multiple LLM providers
    - Custom parameter optimization
    - Response formatting

  - **Agent System**: Advanced autonomous capabilities
    - Tool management and execution
    - State preservation
    - Error handling
    - Type-safe responses



  - AWS service integration
  - Deployment automation
  - Monitoring and scaling
  - Security management

  For a comprehensive architectural overview, see [ARCHITECTURE.md](ARCHITECTURE.md).



  For more detailed usage instructions and API documentation, please refer to our [documentation](https://github.com/yourusername/bedrock_llm/LIBRARY_DOCUMENTATION.md).

  You can also see some examples of how to use and build LLM flow using the libary

  - [basic](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/1_basic.py)
  - [stream response](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/2_stream_response.py)
  - [all support llm](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/3_all_llm.py)
  - [simple chat bot](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/4_chatbot.py)
  - [tool calling](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/5_tool_calling.py)
  - [agent](https://github.com/Phicks-debug/bedrock_llm/blob/main/examples/7_agent.py)

  and more to come, we are working on it :)



  For more detailed documentation, examples, and project insights, please refer to the following resources:

  - **Documentation**: [https://github.com/Phicks-debug/bedrock_llm/LIBRARY_DOCUMENTATION.md](<https://github.com/Phicks-debug/bedrock_llm/LIBRARY_DOCUMENTATION.md>)
  - **Examples**: [https://github.com/Phicks-debug/bedrock_llm/examples](https://github.com/Phicks-debug/bedrock_llm/examples)
  - **Project Insights**: [https://github.com/Phicks-debug/bedrock_llm/docs](https://github.com/Phicks-debug/bedrock_llm/docs)

  Feel free to reach out if you have any questions or need further assistance!



  - python>=3.9
  - pydantic>=2.0.0
  - boto3>=1.18.0
  - botocore>=1.21.0
  - jinja2>=3.1.2
  - psutil>=5.9.0
  - pytz>=2023.3
  - termcolor>=2.3.0
  - databases[postgresql]>=0.7.0
  - sqlalchemy>=2.0.0
  - asyncpg>=0.27.0  # PostgreSQL async driver
  - types-redis>=4.6.0
  - types-pytz
  - rx==3.2.0



  We welcome contributions! Please see our [contributing guidelines](CONTRIBUTING.md) for more details.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


pkgId: f0b839a463ad760196c8015a39d8ca2aeef1b274cbbd10bb985db58817e56856
name: python-bedspec
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: An HTS-specs compliant BED toolkit.
url: https://github.com/clintval/bedspec
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bedspec-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Release](https://badge.fury.io/py/bedspec.svg)](https://badge.fury.io/py/bedspec)
  [![CI](https://github.com/clintval/bedspec/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/clintval/bedspec/actions/workflows/tests.yml?query=branch%3Amain)
  [![Python Versions](https://img.shields.io/badge/python-3.10_|_3.11_|_3.12-blue)](https://github.com/clintval/typeline)
  [![basedpyright](https://img.shields.io/badge/basedpyright-checked-42b983)](https://docs.basedpyright.com/latest/)
  [![mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff/)

  An HTS-specs compliant BED toolkit.



  The package can be installed with `pip`:

  ```console
  pip install bedspec
  ```





  ```pycon
  >>> from bedspec import Bed3
  >>>
  >>> bed = Bed3("chr1", start=2, end=8)

  ```



  ```pycon
  >>> from bedspec import BedWriter
  >>> from tempfile import NamedTemporaryFile
  >>>
  >>> temp_file = NamedTemporaryFile(mode="w+t", suffix=".txt")
  >>>
  >>> with BedWriter.from_path(temp_file.name, Bed3) as writer:
  ...     writer.write(bed)

  ```



  ```pycon
  >>> from bedspec import BedReader
  >>>
  >>> with BedReader.from_path(temp_file.name, Bed3) as reader:
  ...     for bed in reader:
  ...         print(bed)
  Bed3(refname='chr1', start=2, end=8)

  ```



  This package provides builtin classes for the following BED formats:

  ```pycon
  >>> from bedspec import Bed2
  >>> from bedspec import Bed3
  >>> from bedspec import Bed4
  >>> from bedspec import Bed5
  >>> from bedspec import Bed6
  >>> from bedspec import Bed12
  >>> from bedspec import BedGraph
  >>> from bedspec import BedPE

  ```



  Use a fast overlap detector for any collection of interval types, including third-party:

  ```pycon
  >>> from bedspec import Bed3, Bed4
  >>> from bedspec.overlap import OverlapDetector
  >>>
  >>> bed1 = Bed3("chr1", start=1, end=4)
  >>> bed2 = Bed3("chr1", start=5, end=9)
  >>>
  >>> detector = OverlapDetector[Bed3]([bed1, bed2])
  >>>
  >>> my_feature = Bed4("chr1", start=2, end=3, name="hi-mom")
  >>> detector.overlaps(my_feature)
  True

  ```

  The overlap detector supports the following operations:

  - `overlapping`: return all overlapping features
  - `overlaps`: test if any overlapping features exist
  - `enclosed_by`: return those enclosed by the input feature
  - `enclosing`: return those enclosing the input feature



  To create a custom BED record, inherit from the relevant BED-type (`PointBed`, `SimpleBed`, `PairBed`).

  For example, to create a custom BED3+1 class:

  ```pycon
  >>> from dataclasses import dataclass
  >>>
  >>> from bedspec import SimpleBed
  >>>
  >>> @dataclass
  ... class Bed3Plus1(SimpleBed):
  ...     refname: str
  ...     start: int
  ...     end: int
  ...     my_custom_field: float | None

  ```



  See the [contributing guide](./CONTRIBUTING.md) for more information.


pkgId: 8f1199a83be510c277d0b8e77f106ec23d08caa4b623e09d7fcfde9f010710ab
name: python-beeb
arch: src
version: 2.4.2
epoch: 0
release: 1
summary: A modern interface to the BBC Sounds radio catalogue
url: https://github.com/lmmx/beeb
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beeb-2.4.2-1.src.rpm
checksum_type: sha256
description:
  ![](https://raw.githubusercontent.com/lmmx/beeb/master/assets/beeb_logo_small.png)

  A modern interface to the BBC Sounds radio catalogue.



  _beeb_ is a light alternative to
  [`get_iplayer`](https://github.com/get-iplayer/get_iplayer/)
  (10,000 lines of Perl)
  and
  [`youtube-dl`](https://github.com/ytdl-org/youtube-dl/blob/master/youtube_dl/extractor/bbc.py)
  (750+ compatible sites).

  These libraries aim to be deep and broad, `beeb` just aims to be specific and quick,
  handling common use cases (scheduling and download links) clearly, in nicely
  object-oriented Python.



  <details><summary>❧ Click here to show requirements</summary>

  <p>

  - BeautifulSoup
  - HTTPX
    - A `requests`-like API with async and HTTP/2 support
  - aiostream, aiofiles
    - Asynchronous requests to speed up channel listings retrieval and stream downloads
  - tqdm
    - Gives the option to show progress when multiprocessing channel listings
  - `more_itertools`
  - dateutil

  </p>

  </details>



  A `ChannelSchedule` stores a single day's listings, for a single channel.

  <details><summary>❧ Click here for basic info on ChannelSchedule</summary>

  <p>

  - National, local, regional channels can be selected by ID or short name
  - The schedule with today's date is loaded by default

  To load today's schedule for BBC R4:

  ```py
  from beeb.nav import ChannelSchedule
  ChannelSchedule.from_channel_name("r4")
  ```
  ⇣
  ```
  ChannelSchedule for BBC Radio 4 on 2021-03-17
  ```

  These ChannelSchedule objects can be used to find programmes:

  ```py
  >>> from beeb.nav import ChannelSchedule
  >>> s = ChannelSchedule.from_channel_name("r4")
  >>> s.get_broadcast_by_title("Today", pid_only=True)
  'm000t476'
  >>> s.get_broadcast_by_title("Midnight News")
  00:00 on 17/03/2021 — Midnight News
  >>> for b in s.get_broadcast_by_title("Shipping Forecast", multi=True): b
  00:48 on 17/03/2021 — Shipping Forecast
  05:20 on 17/03/2021 — Shipping Forecast
  12:03 on 17/03/2021 — Shipping Forecast
  ```


  </p>

  </details>

  <details><summary>❧ Click here for more complex ChannelSchedule examples</summary>

  <p>

  ```py
  >>> for b in s.get_broadcast_by_title(r".*\bNews\b", regex=True, multi=True): b
  ...
  00:00 on 17/03/2021 — Midnight News
  05:30 on 17/03/2021 — News Briefing
  12:00 on 17/03/2021 — News Summary
  18:00 on 17/03/2021 — Six O'Clock News
  >>> for b in s.get_broadcast_by_title(r".*\bnews\b", multi=True,
  ... case_insensitive=True, regex=True, synopsis=True): print(b)
  ...
  00:00 on 17/03/2021 — Midnight News
  05:30 on 17/03/2021 — News Briefing
  06:00 on 17/03/2021 — Today
  12:00 on 17/03/2021 — News Summary
  13:00 on 17/03/2021 — World at One
  17:00 on 17/03/2021 — PM
  18:00 on 17/03/2021 — Six O'Clock News
  20:00 on 17/03/2021 — Moral Maze
  22:00 on 17/03/2021 — The World Tonight
  23:30 on 17/03/2021 — Today in Parliament
  >>> for b in s.get_broadcast_by_title(
  ... r".*\b(pandemic|virus|coronavirus|Covid|vaccines?|vaccinations?|health|healthcare|NHS)\b",
  ... multi=True, case_insensitive=True, regex=True, synopsis=True): print(b)
  ...
  10:00 on 17/03/2021 — Woman's Hour
  15:00 on 17/03/2021 — Money Box
  15:30 on 17/03/2021 — Inside Health
  ```

  </p>

  </details>

  `ChannelListings` are a collection of `ChannelSchedule` objects over a
  given time period (from up to 30 days ago).

  <details><summary>❧ Click here for basic info on ChannelListings</summary>

  <p>

  The schedules are loaded asynchronously and then their HTML is parsed on all CPU cores (fast!)

  No interface is currently implemented for multiple channels (as I don't particularly need it), but
  `beeb.nav.ChannelPicker` gives all available channels if you wanted to iterate over them.

  ```py
  >>> from beeb.nav import ChannelListings
  >>> ChannelListings.from_channel_name("r4")
  ChannelListings for BBC Radio 4 from 2021-02-17 to 2021-03-18 (30 days)
  ```

  The schedules are stored as a chronological list in the `ChannelListings.schedules` attribute

  ```py
  >>> from beeb.nav import ChannelListings
  >>> l = ChannelListings.from_channel_name("r4")
  ChannelListings for BBC Radio 4 from 2021-02-17 to 2021-03-18 (30 days)
  >>> l.schedules[0]
  ChannelSchedule for BBC Radio 4 on 2021-02-17
  ```

  ChannelListings follows the same interface as ChannelSchedule (they share a commonly bound method,
  to avoid too much parameter passing).


  </p>

  </details>


  <details><summary>❧ Click here for examples of ChannelListings queries</summary>

  <p>


  - There were 26 'Today' episodes aired on BBC R4 in the last 30 days (not aired on Sundays):

  ```py
  >>> for i, b in enumerate(l.get_broadcast_by_title("Today", multi=True)):
  ...     print(f"{i:2}) {b}")
  ...
   0) 06:00 on Wed 17/02/2021 — Today
   1) 06:00 on Thu 18/02/2021 — Today
   2) 06:00 on Fri 19/02/2021 — Today
   3) 07:00 on Sat 20/02/2021 — Today
   4) 06:00 on Mon 22/02/2021 — Today
   5) 06:00 on Tue 23/02/2021 — Today
   6) 06:00 on Wed 24/02/2021 — Today
   7) 06:00 on Thu 25/02/2021 — Today
   8) 06:00 on Fri 26/02/2021 — Today
   9) 07:00 on Sat 27/02/2021 — Today
  10) 06:00 on Mon 01/03/2021 — Today
  11) 06:00 on Tue 02/03/2021 — Today
  12) 06:00 on Wed 03/03/2021 — Today
  13) 06:00 on Thu 04/03/2021 — Today
  14) 06:00 on Fri 05/03/2021 — Today
  15) 07:00 on Sat 06/03/2021 — Today
  16) 06:00 on Mon 08/03/2021 — Today
  17) 06:00 on Tue 09/03/2021 — Today
  18) 06:00 on Wed 10/03/2021 — Today
  19) 06:00 on Thu 11/03/2021 — Today
  20) 06:00 on Fri 12/03/2021 — Today
  21) 07:00 on Sat 13/03/2021 — Today
  22) 06:00 on Mon 15/03/2021 — Today
  23) 06:00 on Tue 16/03/2021 — Today
  24) 06:00 on Wed 17/03/2021 — Today
  25) 06:00 on Thu 18/03/2021 — Today
  ```

  - Here's a query of all programmes which mention vaccin(es,ations,inologists) in their
    title/subtitle/synopsis:

  ```py
  >>> for b in l.get_broadcast_by_title(r".*\b(vaccin.+?)\b", multi=True, case_insensitive=True,
  ... regex=True, synopsis=True): print(b)
  ...
  15:30 on Wed 17/02/2021 — Inside Health
  18:00 on Wed 17/02/2021 — Six O'Clock News
  11:30 on Mon 22/02/2021 — How to Vaccinate the World
  14:00 on Sat 27/02/2021 — Any Answers?
  07:10 on Sun 28/02/2021 — Sunday
  11:30 on Mon 01/03/2021 — How to Vaccinate the World
  20:00 on Wed 03/03/2021 — Moral Maze
  22:15 on Sat 06/03/2021 — Moral Maze
  11:30 on Mon 08/03/2021 — How to Vaccinate the World
  11:30 on Mon 15/03/2021 — How to Vaccinate the World
  18:00 on Mon 15/03/2021 — Six O'Clock News
  22:00 on Mon 15/03/2021 — The World Tonight
  21:00 on Tue 16/03/2021 — Inside Health
  15:30 on Wed 17/03/2021 — Inside Health
  18:00 on Wed 17/03/2021 — Six O'Clock News
  ```

  </p>

  </details>

  From the ChannelListings you can build `ProgrammeCatalogue` dictionaries,
  by inspecting the parent programme IDs of each of the broadcasts in the schedules
  within the listings. Catalogues for multiple stations can be organised in a `ProgrammeGuide`.

  <details><summary>❧ Click here for ProgrammeCatalogue examples</summary>

  <p>

  To obtain an up-to-date `ProgrammeCatalogue` with just programme PIDs and titles:

  ```py
  beeb.api.get_programme_dict("r4", n_days=1)
  ```
  ⇣
  ```py
  {'b00cs19l': 'Midnight News',
   'b006qfvv': 'Shipping Forecast',
   'b006s54y': 'Selection of BBC World Service Programmes',
   'b007rhyn': 'News Briefing',
   'b006qmpj': 'Prayer for the Day',
   'b006qj8q': 'Farming Today',
   'b01s6xyk': 'Tweet of the Day',
   'b006qj9z': 'Today',
   'b09zgd6y': 'Chinese Characters',
   'b007qlvb': "Woman's Hour",
   'm0002rjm': "Alexei Sayle's The Absence of Normal",
   'b04fc120': 'News Summary',
   'b006qps9': 'You and Yours',
   'b007rn05': 'Weather',
   'b006qptc': 'World at One',
   'b006qpgr': 'The Archers',
   'b04xxp0g': 'Drama',
   'b006qjnv': 'Money Box',
   'b019dl1b': 'Inside Health',
   'm000s2kt': 'Sideways',
   'b00dv9hq': 'The Media Show',
   'b006qskw': 'PM',
   'b006qjxt': "Six O'Clock News",
   'b006qsq5': 'Front Row',
   'b006qk11': 'Moral Maze',
   'b006xp1x': 'Lent Talks',
   'b006r4wn': 'Costing the Earth',
   'b006qtl3': 'The World Tonight',
   'm000czyb': 'The Skewer',
   'b006qtqd': 'Today in Parliament'}
  ```

  To obtain a `ProgrammeCatalogue` with genres (be warned — for the last 30 days this takes 60 seconds):

  ```py
  beeb.api.get_genre_programme_dict("r4", n_days=30)
  ```
  ⇣
  ```py
  {'Arts': [('b006v8jn', 'A Good Read')],
   'Arts, Culture & the Media': [('b01875r3', 'One to One'),
                                 ('b006qsq5', 'Front Row'),
                                 ('b00dv9hq', 'The Media Show'),
                                 ('b006qp6p', 'Open Book'),
                                 ('b006r5jt', 'The Film Programme'),
                                 ('b006slnx', 'Feedback'),
                                 ('m00055q2', 'Rewinder'),
                                 ('b006qjym', 'Loose Ends'),
                                 ('b06p0p0g', 'The Why Factor'),
                                 ('b006qpdd', 'Pick of the Week'),
                                 ('b006r9xr', 'Start the Week'),
                                 ('b006s5sf', 'Bookclub'),
                                 ('b09w07c4', 'Art of Now')],
   'Biographical': [('b0721qqk', 'Riot Girls')],
   'Chat': [('p04x5pd7', 'Fortunately... with Fi and Jane'),
            ('m000s9s1', 'Between Ourselves with Marian Keyes'),
            ('b00snr0w', 'The Infinite Monkey Cage')],
   'Classic & Period': [('m000j0t9', 'Electric Decade')],
   'Comedy': [('b00x8dq1', 'My Teenage Diary'),
              ('b08mj1wj', 'Reluctant Persuaders'),
              ('m0002rjm', "Alexei Sayle's The Absence of Normal")],
   'Consumer': [('b006qps9', 'You and Yours')],
   'Crime & Justice': [('b006tgy1', 'Law in Action'), ('m0000nfh', 'Intrigue')],
   'Disability': [('b006qxww', 'In Touch')],
   'Drama': [('b04xxp0g', 'Drama'),
             ('b08lw2hh', 'Short Works'),
             ('m000s855', "Hardy's Women")],
   'Entertainment': [('b060cdyj', 'Bunk Bed')],
   'Factual': [('b006s54y', 'Selection of BBC World Service Programmes'),
               ('b007qlvb', "Woman's Hour"),
               ('m0001kbd', 'Born in Bradford'),
               ('b006th08', 'File on 4'),
               ('m000s2kt', 'Sideways'),
               ('b006qk11', 'Moral Maze'),
               ('b006qjlq', 'From Our Own Correspondent'),
               ('b006qnc7', 'Radio 4 Appeal'),
               ('b07cblx9', 'The Briefing Room'),
               ('b006qng8', 'A Point of View'),
               ('b006qnj3', 'Broadcasting House'),
               ('m0003r3t', 'My Name Is...'),
               ('m00019hp', 'Archive on 4'),
               ('b007qxpr', 'Round Britain Quiz'),
               ('b03w7bwg', 'Out of the Ordinary'),
               ('b09zgd6y', 'Chinese Characters')],
   'Families & Relationships': [('b006qgj4', 'Saturday Live')],
   'Food & Drink': [('b006qnx3', 'The Food Programme')],
   'Gardens': [('b006qp2f', "Gardeners' Question Time")],
   'Health & Wellbeing': [('b019dl1b', 'Inside Health')],
   'Historical': [('m000sqkk', 'Gudrun')],
   'History': [('b006qykl', 'In Our Time'),
               ('b00nrtd2', 'A History of the World in 100 Objects')],
   'Life Stories': [('b01mk3f8', 'Short Cuts'),
                    ('b006qnmr', 'Desert Island Discs'),
                    ('b006qpmv', 'Last Word'),
                    ('b006qjz5', 'Profile'),
                    ('b03cdpww', 'Meeting Myself Coming Back'),
                    ('b01cqx3b', 'The Listening Project')],
   'Money': [('b006qjnv', 'Money Box'), ('b006sz6t', 'The Bottom Line')],
   'Music': [('b00704s1', 'Counterpoint')],
   'Nature & Environment': [('b006qj8q', 'Farming Today'),
                            ('b006xrr2', 'Ramblings'),
                            ('b05w99gb', 'Natural Histories'),
                            ('b006r4wn', 'Costing the Earth')],
   'News': [('b00cs19l', 'Midnight News'),
            ('b007rhyn', 'News Briefing'),
            ('b006qj9z', 'Today'),
            ('b04fc120', 'News Summary'),
            ('b006qptc', 'World at One'),
            ('b006qskw', 'PM'),
            ('b006qjxt', "Six O'Clock News"),
            ('b006qtl3', 'The World Tonight'),
            ('b007rhyy', 'News and Papers'),
            ('b00g3j4x', 'News'),
            ('b006qnz4', 'The World This Weekend')],
   'Panel Shows': [('b006s5dp', 'Just a Minute')],
   'Politics': [('b006qtqd', 'Today in Parliament'),
                ('b006qgvj', 'Any Questions?'),
                ('b006qjfq', 'The Week in Westminster'),
                ('b006qmmy', 'Any Answers?'),
                ('m0001xq1', 'The Battles That Won Our Freedoms'),
                ('b006r4vz', 'Analysis'),
                ('b006s624', 'Westminster Hour')],
   'Religion & Ethics': [('b006qmpj', 'Prayer for the Day'),
                         ('b006xp1x', 'Lent Talks'),
                         ('b006sgsh', 'Bells on Sunday'),
                         ('b006qn7f', 'Something Understood'),
                         ('b006qnbd', 'Sunday'),
                         ('b006qnds', 'Sunday Worship')],
   'Satire': [('b09rwvwt', 'Henry Normal: A Normal...'),
              ('m000czyb', 'The Skewer'),
              ('b006qgt7', 'The Now Show')],
   'Science & Nature': [('b01s6xyk', 'Tweet of the Day'),
                        ('b07dx75g', 'The Curious Cases of Rutherford & Fry'),
                        ('b036f7w2', 'BBC Inside Science'),
                        ('b06vy2jd', 'Science Stories')],
   'Science & Technology': [('b01n7094', 'The Digital Human')],
   'Sitcoms': [('b0b2nh1n', 'Ability')],
   'Sketch': [('b00kvs8r', 'Newsjack')],
   'Soaps': [('b006qpgr', 'The Archers'), ('b006qnkc', 'The Archers Omnibus')],
   'Standup': [('b0b22qhr', 'Stand-Up Specials'),
               ('b011tzjy', 'Meet David Sedaris')],
   'Weather': [('b006qfvv', 'Shipping Forecast'), ('b007rn05', 'Weather')]}
  ```

  This is equivalent to constructing the class directly and accessing its `.keyed_by_genre` property.

  ```py
  beeb.nav.ProgrammeCatalogue("r4", n_days=30, with_genre=True)
  ```

  - This takes about 7 or 8 seconds (fast given the number of requests it's making!)
  - Note that these requests occasionally fail (async sessions are prone to rare connection errors),
    and are silently retried up to 3 times (one seems to be enough in my experience).

  The programme catalogues can be stored in a database and then restored from there:

  ```py
  >>> pc = beeb.nav.ProgrammeCatalogue("r4", n_days=1, with_genre=True, async_pull=True)'
  >>> pc.store_db()
  >>> rc = beeb.nav.ProgrammeCatalogue.regenerate_from_db("r4")
  >>> pc == rc, pc.genred == rc.genred, pc.db.path == rc.db.path, type(rc) is type(pc)
  (True, True, True, True)
  ```

  Note that regenerated catalogues have no associated day range

  ```py
  >>> rc.n_days
  0
  ```

  The SQLite3 database `programme_catalogue.db` records a simple four field table, `programmes`, in `beeb.data.store`:

  ```sql
  SELECT * FROM programmes;
  ```
  ⇣
  ```STDOUT
  m000tcdg|Midnight News|News|r4
  m000tcdj|Shipping Forecast|Weather|r4
  m000tcdl|Selection of BBC World Service Programmes|Factual|r4
  ...
  ```

  </p>

  </details>

  If your programme(s) of interest are regular, long-running ones, they should be
  included in the database of programmes which ships with beeb.

  <details><summary>❧ Click here for ProgrammeCatalogue database support and multiple channel catalogues in ProgrammeGuide</summary>

  <p>

  Multiple `ProgrammeCatalogue` objects can also be produced in a `ProgrammeGuide`.
  This is a glorified dictionary, keyed by the station name and with the catalogues
  as its values.

  To create a `ProgrammeGuide` for an entire categories of stations (available
  categories: "national", "regional", "local"), and automatically store them in
  a database, call `ProgrammeGuide.generate_by_category(c)`,
  where `c` is either one of the options, or a list of them.

  The package ships with a catalogue database populated with the national channels
  (excluding variants: only FM 'outlets' for those with multiple which share a station title).

  Populating the programme catalogues database for all national channels
  takes approximately 60 to 90 seconds, and then can be reloaded instantly:

  ```py
  beeb.nav.ProgrammeGuide.generate_by_category("national")'
  ```

  Unlike the episodes in `ChannelSchedule` and `ChannelListings`, this is
  (potentially) available at runtime, instantly, making it preferable for
  metadata lookup in some cases.

  ```py
  >>> guide = beeb.nav.ProgrammeGuide.generate_by_category("national")
  >>> guide.get_programme_by_title("Today")
  ('b006qj9z', ('Today', 'News'))
  >>> guide.get_programme_by_title("Today", pid_only=True)
  'b006qj9z'
  ```

  The following SQL query shows duplicates in the resulting database
  ([via](https://stackoverflow.com/a/36384145/2668831)). Note that these are
  permitted as the primary key consists of both the programme ('brand') PID
  and the station short name (corresponding to the channel's entry in
  `beeb.nav.channel_ids`).

  This is not an error: these shows are simply syndicated across channels.

  ```sql
  SELECT *
  FROM programmes
  WHERE pid IN (SELECT pid
                FROM programmes
                GROUP BY pid
                HAVING COUNT(pid) >1);
  ```
  ⇣
  ```
  b006wkp7|Annie Nightingale presents...|Dance & Electronica|r1
  b006wkp7|Annie Nightingale presents...|Dance & Electronica|r1x
  b006wkry|Newsbeat|News|an
  b006wkry|Newsbeat|News|r1
  b006wkry|Newsbeat|News|r1x
  ...
  ```

  See
  [`beeb.nav.cat.catalogue`](https://github.com/lmmx/beeb/blob/master/src/beeb/nav/cat/catalogue.py)
  and [`beeb.share.db_utils`](https://github.com/lmmx/beeb/blob/master/src/beeb/share/db_utils.py)
  for more details.

  </p>

  </details>



  <details><summary>❧ Click here for the basics of stream handling</summary>

  <p>

  Episodes are downloaded from BBC Sounds as M4S (MPEG-DASH streams). There is a header `.dash` file
  and then multiple `.dash` files, and if you have all of these you can build a MP4 audio file.

  > As far as I know the access to these is geo-fenced, i.e. you must
  > be in the UK to download but this may vary between programmes/stations.

  To download an episode, initialise a `Stream` object, which will pull the component MPEG-DASH stream
  parts, merge them, and transcode from MP4 to WAV at 16k, as is desirable for most audio handling
  (but note this transcoding does increase the filesize). By default, the individual parts are deleted
  after download.

  The default download directory is a package-internal path beneath `beeb.data.store`, followed by
  a subpath denoting: station » programme (by PID) » year » month » day. To change the directory,
  subclass or otherwise set `_root_store_dir`.

  - Another option is to initialise with `defer_pull=False`, set the attribute,
    then call the `Stream`'s `pull()` and `preprocess()` methods.

  To download an episode by name and date, use the helper class method `Stream.from_name`:

  ```py
  beeb.stream.Stream.from_name("r4", "Today", ymd=(2021,3,30))
  ```

  > The station ID (in this example, "r4") can be looked up in `channel_ids` or with the
  > `ChannelPicker.by_name` helper class method.

  The most directly useful functions (which I've needed when interacting with BBC Sounds API) are
  those to obtain the M4S links: you only need the final one to construct the full set of URLs
  to obtain a complete MP4.

  The following functions handle this in `beeb.api`:

  - `get_episode_dict`
    - a trivial wrapper to access the `episodes_dict` attribute of `EpisodeListingsHtml`
  - `final_m4s_link_from_programme_pid`
    - a wrapper to access the `last_m4s_link` attribute of the `MpdXml` class constructed with the `from_episode_pid` class method
  - `final_m4s_link_from_episode_pid`
    - a wrapper to access the `last_m4s_link` attribute of the `MpdXml` class constructed with the `from_episode_pid` class method
      after obtaining the episode PID from the episode dict
  - `get_programme_pid_by_name`
    - a wrapper to access the `filtered` attribute of a `EpisodeMetadataPidJson` object
      constructed with the `get_programme_pid` class method.
    - technically it's "by programme title and station name" (the arguments are in this order)

  You may very well prefer to construct the objects and handle the attributes involved yourself,
  these are given as 'recipes' to make it clear how to use beeb's functionality.

  </p>

  </details>


pkgId: e607786bc53935b4f72d0c89d54fc27f02ba270a8032bd9d3ef3cbfb091a7c1d
name: python-beeflow-ajax
arch: src
version: 1.0.18
epoch: 0
release: 1
summary: Library to maintain ajax and websockets communication without writing complicated code in JS
url: https://github.com/beeflow/BeeflowAjaxPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beeflow-ajax-1.0.18-1.src.rpm
checksum_type: sha256
description:
  The library to maintain ajax and websockets communication without writing complicated code in JS



  ```shell
  $ pip install beeflow-ajax
  ```

  ```shell
  $ npm i @beeflow/beeflow_ajax_js
  ```

  or use cdn

  ```html

  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@1.0.2/css/BeeflowAjax.css"/>
  <script src="https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@1.0.2/js/js-url-2.3.0.min.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@1.0.2/js/BeeflowAjax.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@1.0.2/js/BeeflowAjaxSwalMessages.js"></script>
  ```

  Where

  * `css/BeeflowAjax.css` - declaration for classes for IDE helper
  * `js/js-url-2.3.0.min.js` - library used by
  * `js/BeeflowAjax.js` - beeflow ajax library including websocket
  * `js/BeeflowAjaxSwalMessages.js` - definition of messages that use sweet alerts (you need to have sweet alerts library)







  ```html
  <a href="https://some.web.example/api/v1/record/<int:record_id>" data-method="delete"
     data-confirm="Are you sure you want to delete this record?"
     class="ajax-link" title="Delete record"
     data-callback="() => { console.log('Hello world!') }">delete</a>
  ```



  ```html
  <form action="https://some.web.example/api/v1/record/" method="post" class="ajax-form">
      <input type="text" name="some_data">
      <input type="submit" name="submit" value="Send">
  </form>
  ```



  ```html
  <select data-ajax-datasource="https://some.web.example/api/v1/record/all" data-defaul-value="10"
          data-url-value="language_code=pl"></select>
  ```



  ```javascript
  BeeflowAjax.send("https://some.web.example/api/v1/record/", {"some": "data"}, submitButton, callbackMethod, 'POST');
  ```





  ```javascript
  BeeflowAjax.websocket.init("ws://some.web.example/api/v1/ws/<any:connectionId>", {some: "data"}, () => {
      consolr.log('Callback function')
  })
  ```



  ```html
  <form action="https://some.web.example/api/v1/record/" method="post" class="websocket-form">
      <input type="text" name="some_data">
      <input type="submit" name="submit" value="Send">
  </form>
  ```







  ```python
  from django.http import HttpResponse  # or any response class
  from rest_framework.views import APIView
  from beeflow_ajax.lib import AjaxResponse

  ...


  class SomeView(APIView):
      ajax = AjaxResponse(HttpResponse)

      def get(self, request, id: int, *args, **kwargs):
          return self.ajax.assign("#some-html-element-id", f"Received id: {id}").response(*args, **kwargs)
  ```



  ```python
  from fastapi import APIRouter, Depends
  from sqlalchemy.orm import Session
  from starlette import status
  from beeflow_ajax.lib import AjaxResponse

  router = APIRouter()


  @router.get("/some-view-id", status_code=status.HTTP_200_OK)
  async def new_game(db: Session = Depends(get_db)):
      ajax = AjaxResponse()

      
      return ajax.assign("#some-html-element-id", f"Received id: {id}").response()
  ```


  You can register custom commands

  ```javascript
  BeeflowAjax.addCommandHandler(
      'customCommand', (data) => { alert(data['message']) }
  )
  ```

  ```python
  def handle_custom_data(data: Dict[str, Any]) -> 'AjaxResponse':
      ajax = AjaxResponse()
      ajax.add_command("customCommand", data)
      return ajax


  ajax = AjaxResponse()
  ajax.register_command_handler("customCommand", handle_custom_data)
  ```


  First install `pre-commit`

  ```shell
  $ pip install pre-commit
  $ pre-commit install
  ```



  ```shell
  $ python -m build
  $ twine upload dist/*
  ```



  In the `beeflow_ajax/beeflow_ajax_js` directory, run commands

  ```shell
  $ npm version patch
  $ npm publish
  ```

  Then use these urls in the browser:
  * https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@<correct_version>/css/BeeflowAjax.css
  * https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@<correct_version>/js/js-url-2.3.0.min.js
  * https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js<correct_version>/js/BeeflowAjax.js
  * https://cdn.jsdelivr.net/npm/@beeflow/beeflow_ajax_js@<correct_version>/js/BeeflowAjaxSwalMessages.js


pkgId: 4f6f0eaf9a50dea91a5fa440908e16a0f87cbb179acdd9591f13dac527efcd7f
name: python-beekeeper-alt
arch: src
version: 2022.9.3
epoch: 0
release: 1
url: https://github.com/miigotu/beekeeper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beekeeper-alt-2022.9.3-1.src.rpm
checksum_type: sha256
summary:
  beekeeper is a Python library designed around dynamically generating a RESTful client interface based on a minimal JSON hive


pkgId: 7b63e098771decfb852af323a2ccd68aae60f31e65ae77258f382fa326a20ccf
name: python-beelzebub
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Lightweight framework for transforming input to output
url: https://github.com/paul-breen/beelzebub
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beelzebub-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Beelzebub is a lightweight framework to transform input to output.  The base classes aren't meant to be used directly, rather they establish the interfaces of the framework, and provide a basis with which to derive classes for defining a particular transformation workflow.

  A workflow consists of a reader class, a writer class, and a processor class.  The workflow class instantiates one of each of these classes, and then executes the workflow of reading input from a given *source* via the reader class, writing output to a given *sink* via the writer class, and the processor class calls the reader, processes the input, and passes this to the writer.

  Both the reader and writer classes are based on a common context manager class.  In particular, the `open()` method can read/write to one of a set of supported *iostream* types.  The *iotype* must be one of `['file','url','str']`.  A `TypeError` exception will be raised otherwise.

  The workflow class can optionally set up logging for the workflow (based on the existence of a `logger` section in the optional configuration dict), and then calls the `run()` method, passing the source and sink.

  As mentioned, an optional configuration dict can be passed when instantiating the workflow object.  As a particular workflow will have specific reader, writer and processor classes, the configuration items for each of these components is arbitrary, suited to the particular workflow.  However, the framework will look for a toplevel key called `reader` to pass to the reader class, `writer` to pass to the writer class, and `processor` to pass to the processor class.  In addition, if a `logger` key exists, then this will be used to configure logging, via a call to `logging.config.dictConfig(conf['logger'])`.

  One of the main uses of the configuration is to specify the iotype for the reader and writer.  For example, if the input is read from a file, but the output is to be written to a string, then the configuration should be something like the following:

  ```python
  conf = {'reader': {'iotype': 'file'}, 'writer': {'iotype': 'str'}}
  in_file = sys.argv[1]
  out_file = None

  x = BaseWorkflow(conf=conf)
  x.run(in_file, out_file)
  print(x.writer.output)
  ```

  Note that if the output is to be written to a string, then the sink argument (here, `out_file`) to `run()` is redundant, and can be set to `None`.  In this case, access the output string via the workflow's writer's `output` attribute.

  If a binary file is to be read or written, then `mode` should be specified in the corresponding part of the configuration and include the `'b'` flag.  For example, for reading a binary file from a web server and writing to a local copy:

  ```python
  conf = {
      'reader': {'iotype': 'url', 'mode': 'rb'},
      'writer': {'iotype': 'file', 'mode': 'wb'},
      'logger': {'version': 1, 'loggers': {'beelzebub.base': {'level': 'DEBUG'}}}
  }
  in_file = 'http://web.server/file.dat'
  out_file = './file-copy.dat'

  x = BaseWorkflow(conf=conf)
  x.run(in_file, out_file)
  ```


pkgId: 2118ca648509b76abf4c0a49dbc1c1d06fc4870bf0c07739e73d7bbffdcca5ef
name: python-beelzebub-md-iso
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Translate between mdJson and ISO19115-2
url: https://github.com/paul-breen/beelzebub-md-iso
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beelzebub-md-iso-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Beelzebub-md-iso is a subpackage of [beelzebub](https://github.com/paul-breen/beelzebub).  Given a metadata record in [mdJSON](https://www.adiwg.org/projects/#mdjson-schemas) format, it will translate it to [ISO19115-2](https://www.iso.org/standard/67039.html) format.



  ```
  from beelzebub.md_iso import MdjsonToISO19115_2

  conf = {
      'reader': {'iotype': 'file'},
      'writer': {'iotype': 'file'}
  }
  in_file = '/path/to/mdjson/metadata.json'
  out_file = '/path/to/iso19115-2/metadata.xml'

  x = MdjsonToISO19115_2(conf=conf)
  x.run(in_file, out_file)
  ```



  NOAA have useful [metadata resources](https://www.ncei.noaa.gov/resources/metadata), including this [ISO Workbook](http://www.ncei.noaa.gov/sites/default/files/2020-04/ISO%2019115-2%20Workbook_Part%20II%20Extentions%20for%20imagery%20and%20Gridded%20Data.pdf) and this [collection level metadata template](https://data.noaa.gov/waf/templates/iso_u/xml/ncei_template.xml).


pkgId: bb9eca844244b1802bf6db50be8f7fee95200cb529e5c6e3c809783747073bb3
name: python-beem
arch: src
version: 0.24.26
epoch: 0
release: 1
summary: Unofficial Python library for HIVE and STEEM
url: http://www.github.com/holgern/beem
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beem-0.24.26-1.src.rpm
checksum_type: sha256
description:
  beem is an unofficial python library for steem and HIVE, which is created new from scratch from `python-bitshares`_
  The library name is derived from a beam machine, similar to the analogy between steem and steam. beem includes `python-graphenelib`_.


pkgId: 8232c6946b63e4d0f4a75913e5615132a2f1d773a0ace268d6fb9cb5c596d329
name: python-bees-challenge
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: challenge submission for the bees ml path challenge
url: https://github.com/yuiti-ara/yuiti-bees-ml-path-challenge
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bees-challenge-0.24.0-1.src.rpm
checksum_type: sha256
description:
  Welcome to the Fuel Efficiency Path Challenge! In this coding exercise, you are tasked with implementing a series of entities and algorithms to map the most fuel-efficient path through various terrains. This challenge is designed to assess your skills in algorithm implementation, object-oriented programming, and problem-solving.
  **NOTE**: Do NOT modify the tests in the `tests` folder. These tests are used to verify your code and should not be changed.

  Ensure your submission is zipped/compressed, does NOT change the tests, AND includes your `.git` file.

  Your mission involves two key components: `entities` and `algorithms`. These are represented as two separate folders in the repository. Each folder contains files that define the structure and requirements of components you need to implement.

  The `entities` folder contains definitions for different objects in a grid that represents various terrains. Your task is to implement the functionality of these entities. The entities include:
  - `DownHill`
  - `Valley`
  - `Position`
  - `UpHill`
  - `Node`
  - `Plateau`
  Each of these entities plays a role in the simulation of a vehicle moving through different terrains, affecting its fuel efficiency.

  The `algorithms` folder includes files that describe algorithms for pathfinding. These algorithms will be used to determine the most efficient path through the grid considering the different terrains. The algorithms you need to implement are:
  - `Dijkstra`
  - `PathFinding`
  - `AStar`
  You will need to understand and implement these algorithms to find the optimal path in terms of fuel efficiency.

  To assist you in this challenge, a suite of tests is provided. These tests will guide you through the implementation process and ensure your code meets the specified requirements. The tests can be found in the `tests` folder.

  As part of this project, you are required to set up a Continuous Integration and Continuous Deployment (CI/CD) pipeline using GitHub Actions. This pipeline will automate the testing and deployment of your code.

  1. **Testing with pytest**: Upon each push or pull request to the main branch, the CI pipeline should automatically execute tests using pytest. This ensures that all new changes are verified before deployment.
  2. **Building the Package**: If the tests pass, the next step is to build the Python package. This process involves preparing the package for distribution, ensuring that it is ready for deployment to PyPI.
  3. **Creating a GitHub Workflow Artifact**: After successful deployment to PyPI, create a downloadable artifact of your package within the GitHub Workflow. This artifact should be accessible from the GitHub Actions run, allowing users to directly download the package version from GitHub.

  We look forward to seeing your innovative solutions to this unique and challenging problem. Good luck, and happy coding!



     - `DownHill` Implementation: 5 points
     - `Valley` Implementation: 5 points
     - `Position` Implementation: 5 points
     - `UpHill` Implementation: 5 points
     - `Node` Implementation: 5 points
     - `Plateau` Implementation: 5 points

     - `Dijkstra` Algorithm Implementation: 15 points
     - `PathFinding` Algorithm Implementation: 15 points

     - Readability: 5 points
     - Adherence to coding standards/conventions: 5 points

     - Comprehensive test cases: 10 points
     - Test coverage (measured using a tool like `coverage.py`): 10 points

     - Correct setup of GitHub Actions for pytest: 3 points
     - Successful building and packaging of the Python package: 3 points
     - Creation of a downloadable GitHub Workflow artifact: 4 points


pkgId: acc062456e8fd44863ff9e340fbdefd2f7dfa5784e7caba5bc386b420234c98d
name: python-beetcamp
arch: src
version: 0.19.3
epoch: 0
release: 1
summary: Bandcamp autotagger source for beets (http://beets.io).
url: https://github.com/snejus/beetcamp
rpm_license: GPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beetcamp-0.19.3-1.src.rpm
checksum_type: sha256
description:
  [![image](http://img.shields.io/pypi/v/beetcamp.svg)](https://pypi.python.org/pypi/beetcamp)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=snejus_beetcamp&metric=alert_status)](https://sonarcloud.io/dashboard?id=snejus_beetcamp)
  [![Coverage Status](https://coveralls.io/repos/github/snejus/beetcamp/badge.svg?branch=main)](https://coveralls.io/github/snejus/beetcamp?branch=main)
  [ ![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Fsnejus%2Fbeetcamp&count_bg=%23842424&title_bg=%23846060&icon=postwoman.svg&icon_color=%23CF4D4D&title=hits&edge_flat=true)](https://hits.seeyoufarm.com)
  Bandcamp autotagger plugin for [beets]. It mostly focuses on
  - Staying up-to-date with information Bandcamp provide in the JSON metadata
  - Parsing **all possible** (if relevant) metadata from various places
    - For example, a catalog number given in the release or media description
  - Correctness of the data
    - For example, determining artist names from various artists releases
  - Compliance with MusicBrainz fields format, to remove the need for pre-processing if, for
    example, one wishes to upload the metadata to MB.
  Thanks to [unrblt] for [beets-bandcamp] providing the idea and initial implementation.
  [beets]: https://github.com/beetbox/beets
  [unrblt]: https://github.com/unrblt
  [beets-bandcamp]: https://github.com/unrblt/beets-bandcamp


  1. Install `beets` with `pipx` so that it's isolated from your system and other projects
  ```bash
  pipx install beets
  ```
  2. Inject `beetcamp` and other dependencies that you need. The `--include-apps` flag is required to make sure that `beetcamp` is made available in your command line.
  ```bash
  pipx inject --include-apps beets beetcamp [python-mpd2 ...]
  ```
  3. Add `bandcamp` to the `plugins` list to your beets configuration file.

  Navigate to your `beets` virtual environment and install the plug-in with
  ```bash
  pip install beetcamp
  ```

  The plugin exposes some of its functionality through a command-line application `beetcamp`:
  ```xml
  usage: beetcamp [-h] [-a] [-l] [-t] [-o INDEX] [-p PAGE] (release_url | query)
  Get bandcamp release metadata from the given <release-url> or perform
  bandcamp search with <query>. Anything that does not start with https://
  will be assumed to be a query. Search type flags: -a for albums, -l for
  labels and artists, -t for tracks. By default, all types are searched.
  positional arguments:
    release_url  Release URL, starting with https:// OR
    query        Search query
  optional arguments:
    -h, --help   show this help message and exit
    -a, --album  Search albums
    -l, --label  Search labels and artists
    -t, --track  Search tracks
    -o INDEX, --open INDEX
                          Open search result indexed by INDEX in the browser
    -p PAGE, --page PAGE  The results page to show, 1 by default
  ```
  - Use `beetcamp <bandcamp-release-url>` to return release metadata in JSON format.
  - Use `beetcamp [-alt] <query>` to search albums, labels and tracks on Bandcamp and return
    results in JSON.
  - Search results are indexed - add `-o <index>` in order to open the chosen URL in the browser.
  You can see how the data looks below (the output is prettified with [rich-tables]).
  ![image](https://github.com/snejus/beetcamp/blob/fe6ea71a0ab0035d657d13f664de957befb4552c/images/search.png?raw=true)
  [rich-tables]: https://github.com/snejus/rich-tables


  ```yaml
  bandcamp:
    include_digital_only_tracks: true
    search_max: 2
    art: yes
    comments_separator: "\n---\n"
    exclude_extra_fields: []
    genre:
      capitalize: no
      maximum: 0
      always_include: []
      mode: progressive # classical, progressive or psychedelic


pkgId: f23cdcf948bd1eb1f9354ca4d0bb78b2f5238c10c03f6dada36bcc125bd35f7c
name: python-beetlesafari
arch: src
version: 0.4.0
epoch: 0
release: 1
url: https://github.com/haesleinhuepf/beetlesafari
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beetlesafari-0.4.0-1.src.rpm
checksum_type: sha256
summary:
  A napari plugin for loading and working with light sheet imaging data of developing embryos acquired using ClearControl, e.g. _Tribolium castaneum_.

description:
  A library for working with light sheet imaging data of developing embryos acquired using [ClearControl](https://github.com/ClearControl) at the [Center for Systems Biology Dresden](https://www.csbdresden.de/), e.g. _Tribolium castaneum_.


  ```
  conda install -c conda-forge pyopencl
  pip install beetlesafari
  ```


pkgId: 08eedaaf3e85858a7b1b78006b27435e19fd0eac733235b3c4bc6f41702fad97
name: python-beetools
arch: src
version: 5.1.1
epoch: 0
release: 1
summary: Tools for batch scripts, virtual environments and utilities.
url: https://github.com/BrightEdgeeServices/beetools
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beetools-5.1.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) [year] [fullname]  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: baac63362b915a73bb6dd8f1d199913a2e8c74cb4490f82154471af4f061e29f
name: python-beets
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: music tagger and library organizer
url: https://beets.io/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Beets is the media library management system for obsessive music geeks.
  The purpose of beets is to get your music collection right once and for all.
  It catalogs your collection, automatically improving its metadata as it goes.
  It then provides a bouquet of tools for manipulating and accessing your music.
  Here's an example of beets' brainy tag corrector doing its thing::
    $ beet import ~/music/ladytron
    Tagging:
        Ladytron - Witching Hour
    (Similarity: 98.4%)
     * Last One Standing      -> The Last One Standing
     * Beauty                 -> Beauty*2
     * White Light Generation -> Whitelightgenerator
     * All the Way            -> All the Way...
  Because beets is designed as a library, it can do almost anything you can
  imagine for your music collection. Via `plugins`_, beets becomes a panacea:
  - Fetch or calculate all the metadata you could possibly need: `album art`_,
    `lyrics`_, `genres`_, `tempos`_, `ReplayGain`_ levels, or `acoustic
    fingerprints`_.
  - Get metadata from `MusicBrainz`_, `Discogs`_, and `Beatport`_. Or guess
    metadata using songs' filenames or their acoustic fingerprints.
  - `Transcode audio`_ to any format you like.
  - Check your library for `duplicate tracks and albums`_ or for `albums that
    are missing tracks`_.
  - Clean up crufty tags left behind by other, less-awesome tools.
  - Embed and extract album art from files' metadata.
  - Browse your music library graphically through a Web browser and play it in any
    browser that supports `HTML5 Audio`_.
  - Analyze music files' metadata from the command line.
  - Listen to your library with a music player that speaks the `MPD`_ protocol
    and works with a staggering variety of interfaces.
  If beets doesn't do what you want yet, `writing your own plugin`_ is
  shockingly simple if you know a little Python.
      https://beets.readthedocs.org/page/dev/plugins.html
      https://html.spec.whatwg.org/multipage/media.html#the-audio-element
      https://beets.readthedocs.org/page/plugins/missing.html
      https://beets.readthedocs.org/page/plugins/duplicates.html
      https://beets.readthedocs.org/page/plugins/convert.html
      https://beets.readthedocs.org/page/plugins/chroma.html


pkgId: 1bef8e690ec0748bec41399b93c58e4fe1ff856dd49fb36e6dc8f3db2024e60b
name: python-beets-alternatives
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: beets plugin to manage multiple files
url: http://www.github.com/geigerzaehler/beets-alternatives
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-alternatives-0.13.1-1.src.rpm
checksum_type: sha256
description:
  [![Check and test](https://github.com/geigerzaehler/beets-alternatives/actions/workflows/main.yaml/badge.svg)](https://github.com/geigerzaehler/beets-alternatives/actions/workflows/main.yaml)
  [![Coverage Status](https://coveralls.io/repos/github/geigerzaehler/beets-alternatives/badge.svg?branch=main)](https://coveralls.io/github/geigerzaehler/beets-alternatives?branch=main)
  You want to manage multiple versions of your audio files with beets?
  Your favorite iPlayer has limited space and does not support Ogg Vorbis? You
  want to keep lossless versions on a large external drive? You want to
  symlink your audio to other locations?
  With this [beets][beets-docs] plugin every file in you music library have
  multiple alternate versions in separate locations.
  If you’re interested in contributing to this project, check out the [developer
  documentation](./DEVELOPING.md).


pkgId: bb5923ca65e7e3f62583192774ccb01de9f1a23ae0aaecef2f154d907c4d3161
name: python-beets-beetmatch
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: beets plugin for generating playlists of songs that somehow match
url: https://pypi.org/project/beets-beetmatch/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-beetmatch-0.3.0-1.src.rpm
checksum_type: sha256
description:
  A plugin for the [beets](https://beets.io) media library manager that tries to generate playlists from tracks that have
  similar properties.



  The plugin can be installed via pip:

  ```bash
  $ pip install beets-beetmatch
  ```

  To activate the plugin add `beetmatch` to the lists of plugins in your beets config.yaml:

  ```yaml
  plugins:
    - beetmatch
  ```



  The plugin supports music similarity computation using [libmusly](https://github.com/dominikschnitzer/musly).
  In order to allow beetmatch to use this functionality, the [pymusly](https://github.com/andban/pymusly) package has to
  be installed first.



  This plugin works best when it has a set of track attributes that provide addition insight on the audio content of
  individual tracks.

  - [autobpm] computes the BPM of tracks
  - [keyfinder] computes the musical scale of tracks
  - [xtractor] uses Essentia to provide multiple properties that can be used for track similarity (BPM, scales,
    danceability, etc.)
  - ... any plugin that does add one or more properties to the tracks in your library that can be used to determine
    musical similarity.



  This plugin can be configured by providing options in the beets config.yaml under the `beetmatch` section:

  - **auto**: automatically analyze imported tracks when musly is available
  - **[jukeboxes](#jukebox)**: define jukeboxes that narrow tracks used for generating playlists from, e.g. songs
    within the same genre.
  - **[playlist](#playlist)**: defines parameters used for playlist generation
  - **[musly](#musly)**: change if and how musly is used for metadata generation



  A jukebox is a sub-set of songs in your library, that can be used to create playlists from.
  For example, you want to create playlists, which are only generated from songs in the 'electronic' genre.

  A jukebox entry is made up of the following attributes:

  - **name**: The name of the jukebox.
  - **query**: a list of queries that specify which songs should go into the jukebox.

  Example:

  ```yaml
      jukeboxes:
        - name: electronic
          query:
            - 'genre:electronic'
            - 'length:..30:00'
        - name: rock_and_pop
          query: 'genre:(rock|pop|country)'
  ```



  The playlist sections defines how playlists are generated.

  - **default_script**: Define a default script to be call after a playlist was generated.
  - **cooldown**: Define how many songs need to be selected before another song of the same artist or album can be added
    to a playlist.
  - **selection**: Configure the track selection parameters.
    With higher pickiness, the selection will stick to the best matches, for example a pickiness of 1.0 will select only
    the tracks with the highest similarity, while 0.0 will consider every track.
    The minimum pool size configures the minimum number of tracks to consider, even if that will mean to lower the
    pickiness.
    To always select only the tracks with the highest similarity, set pickiness and minimum_pool_size to 1.
  - **attributes**: Configure which attributes of a song are used for similarity computation and how they should be
    measured and weighted. The available attribute types are described further [below](#attribute-types).

  Example:

  ```yaml
      playlist:
        default_script: '~/.config/beets/scripts/music-create-playlist'
        cooldown:
          artist: 5
          album: 2

        selection:
          pickiness: 0.9
          minimum_pool_size: 10

        attributes:
          bpm:
            type: BpmDistance
            weight: 0.4
            config:
              tolerance: 0.04
          genre:
            type: ListDistance
            weight: 0.3
          year:
            type: YearDistance
            weight: 0.3
            config:
              max_diff: 5
  ```



  When libmusly is installed, it's setup for track analysis can be configured in this section.

  - **enabled**: Whether to enable track analysis.
  - **threads**: Number of threads to use when analysing the library.
  - **method**: The algorithm that musly should use for track analysis one of `timbre` or `mandelellis` (not tested).
  - **data_dir**: Where to store musly jukebox information inside `BEETSDIR`

  Example:

  ```yaml
    musly:
      threads: 2
      method: timbre
      data_dir: beetmatch
  ```





  In case you want to use libmusly for track similarity computations, you will need to analyze the tracks and update
  musly jukeboxes first.
  It is recommended to trigger an update whenever you added a lot of new songs to your library, or when you feel that the
  results are somehow off.
  You need to install the [pymusly](https://github.com/andban/pymusly) package to enable this command.

  ```bash
  $ beet beetmatch-musly --write --update
  ```

  ```
  Analyze tracks and update musly jukeboxes

  Usage: beet beetmatch-musly

  Options:
    -h, --help            show this help message and exit
    -u, --update          Update jukeboxes with new musly data
    -w, --write           Write analysis results to meta data database
    -f, --force           [default: False] force analysis of previously analyzed
                          items
    -t THREADS, --threads=THREADS
                          [default: 4] number of threads to use for analysis
  ```



  ```bash
  $ beet beetmatch-generate --jukebox=<jukebox_name> --tracks=30
  ```

  ```
  Usage: beet beetmatch-generate
  Example: beet beetmatch-generate --jukebox=all --duration 60 'artist:Air'

  Options:
    -h, --help            show this help message and exit
    -j JUKEBOX_NAME, --jukebox=JUKEBOX_NAME
                          Name of the jukebox to generate playlist from
                          (required)
    -t NUMTRACKS, --num-tracks=NUMTRACKS
                          Maximum number of tracks to add to the playlist.
    -d DURATION, --duration=DURATION
                          Approximate duration of playlist in minutes.
    -s SCRIPT, --script=SCRIPT
                          Call script after playlist was generated.
                          This overrides the default_script defined in the configuration.
  ```





  This measure considers tracks similar if they use scales that are next to each other in
  the [circle of fifths](https://en.wikipedia.org/wiki/Circle_of_fifths).
  For example a track that uses a C major scale is considered similar to songs that use F major, G major or A minor
  scales.

  This example uses the `key` and `key_scale` properties provided by the xtractor plugin:

  ```yaml
  attributes:
    key:
      type: TonalDistance
      weight: 0.2
      config:
        key_scale: key_scale
  ```

  When the scale attribute contains a combinded key/scale, like the attribute provided by the keyfinder plugin. No
  additional config is needed.



  This measure considers tracks similar if their tempo is within a certain `tolerance`.

  This example uses the `bpm` property with a 4% tolerance level:

  ```yaml
  attributes:
    bpm:
      type: BpmDistance
      weight: 0.2
      config:
        tolerance: 0.04
  ```



  This measure considers tracks similar if the year of release is within a certain timespan.

  The example uses the `year` property with a maximum distance of 10 years:

  ```yaml
  attributes:
    year:
      type: YearDistance
      weight: 0.1
      config:
        max_diff: 10
  ```



  This measure uses libmusly to calculate a similarity based on their timbral properties, i.e. tracks that have a similar
  sound.

  ```yaml
  attributes:
    musly_track:
      type: MuslyDistance
      weight: 0.25
  ```



  This measure uses the difference of two numeric track properties as similarity measure. For example the danceability
  property provided by the xtractor beets plugin.

  ```yaml
  attributes:
    danceability:
      type: NumberDistance
      weight: 0.1
      config:
        min_value: 0
        max_value: 1
  ```



  This measure uses the edit difference of two set properties as similarity, like the style or genre properties provided
  by the Discogs beets plugin.

  ```yaml
  attributes:
    genre:
      type: ListDistance
      weight: 0.1

  ```



  ```bash
  $ docker build -f docker/Dockerfile -t beetmatch .
  $ docker run -it \
       -v "${PWD}/examples/docker:/var/lib/beets" \
       -v "<your music folder>:/var/lib/music:ro" \
       -e "BEETSDIR=/var/lib/beets" \
       -e "MUSIC_FOLDER_HOST=<your music folder>" \
       beetmatch:latest

  beets@docker:/var/lib/beets$ beet import /var/lib/music

  beets@docker:/var/lib/beets$ beet bmm -u -w
  beets@docker:/var/lib/beets$ beet bmg -j electronic -t 10
  ```

  After all these commands are done, you should find a rock.m3u playlist in the examples/docker/playlist folder.

rpm_license:
  MIT License  Copyright (c) 2024 Andreas Bannach  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 08de33e87e3a8f6ab8723412e59251b49dd79c7ea35c21f2ff7d172d66d19eab
name: python-beets-bpmanalyser
arch: src
version: 1.5.9
epoch: 0
release: 1
summary: A beets plugin for analysing tempo of songs and storing it in the bpm tag.
url: https://github.com/adamjakab/BeetsPluginBpmAnalyser
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-bpmanalyser-1.5.9-1.src.rpm
checksum_type: sha256
description:
  [![Test & Release & Deploy](https://github.com/adamjakab/BeetsPluginBpmAnalyser/actions/workflows/test_release_deploy.yml/badge.svg)](https://github.com/adamjakab/BeetsPluginBpmAnalyser/actions/workflows/test_release_deploy.yml)
  [![PyPi](https://img.shields.io/pypi/v/beets-bpmanalyser.svg)](https://pypi.org/project/beets-bpmanalyser/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/beets-bpmanalyser.svg)](https://pypi.org/project/beets-bpmanalyser/)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.txt)



  The _beets-bpmanalyser_ plugin lets you analyse the tempo of the songs you have in your library and write the bpm information on the bpm tag of your media files.

  This plugin has a more powerful big brother which does much more than just extracting bpm: [beets-xtractor plugin](https://github.com/adamjakab/BeetsPluginXtractor).



  The plugin can be installed via:

  ```shell script
  pip install beets-bpmanalyser
  ```

  It has three dependencies: [numpy](https://pypi.org/project/numpy/), [aubio](https://pypi.org/project/aubio/) and [pydub](https://pypi.org/project/pydub/) all of which are installed automatically when installing the plugin itself. Pydub is a wrapper library around ffmpeg or libav which are used to convert audio files to a temporary non-compressed (wav) version before running the aubio analysis on the song.



  Activate the plugin in your configuration file:

  ```yaml
  plugins:
    - bpmanalyser
    
  ```

  Check if plugin is loaded with `beet version`. It should list 'bpmanalyser' amongst the loaded plugins.

  Your default configuration is:

  ```yaml
  bpmanalyser:
    auto: no
    dry-run: no
    write: yes
    threads: "AUTO"
    force: no
    quiet: no
  ```

  By setting the `auto` option to `yes`, the plugin will be run automatically on each new item during import.

  The other configuration options can also be set from the command line when running the plugin.
  Here are the options explained:

  _-d, --dry-run_ : Do not update the library or the media files. Only display the bpm values.

  _-f, --force_ : By default only songs with no bpm value (bpm:0) are analysed. Use this option to force the analysis regardless of the current bpm value.

  _-w, --write_ : Write the bpm values directly to the media files.

  _-t THREADS, --threads=THREADS_: Set the number of processes to run in parallel. By default it is set to AUTO (`threads: AUTO`) and it will use half of the number of cores of your processor(s) have. You can set this to any number to specify how many concurrent threads you want to run.

  _-q, --quiet_ : Do not display any output from the command.

  _-v, --version_ : Displays the version number of the plugin.



  Calculate but show only (do not store) tempo information on all AC/DC songs:

      $ beet bpmanalyser --dry-run artist:AC/DC

  Update tempo information on all songs where it is missing:

      $ beet bpmanalyser bpm:0

  Force the update of tempo information on all songs where it has already been set:

      $ beet bpmanalyser -f ^bpm:0



  BPM values from acousticbrainz:

  ```shell script
  $ beet -c dev.yml acousticbrainz artist:AC/DC
  acousticbrainz: getting data for: [format:MP3][bpm:121.106361389] ::: /_TmpMusic_/A/AC_DC/High Voltage/01. Baby, Please Don't Go.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:117.203399658] ::: /_TmpMusic_/A/AC_DC/High Voltage/02. She's Got Balls.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:106.826393127] ::: /_TmpMusic_/A/AC_DC/High Voltage/03. Little Lover.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:119.486862183] ::: /_TmpMusic_/A/AC_DC/High Voltage/04. Stick Around.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:133.189102173] ::: /_TmpMusic_/A/AC_DC/High Voltage/05. Soul Stripper.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:128.054992676] ::: /_TmpMusic_/A/AC_DC/High Voltage/06. You Ain't Got a Hold on Me.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:123.012046814] ::: /_TmpMusic_/A/AC_DC/High Voltage/07. Love Song.mp3
  acousticbrainz: getting data for: [format:MP3][bpm:136.914703369] ::: /_TmpMusic_/A/AC_DC/High Voltage/08. Show Business.mp3
  ```

  BPM values calculated by aubio:

  ```shell script
  $ beet -c dev.yml bpmanalyser artist:AC/DC -df
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/01. Baby, Please Don't Go.mp3] bpm: 122
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/02. She's Got Balls.mp3] bpm: 117
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/03. Little Lover.mp3] bpm: 106
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/04. Stick Around.mp3] bpm: 120
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/05. Soul Stripper.mp3] bpm: 132
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/06. You Ain't Got a Hold on Me.mp3] bpm: 128
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/07. Love Song.mp3] bpm: 125
  bpmanalyser: Song[/_TmpMusic_/A/AC_DC/High Voltage/08. Show Business.mp3] bpm: 139
  ```



  If something is not working as expected please use the Issue tracker.
  If the documentation is not clear please use the Issue tracker.
  If you have a feature request please use the Issue tracker.
  In any other situation please use the Issue tracker.



  - [beets-goingrunning](https://github.com/adamjakab/BeetsPluginGoingRunning)
  - [beets-xtractor](https://github.com/adamjakab/BeetsPluginXtractor)
  - [beets-yearfixer](https://github.com/adamjakab/BeetsPluginYearFixer)
  - [beets-autofix](https://github.com/adamjakab/BeetsPluginAutofix)
  - [beets-describe](https://github.com/adamjakab/BeetsPluginDescribe)
  - [beets-bpmanalyser](https://github.com/adamjakab/BeetsPluginBpmAnalyser)
  - [beets-template](https://github.com/adamjakab/BeetsPluginTemplate)



  Many thanks to the developers and contributors of the [beets check plugin](https://github.com/geigerzaehler/beets-check). Some structural concepts and best practices were adopted to get started on this plugin.



  Enjoy!


pkgId: faa28a04cb4b2b026c8bac3b2c002025d75fd1f0eab841b34c1ac44fc24c5c90
name: python-beets-copyartifacts3
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: beets plugin to copy non-music files to import path
url: https://github.com/adammillerio/beets-copyartifacts
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-copyartifacts3-0.1.5-1.src.rpm
checksum_type: sha256
description:
  A plugin that moves non-music files during the import process.
  This is a plugin for `beets <http://beets.radbox.org/>`__: a music
  library manager and much more.


pkgId: 4117e47ce618175afb8822edf7bf0a78d469a5156bf42978e89bd0ffb934e1c3
name: python-beets-extrafiles
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: A plugin for beets that copies additional files and directories during the import process.
url: https://github.com/Holzhaus/beets-extrafiles
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-extrafiles-0.0.7-1.src.rpm
checksum_type: sha256
description:
  A plugin for [beets](http://beets.io/) that copies additional files and directories during the import process.




  **Important:** Even though beets supports Python 2 and Windows, this plugin does not - it only supports Python 3 on a Unix-like OS. See the [F.A.Q. section](#faq) for details.

  This plugin has no dependencies apart from [`setuptools`](https://pypi.org/project/setuptools/) and [`beets`](https://pypi.org/project/beets/) itself.

  The plugin in release on [PyPI](https://pypi.org/project/beets-extrafiles/) and can be installed via:

      $ pip3 install --user beets-extrafiles

  It is also possible to clone the git repository and install the plugin manually:

      $ git clone https://github.com/Holzhaus/beets-extrafiles.git
      $ cd beets-extrafiles
      $ ./setup.py install --user




  Activate the plugin by adding it to the `plugins` list in beet's `config.yaml`:

  ```yaml
  plugins:
    
    - extrafiles
  ```

  Also, you need to add [glob patterns](https://docs.python.org/3/library/glob.html#module-glob) that will be matched.
  Patterns match files relative to the root directory of the album, which is the common directory of all the albums files.
  This means that if an album has files in `albumdir/CD1` and `albumdir/CD2`, then all patterns will match relative to `albumdir`.

  The snippet below will add a pattern group named `all` that matches all files that have an extension.

  ```yaml
  extrafiles:
      patterns:
          all: '*.*'
  ```

  Pattern names are useful when you want to customize the destination path that the files will be copied or moved to.
  The following configuration will match all folders named `scans`, `Scans`, `artwork` or `Artwork` (using the pattern group `artworkdir`), copy them to the album path and rename them to `artwork`:

  ```yaml
  extrafiles:
      patterns:
          artworkdir:
            - '[sS]cans/'
            - '[aA]rtwork/'
      paths:
          artworkdir: $albumpath/artwork
  ```




  After cloning the git repository, you can use `setup.py` to set up the necessary symlinks for you:

      $ git clone https://github.com/Holzhaus/beets-extrafiles.git
      $ cd beets-extrafiles
      $ ./setup.py develop --user

  When adding changes, please conform to [PEP 8](https://www.python.org/dev/peps/pep-0008/).
  Also, please add docstrings to all modules, functions and methods that you create.
  Use can check this by running [`flake8`](http://flake8.pycqa.org/en/latest/index.html) with the [`flake8-docstrings` plugin](https://pypi.org/project/flake8-docstrings/).

  Using [pre-commit](https://pre-commit.com/) will perform these checks automatically when committing changes.
  You can install the pre-commit hooks by executing this in the git repository's root directory:

      $ pre-commit install

  You should also *test every single commit* by running unittests, i.e.:

      $ ./setup.py test

  If a test fails, please fix it *before* you create a pull request.
  If you accidently commit something that still contains errors, please amend, squash or fixup that commit instead of adding a new one.






  The [`copyartifacts` plugin](https://github.com/sbarakat/beets-copyartifacts) by Samit Barakat serves the same purpose.

  However, it curently seems to be unmaintained:
  The last commit has been made over a year ago and also suffers from a [bug](https://github.com/sbarakat/beets-copyartifacts/issues/38) that makes it crash on every run.
  I wrote a patch and filed a [Pull Request](https://github.com/sbarakat/beets-copyartifacts/pull/43) some time ago, but I has not been merged yet.

  Also, wanted to go in a different direction by supporting folders and the ability to do finer-grained path customizations.
  Hence, I wrote `beets-extrafiles`.



  I initally wrote this plugin, because I needed it.
  Since I use neither Python 2 nor Windows, I didn't implement support.

  If you really need support, feel free to write a patch and file a Pull Request.
  As long as it does not make the code considerably harder to read, I'll merge it.

  For Windows support, some kind of Continuous Integration (CI) solution would also be necessary to prevent future breakage.



  This project is released under the terms of the [MIT license](LICENSE).


pkgId: 6570f3f11b7c820dfc9ca475548a603d19fff14a92aa26e47552caeb5fce5aa4
name: python-beets-gdplaylists
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: beets plugin to create Grateful Dead playlists
url: https://pypi.org/project/beets-gdplaylists/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-gdplaylists-0.2.10-1.src.rpm
checksum_type: sha256
description:
  A plugin for [beets](https://github.com/beetbox/beets) to create playlists for live Grateful Dead releases in your library.

  It came about because I wanted to be able to listen to individual shows with their tracks in the right order, as opposed
  to the disc order which might have been changed to fit more onto the discs.




  * Creates Plex playlists from releases it finds in your collection
  * Updates the same playlists if you add more releases to your library


  It does this by creating m3u playlist files for each show that it knows about
  and can find tracks for you in your library. This all done by Musicbrainz track IDs, so your
  library will need to be properly tagged.

  The m3u file is copied to where your Plex server can read it, and then Plex is instructed
  to create a playlist.




  ```sh
  python3 -m pip install beets-gdplaylists

  ```




  Enabled the plugin:

  ```yaml
  plugins:
      - gdplaylists
  ```

  Ensure your plex connection is configured:

  ```yaml
  plex:
      host: localhost
      secure: false
      token: &lt;your token here&gt;
      library_name: "Music"
  ```

  By default, the m3u files will be placed in a directory called `.playlists` in the root
  of your library (`directory` in your config file). If you need to change that, you can
  reconfigure the plugin:

  ```yaml
  gdplex:
      playlist_dir: "/Volumes/music/.playlists/"
      
  ```

  If, for some reason, this means the directory that Plex sees is different, you can configure
  that with the `remote_dir` field. If your beets and plex servers see the same files at
  the same paths, you won't need that at all.




  ```sh
  beet gdplex

  ```

  By default it's very quiet, you can use `beet -vv gdplex` to see what it's doing.


pkgId: 9083eeb37b176ae597a146cc959f7182b4f76d16ef09f3fbf3b55f57405c2bf3
name: python-beets-goingrunning
arch: src
version: 1.2.10
epoch: 0
release: 1
summary: ('A beets plugin for creating and exporting songs that match your running session.',)
url: https://github.com/adamjakab/BeetsPluginGoingRunning
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-goingrunning-1.2.10-1.src.rpm
checksum_type: sha256
description:
  [![Coverage Status](https://coveralls.io/repos/github/adamjakab/BeetsPluginGoingRunning/badge.svg?branch=master)](https://coveralls.io/github/adamjakab/BeetsPluginGoingRunning?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/beets-goingrunning.svg)](https://pypi.org/project/beets-goingrunning/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/beets-goingrunning.svg)](https://pypi.org/project/beets-goingrunning/)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.txt)



  The *beets-goingrunning* is a [beets](https://github.com/beetbox/beets) plugin for obsessive-compulsive music geek runners. It lets you configure different training activities by filtering songs based on their tag attributes (bpm, length, mood, loudness, etc), generates a list of songs for that specific training and copies those songs to your player device.

  Have you ever tried to beat your PR and have good old Bob singing about ganja in the background? It doesn’t really work. Or don't you know how those recovery session end up with the Crüe kickstarting your heart? You'll be up in your Zone 4 in no time.

  The fact is that it is very difficult and time consuming to compile an appropriate playlist for a specific training session. This plugin tries to help runners with this by allowing them to use their own library.




  To use this plugin at its best and to benefit the most from your library, you will want to make sure that your songs have the most possible information on rhythm, moods, loudness, etc.

  Without going into much detail the most fundamental information you will want to harvest is `bpm`. Normally, when you run a fast pace training you will keep your pace (the number of times your feet hit the ground in a minute) around 170-180. If you are listening to songs with the same rhythm it helps a lot. If your library has many songs without the bpm information (check with `beet ls bpm:0`) you will not be able to use those songs. So, you should consider updating them. There are many tools you can use:

  1) Use the built-in [acousticbrainz plugin](https://beets.readthedocs.io/en/stable/plugins/acousticbrainz.html) to fetch the bpm plus many other information about your songs. This is your starting point. It is as easy as `beet cousticbrainz` and it will do the rest. This tool is based on an on-line database so it will be able to fetch only what has been submitted by someone else. If you have many "uncommon" songs you will need to integrate it with other tools. (My library was still 30% uncovered after a full scan.)

  2) Use the [bpmanalyser plugin](https://github.com/adamjakab/BeetsPluginBpmAnalyser). This will scan your songs and calculate the tempo (bpm) value for them. If you have a big collection it might take a while, but since this tool does not use an on-line database, you can potentially end up with 100% coverage. This plugin will only give you bpm info.

  3) [Essentia extractors](https://essentia.upf.edu/index.html). The Acoustic Brainz (AB) project is based partly on these low and high level extractors. There is currently a highly under-development project [xtractor plugin](https://github.com/adamjakab/BeetsPluginXtractor) which aims to bring your library to 100% coverage. However, for the time being there are no distributable static extractors, so wou will have to compile your own extractors.

  There are many other ways and tools we could list here but I think you got the point...



  The plugin can be installed via:

  ```shell script
  $ pip install beets-goingrunning
  ```

  Activate the plugin in your configuration file by adding `goingrunning` to the plugins section:

  ```yaml
  plugins:
      - goingrunning
  ```

  Check if plugin is loaded with `beet version`. It should list 'goingrunning' amongst the loaded plugins.

  If you already have the plugin installed but a newer version is available you can use `pip install --upgrade beets-goingrunning` to upgrade it.



  Invoke the plugin as:

      $ beet goingrunning training [options] [QUERY...]

  or with the shorthand alias `run`:

      $ beet run training [options] [QUERY...]

  The following command line options are available:

  **--list [-l]**: List all the configured trainings. With `beet goingrunning --list` you will be presented the list of the trainings you have configured in your configuration file.

  **--count [-c]**: Count the number of songs available for a specific training. With `beet goingrunning longrun --count` you can see how many of your songs will fit the specifications for the `longrun` training.

  **--dry-run [-r]**: Only display what would be done without actually making changes to the file system. The plugin will run without clearing the destination and without copying any files.

  **--quiet [-q]**: Do not display any output from the command.

  **--version [-v]**: Display the version number of the plugin. Useful when you need to report some issue and you have to state the version of the plugin you are using.




  All your configuration will need to be created under the key `goingrunning`. There are three concepts you need to know to configure the plugin: `targets`, `trainings` and `flavours`. They are explained in detail below.




  Targets are named destinations on your file system to which you will be copying your songs. The `targets` key allows you to define multiple targets so that under a specific training session you will only need to refer to it with the `target` key.

  The configuration of the target names `MPD1` will look like this:

  ```yaml
  goingrunning:
      targets:
        MPD1:
          device_root: /media/MPD1/
          device_path: MUSIC/AUTO/
          clean_target: yes
          delete_from_device:
            - LIBRARY.DAT
          generate_playlist: yes
          copy_files: yes
  ```

  The key `device_root` indicates where your operating system mounts the device. The key `device_path` indicates the folder inside the device to which your audio files will be copied. In the above example the final destination is `/media/MPD1/MUSIC/AUTO/`. It is assumed that the folder indicated in the `device_path` key exists. If it doesn't the plugin will exit with a warning. The device path can also be an empty string if you want to store the files in the root folder of the device.

  The key `clean_target`, when set to yes, instructs the plugin to clean the `device_path` folder before copying the new songs to the device. This will remove all audio songs and playlists found in that folder.

  Some devices might have library files or other data files which need to be deleted in order for the device to re-discover the new songs. These files can be added to the `delete_from_device` key. The files listed here are relative to the `device_root` directive.

  You can also generate a playlist by setting the `generate_playlist` option to `yes`. It will create an .m3u playlist file and store it to your `device_path` location.

  There might be some special conditions in which you do not want to copy files to the device. In fact, the destination folder (`device_root`/`device_path`) might refer to an ordinary folder on your computer and you might want to create only a playlist there. In this case, you want to disable the copying of the music files by setting `copy_files: no`. By default, `copy_files` is always enabled so in the above `MPD1` target it could also be omitted and files would be copied all the same.




  Trainings are the central concept behind the plugin. When you are "going running" you will already have in mind the type of training you will be doing. This configuration section allows you to preconfigure filters that will allow you to launch a `beet run 10K` command whilst you are tying your shoelaces and be out of the house as quick as possible. In fact, the `trainings` section is there for you to be able to preconfigure these trainings.

  The configuration of a hypothetical 10K training might look like this:

  ```yaml
  goingrunning:
    trainings:
      10K:
        query:
          bpm: 160..180
          mood_aggressive: 0.6..
          ^genre: Reggae
        ordering:
          bpm: 100
          average_loudness: 50
        use_flavours: []
        duration: 60
        target: MPD1
  ```


  The keys under the `query` section are exactly the same ones that you use when you are using beets for any other operation. Whatever is described in the [beets query documentation](https://beets.readthedocs.io/en/stable/reference/query.html) applies here with two restriction: you must query specific fields in the form of `field: value` and (for now) regular expressions are not supported.


  At the time being there is only one ordering algorithm (`ScoreBasedLinearPermutation`) which orders your songs based on a scoring system. What you indicate under the `ordering` section is the fields by which the songs will be ordered. Each field will have a weight from -100 to 100 indicating how important that field is with respect to the others. Negative numbers indicate a reverse ordering. (@todo: this probably needs an example.)


  You will find that many of the query specification that you come up with will be repeated across different trainings. To reduce repetition and at the same time to be able to combine many different recipes you can use flavours. Similarly to targets, instead of defining the queries directly on your training you can define queries in a separate section called `flavours` (see below) and then use the `use_flavours` key to indicate which flavours to use. The order in which flavours are indicated is important: the first one has the highest priority meaning that it will overwrite any keys that might be found in subsequent flavours.


  The duration is expressed in minutes and serves the purpose of defining the total length of the training so that the plugin can select the exact number of songs.


  This key indicates to which target (defined in the `targets` section) your songs will be copied to.


  You might also define a special `fallback` training:

  ```yaml
  goingrunning:
    trainings:
      fallback:
        target: my_other_player
  ```

  Any key not defined in a specific training will be looked up from the `fallback` training. So, if in the `10K` example you were to remove the `target` key, it would be looked up from the `fallback` training and your songs would be copied to the `my_other_device` target.


  In the default configuration of the plugin, on the `fallback` training there are two disabled options that you might want to consider enabling: `increment_play_count` and `favour_unplayed`. They are meant to be used together. The `increment_play_count` option, on copying your songs to your device, will increment the `play_count` attribute by one and store it in your library and on your media file. The `favour_unplayed` option will instruct the algorithm that picks the songs from your selection to favour the songs that have lower `play_count`. This feature will make you discover songs in your library that you might have never heard. At the same time it ensures that the proposed songs are always changed even if you keep your selection query and your ordering unchanged.



  The flavours section serves the purpose of defining named queries. If you have 5 different high intensity trainings different in length but sharing queries about bpm, mood and loudness, you can create a single definition here, called flavour, and reuse that flavour in your different trainings with the `use_flavours` key.

  **Note**: Because flavours are only used to group query elements, the `query` key should not be used here (like it is in trainings).

  ```yaml
  goingrunning:
    flavours:
      overthetop:
        bpm: 170..
        mood_aggressive: 0.8..
        average_loudness: 50..
      rocker:
        genre: Rock
      metallic:
        genre: Metal
      sunshine:
        genre: Reggae
      60s:
        year: 1960..1969
      chillout:
        bpm: 1..120
        mood_happy: 0.5..1
  ```

  This way, from the above flavours you might add `use_flavours: [overthetop, rock, 60s]` to one training and `use_flavours: [overthetop, metallic]` to another so they will share the same `overthetop` intensity definition whilst having different genre preferences. Similarly, your recovery session might use `use_flavours: [chillout, sunshine]`.



  When it comes to handling queries, this plugin introduces some major differences with respect to the beets core you need to be aware of.


  You might define different flavours in which some of the same fields are defined, like the `genre` field in the `rocker` and the `metallic` flavours above. You can define a training that makes use of those flavours and optionally adding the same field through a direct query section, like this:

  ```yaml
  goingrunning:
    trainings:
      HM:
        query:
          genre: Folk
        use_flavours: [rocker, metallic]
  ```

  The resulting query will include songs corresponding to any of the three indicated genres: `genre='Folk' OR genre='Rock' OR genre='Metal'`. This, of course, is applicable to all fields.



  Sometimes it is cumbersome to define a separate flavour for each additional value of a specific field. For example, it would be nice to have the above `chillout` flavour to include a list of genres instead of having to combine it with multiple flavours. Well, you can just do that by using the list notation like this:
  ```yaml
  goingrunning:
    flavours:
      chillout:
        bpm: 1..120
        mood_happy: 0.5..1
        genre: [Soul, Oldies, Ballad]
  ```

  or like this:

  ```yaml
  goingrunning:
    flavours:
      chillout:
        bpm: 1..120
        mood_happy: 0.5..1
        genre:
          - Soul
          - Oldies
          - Ballad
  ```
  The resulting query will have the same effect including all indicated genres: `genre='Soul' OR genre='Oldies' OR genre='Ballad'`. This technique can be applied to all fields.



  What is described above also applies to negated fields. That is to say, you can also negate a field and use it as a list to query your library by excluding all those values:
  ```yaml
  goingrunning:
    flavours:
      not_good_for_running:
        ^genre: [Jazz, Psychedelic Rock, Gospel]
  ```
  When the above flavour is compiled it will result in a query excluding all indicated genres: `genre!='Jazz' AND genre!='Psychedelic Rock' AND genre!='Gospel'`. This technique can be applied to all fields.



  In my experience the configuration section can grow quite long depending on your needs, so I find it useful to keep my `goingrunning` specific configuration in a separate file and from the main configuration file include it like this:

  ```yaml
  include:
      - plg_goingrunning.yaml
  ```




  Show all the configured trainings:

      $ beet goingrunning --list

  Check what would be done for the `10K` training:

      $ beet goingrunning 10K --dry-run

  Let's go! Copy your songs to your device based on the `10K` training and using the plugin shorthand:

      $ beet run 10K

  Do the same as above but today you feel Ska:

      $ beet run 10K genre:ska




  - If something is not working as expected please use the Issue tracker.
  - If the documentation is not clear please use the Issue tracker.
  - If you have a feature request please use the Issue tracker.
  - In any other situation please use the Issue tracker.



  Please check the [ROADMAP](./docs/ROADMAP.md) file. If there is a feature you would like to see but which is not planned, create a feature request in the Issue tracker.



  Enjoy!


pkgId: db339b62b211944fcafdcd85b643c6120fee9087f2c1f65c472c4b4589b44a95
name: python-beets-stylize
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Stylize Plugin for Beets
url: https://github.com/kergoth/beets-stylize
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-stylize-1.2.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/beets-stylize.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/beets-stylize.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/beets-stylize)][pypi status]
  [![License](https://img.shields.io/pypi/l/beets-stylize)][license]

  [![Read the documentation at https://beets-stylize.readthedocs.io/](https://img.shields.io/readthedocs/beets-stylize/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![The Ethical Source Principles](https://img.shields.io/badge/ethical-source-%23bb8c3c?labelColor=393162)][ethical source]
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)][contributor covenant]
  [![Tests](https://github.com/kergoth/beets-stylize/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/kergoth/beets-stylize/branch/main/graph/badge.svg)][codecov]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Ruff codestyle][ruff badge]][ruff project]

  [pypi status]: https://pypi.org/project/beets-stylize/
  [ethical source]: https://ethicalsource.dev/principles/
  [read the docs]: https://beets-stylize.readthedocs.io/
  [tests]: https://github.com/kergoth/beets-stylize/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/kergoth/beets-stylize
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [ruff badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
  [ruff project]: https://github.com/charliermarsh/ruff

  ![Album Listing][]

  The [stylize](https://github.com/kergoth/beets-stylize) plugin adds style and color to the [list][] command and other commands that need to print out items, by adding three [template functions][] for use with the [format_item][] and [format_album][] configuration options.

  - `stylize` or `color`: Add color and formatting to your formatted items and albums.
  - `nocolor`: Show the supplied text only when color is disabled. This is useful to add separators between fields when color is unavailable.
  - `link`: Create clickable links in the terminal. This has no effect on an unsupported terminal. This lets you play a track or navigate to an album folder with a click.
  - `urlencode`: URL-encode the supplied text.



  As the beets documentation describes in [Other plugins][], to use an external plugin like this one, there are two options for installation:

  - Make sure it’s in the Python path (known as `sys.path` to developers). This just means the plugin has to be installed on your system (e.g., with a setup.py script or a command like pip or easy_install). For example, `pip install beets-stylize`.
  - Set the pluginpath config variable to point to the directory containing the plugin. (See Configuring) This would require cloning or otherwise downloading this [repository](https://github.com/kergoth/beets-stylize) before adding to the pluginpath.



  First, enable the `stylize` plugin (see [Using Plugins][]). Colors for use with the `stylize` function may be defined using the [colors][] option under [UI Options][] in your beets configuration. For example:

  ```yaml
  ui:
    colors:
      artist: ["bold", "green"]
  ```



  The `stylize` function accepts a named color as the first argument, the text to be stylized as the second, and an optional third argument for the text to be used if color is disabled.



  Example usage in your beets configuration, based on the default `format_item` and `format_album` configuration options:

  ```yaml
  ui:
    color: true
    colors:
      
      album: ["blue", "bold"]
      albumartist: ["yellow"]
      artist: ["bold", "yellow"]
      title: ["normal"]

  format_item: "%stylize{artist,$artist} %nocolor{- }%stylize{album,$album} %nocolor{- }%stylize{title,$title}"
  format_album: "%stylize{albumartist,$albumartist} %nocolor{- }%stylize{album,$album}"
  ```

  With this configured, we see listings like this:

  ![Album Listing][]

  And this:

  ![Track Listing][]

  If no color is available, such as due to redirection, or setting the `NO_COLOR` environment variable, we see a listing like this due to the use of `%nocolor` to add the separator:

  ![Nocolor Listing][]

  As an example of how to use `%link`, this would make the entire line a clickable link to the file path:

  ```yaml
  format_item: "%link{file://$path,$artist - $album - $title}"
  ```

  As we see here, in the Visual Studio Code terminal:

  ![Link Listing][]



  ![Personal Config Listings][]

  This example is more elaborate, and includes usage of [alias][], [savedformats][], [inline][] and [albumtypes][]. [alias][] is only used to provide separate commands that use `%link`, as using it seems to have a performance impact, so I don't want it always used. [savedformats][] is only used to split up the default format strings for readability and maintainability, but is not required. [inline][] can be used instead of [savedformats][] to provide the `icon` field.

  ```yaml
  plugins: stylize alias savedformats inline albumtypes

  aliases:
    lsl:
      help: List items, linking to their files
      command: ls -f '%link{file://$path,$icon} $format_item'
      aliases: list-linked

    lsf:
      help: List items, with links to play them in foobar2000 (macOS only)
      command: ls -f '%link{shortcuts://run-shortcut?name=Open in foobar2000&input=text&text=%urlencode{$path},$icon} $format_item'
      aliases: list-foobar2k

  item_fields:
    icon: '"📄"'
    disc_and_track: |
      if not track or (tracktotal and tracktotal == 1):
        return ''
      elif disctotal > 1:
        return u'%02i.%02i' % (disc, track)
      else:
        return u'%02i' % track

  album_fields:
    icon: '"📁"'

  item_formats:
    format_item: "%ifdef{id,$format_id }%if{$singleton,,$format_album_title %nocolor{| }}$format_year %nocolor{- }$format_track"

    format_id: "%stylize{id,$id,[$id]}"
    format_album_title: "%stylize{album,$album%aunique{}}%if{$albumtypes,%stylize{albumtypes,%ifdef{atypes,%if{$atypes, $atypes}}}}"
    format_year: "%stylize{year,$year}"

    format_track: "%if{$singleton,,%if{$disc_and_track,$format_disc_and_track %nocolor{- }}}$format_artist$format_title"
    format_disc_and_track: "%stylize{track,$disc_and_track}"
    format_artist: "%stylize{artist,$artist} %nocolor{- }"
    format_title: "%stylize{title,$title}"

  album_formats:
    format_album: "%ifdef{id,$format_album_id }%if{$albumartist,$format_albumartist %nocolor{- }}$format_album_title %nocolor{| }$format_year"

    format_album_id: "%stylize{id,$id,[$id]}"
    format_albumartist: "%stylize{albumartist,$albumartist}"
    format_album_title: "%stylize{album,$album%aunique{}}%if{$albumtypes,%stylize{albumtypes,%ifdef{atypes,%if{$atypes, $atypes}}}}"
    format_year: "%stylize{year,$year}"

    
    format_item: "$format_album"

  format_album: "$format_album"
  format_item: "$format_item"

  ui:
    colors:
      album: ["blue", "bold"]
      albumartist: ["yellow", "bold"]
      albumtypes: ["cyan"]
      artist: ["yellow", "bold"]
      id: ["faint"]
      title: ["normal"]
      track: ["green"]
      year: ["magenta", "bold"]
  ```



  Contributions are very welcome.
  To learn more, see the [Contributor Guide].



  Distributed under the terms of the [MIT license][license],
  _Stylize Plugin for Beets_ is free and open source software. This software prioritizes meeting the criteria of the [Ethical Source Principles][ethical source], though it does not currently utilize an [ethical source license][].



  If you encounter any problems,
  please [file an issue] along with a detailed description.



  This project is a plugin for the [beets][] project, and would not exist without that fantastic project.
  This project was generated from [@cjolowicz]'s [Hypermodern Python Cookiecutter] template.

  [template functions]: https://beets.readthedocs.io/en/stable/reference/pathformat.html#template-functions
  [beets]: https://beets.readthedocs.io/en/stable/index.html
  [format_item]: https://beets.readthedocs.io/en/stable/reference/config.html#id66
  [format_album]: https://beets.readthedocs.io/en/stable/reference/config.html#id67
  [list]: https://beets.readthedocs.io/en/stable/reference/cli.html#list-cmd
  [other plugins]: https://beets.readthedocs.io/en/stable/plugins/index.html#other-plugins
  [using plugins]: https://beets.readthedocs.io/en/stable/plugins/index.html#using-plugins
  [colors]: https://beets.readthedocs.io/en/stable/reference/config.html#colors
  [ui options]: https://beets.readthedocs.io/en/stable/reference/config.html#id81
  [@cjolowicz]: https://github.com/cjolowicz
  [hypermodern python cookiecutter]: https://github.com/cjolowicz/cookiecutter-hypermodern-python
  [ethical source license]: https://ethicalsource.dev/faq/#what-is-an-ethical-license-for-open-source
  [file an issue]: https://github.com/kergoth/beets-stylize/issues
  [alias]: https://github.com/kergoth/beets-alias
  [savedformats]: https://github.com/kergoth/beets-kergoth/blob/master/docs/savedformats.rst
  [inline]: https://beets.readthedocs.io/en/stable/plugins/inline.html
  [albumtypes]: https://beets.readthedocs.io/en/stable/plugins/albumtypes.html

  <!-- github-only -->

  [track listing]: https://raw.githubusercontent.com/kergoth/beets-stylize/main/docs/images/track_listing.png
  [album listing]: https://raw.githubusercontent.com/kergoth/beets-stylize/main/docs/images/album_listing.png
  [nocolor listing]: https://raw.githubusercontent.com/kergoth/beets-stylize/main/docs/images/nocolor_listing.png
  [link listing]: https://raw.githubusercontent.com/kergoth/beets-stylize/main/docs/images/link_listing.png
  [personal config listings]: https://raw.githubusercontent.com/kergoth/beets-stylize/main/docs/images/my_config_listings.png
  [license]: ./LICENSE
  [contributor guide]: ./CONTRIBUTING.md
  [contributor covenant]: ./CODE_OF_CONDUCT.md


pkgId: 8fe9b71eed5f1a7570d6132e1ac33515938d9f624d9194a9a0078090a935715e
name: python-beets-xtractor
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: ('A beets plugin that extracts music descriptors from your audio files',)
url: https://github.com/adamjakab/BeetsPluginXtractor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beets-xtractor-0.4.2-1.src.rpm
checksum_type: sha256
description:
  [![Test & Release & Deploy](https://github.com/adamjakab/BeetsPluginXtractor/actions/workflows/test_release_deploy.yml/badge.svg)](https://github.com/adamjakab/BeetsPluginXtractor/actions/workflows/test_release_deploy.yml)
  [![Coverage Status](https://coveralls.io/repos/github/adamjakab/BeetsPluginXtractor/badge.svg?branch=master)](https://coveralls.io/github/adamjakab/BeetsPluginXtractor?branch=master)
  [![PyPi](https://img.shields.io/pypi/v/beets-xtractor.svg)](https://pypi.org/project/beets-xtractor/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/beets-xtractor.svg)](https://pypi.org/project/beets-xtractor/)
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE.txt)



  The _beets-xtractor_ plugin lets you, through the use of the [Essentia](https://essentia.upf.edu/index.html) extractors,
  to obtain low and high level musical information from your songs.

  Currently, the following attributes are extracted for each library item:
  `bpm`, `danceability`, `beats_count`, `average_loudness`, `danceable`, `gender`, `is_male`, `is_female`,
  `genre_rosamerica`, `voice_instrumental`, `is_voice`, `is_instrumental`, `mood_acoustic`,
  `mood_aggressive`, `mood_electronic`, `mood_happy`, `mood_sad`, `mood_party`, `mood_relaxed`, `mood_mirex`,
  `mood_mirex_cluster_1`, `mood_mirex_cluster_2`, `mood_mirex_cluster_3`, `mood_mirex_cluster_4`, `mood_mirex_cluster_5`



  The plugin can be installed via:

  ```shell script
  pip install beets-xtractor
  ```

  and activated the usual way by adding `xtractor` to the list of plugins in your configuration:

  ```yaml
  plugins:
    - xtractor
  ```



  You will also need the `streaming_extractor_music` binary extractor from the [Essentia project](#credits).
  Please refer to the [official installation documentation](https://essentia.upf.edu/installing.html#compiling-essentia-from-source)
  for the installation procedure for your OS. If you are stuck you can use
  the [Issue tracker](https://github.com/adamjakab/BeetsPluginXtractor/issues). If you are compiling Essentia from source,
  make sure you compile it with Gaia support (`--with-gaia`) otherwise will not be able to use the high level models.



  For computing the high-level descriptors you will need the prebuilt trained models for prediction. You need to download these from
  here: [SVM Models](https://essentia.upf.edu/svm_models/). I suggest that you download the most recent beta5 version.
  This means that your binaries must match this version. Put the downloaded models in any folder from which they can be
  accessed.



  All your configuration will need to go under the `xtractor` key. This is what your configuration should look like:

  ```yaml
  xtractor:
    auto: no
    dry-run: no
    write: yes
    threads: 1
    force: no
    quiet: no
    keep_output: yes
    keep_profiles: no
    output_path: /mnt/data/xtraction_data
    essentia_extractor: /mnt/data/extractors/beta5/streaming_extractor_music
    extractor_profile:
      highlevel:
        svm_models:
          - /mnt/data/extractors/beta5/svm_models/danceability.history
          - /mnt/data/extractors/beta5/svm_models/gender.history
          - /mnt/data/extractors/beta5/svm_models/genre_rosamerica.history
          - /mnt/data/extractors/beta5/svm_models/mood_acoustic.history
          - /mnt/data/extractors/beta5/svm_models/mood_aggressive.history
          - /mnt/data/extractors/beta5/svm_models/mood_electronic.history
          - /mnt/data/extractors/beta5/svm_models/mood_happy.history
          - /mnt/data/extractors/beta5/svm_models/mood_sad.history
          - /mnt/data/extractors/beta5/svm_models/mood_party.history
          - /mnt/data/extractors/beta5/svm_models/mood_relaxed.history
          - /mnt/data/extractors/beta5/svm_models/voice_instrumental.history
          - /mnt/data/extractors/beta5/svm_models/moods_mirex.history
  ```

  First of all, you will need adjust all paths. Put the path of the extractor binary in `essentia_extractor` and
  substitute the location of the SVM models with your local path under the `svm_models` section. Finally, set
  the `output_path` to indicate where the extracted data files will be stored. If you do not set this, a temporary path
  will be used.
  will be used.

  **Note on shell tilde expansion**: Please note that you cannot use shell expansion on the `svm_models` (i.e.: do not use `~` for your home folder).
  The entire section of `extractor_profile` is passed as-is to the essentia extractor binary and it will not do tilde expansion on your paths.
  The rest of the path keys such as `essentia_extractor` and `output_path` are used by the plugin itself and it will take
  care of expanding the tilde symbol (`~`) to the home directory of the user running the script.
  care of expanding the tilde symbol (`~`) to the home directory of the user running the script.

  By default both `keep_output` and `keep_profile` options are set to `no`. This means that after extraction (and the
  storage of the important information) the profile files used to pass to the extractors, and the json files created by
  the extractors will be deleted. There are various reasons you might want to keep these files. One is for debugging
  purposes. Another is to see what else is in these files (there is a lot) and maybe to use them with some other projects
  of yours. Lastly, you might want to keep these because the plugin only extracts data if these files are not present. If
  you store them, on a successive extraction, the plugin will skip the extraction and use these files (they are named
  by `mb_trackid`) - speeding up the process a lot.

  The `force` option instructs the plugin to execute on items which already have the required properties.

  The `threads` option sets the number of concurrent executions. By default this is set to 1.
  If you remove this option or if you set it to 0 the number of CPU cores present on your machine will be used.
  The extraction is quite a CPU intensive process so there might be cases when you want to limit it to just 1.

  The `write` option instructs the plugin to write the extracted attributes to the media file right away. Note that only `bpm` is actually written to the media file, all the other attributes are flex attributes and are only stored in the database.

  The `dry-run` option shows what would be done without actually doing it.

  **NOTE**: Please note that the `auto` option is not yet implemented. For now you will have to call the xtractor plugin manually.



  Invoke the plugin as:

      $ beet xtractor [options] [QUERY...]

  For a more verbose reporting use the `-v` flag on `beet`:

      $ beet -v xtractor [options] [QUERY...]

  The plugin has also got a shorthand `xt` so you can also invoke it like this:

      $ beet xt [options] [QUERY...]

  The following command line options are available:

  **--dry-run [-d]**: Only show what would be done - displays the extracted values but does not store them in the library.

  **--write [-w]**: Write the values (bpm only) to the media files.

  **--threads=THREADS [-t THREADS]**: The number of concurrently running executions.

  **--force [-f]**: Force the analysis of all items (skip attribute checks).

  **--count-only [-c]**: Show the number of items to be processed and exit. Extraction will not be executed.

  **--quiet [-q]**: Run without any output.

  **--version [-v]**: Display the version number of the plugin. Useful when you need to report some issue and you have to state the version of the plugin you are using.

  These command line options will override those specified in the configuration file.



  - If something is not working as expected please use the Issue tracker.
  - If the documentation is not clear please use the Issue tracker.
  - If you have a feature request please use the Issue tracker.
  - In any other situation please use the Issue tracker.



  - [beets-goingrunning](https://github.com/adamjakab/BeetsPluginGoingRunning)
  - [beets-xtractor](https://github.com/adamjakab/BeetsPluginXtractor)
  - [beets-yearfixer](https://github.com/adamjakab/BeetsPluginYearFixer)
  - [beets-autofix](https://github.com/adamjakab/BeetsPluginAutofix)
  - [beets-describe](https://github.com/adamjakab/BeetsPluginDescribe)
  - [beets-bpmanalyser](https://github.com/adamjakab/BeetsPluginBpmAnalyser)
  - [beets-template](https://github.com/adamjakab/BeetsPluginTemplate)



  Essentia is an open-source C++ library with Python bindings for audio analysis and audio-based music information retrieval. It is released under the Affero GPLv3 license and is also available under proprietary license upon request. This plugin is just a mere wrapper around this library. [Learn more about the Essentia project](http://essentia.upf.edu)



  - [Essentia](https://essentia.upf.edu/index.html)
  - [SVM Models](https://essentia.upf.edu/svm_models/)
  - [Essentia Licensing](https://essentia.upf.edu/licensing_information.html)
  - [MTG Github - Music Technology Group](https://github.com/MTG)
  - [Acousticbrainz Downloads](https://acousticbrainz.org/download)



  Enjoy!


pkgId: b5c335fbe033671fcd9269c05eeed1f20d99043bc926dc8bb2575b839e6a01d9
name: python-beeware
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A metapackage to install the full BeeWare suite of tools.
url: http://beeware.org/
rpm_license: New BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beeware-0.3.0-1.src.rpm
checksum_type: sha256
description:
  BeeWare is a collection of tools and libraries for building and distributing
  native applications in Python.
  For an introduction to the full BeeWare suite, we recommend running the
  `BeeWare Tutorial`_.


pkgId: 79d136a2e0b13bcbe36483e813e878076ce8c909b3e68718fba9deb5310bfe86
name: python-befordata
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: BeFoR-Data structure for handling behavioural force data
url: https://pypi.org/project/befordata/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-befordata-0.2.3-1.src.rpm
checksum_type: sha256
description:
  Data structure for handling behavioural force data

  [![GitHub license](https://img.shields.io/github/license/lindemann09/befordata)](https://github.com/lindemann09/befordata/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/befordata?style=flat)](https://pypi.org/project/befordata/)

  see  https://lindemann09.github.io/befordata/




  ```
  pip install befordata
  ```


  [BeForData Demo](https://lindemann09.github.io/befordata/demo_befordata.html)




  A [Julia implementation of BeFordata](https://github.com/lindemann09/BeForData.jl) is under development.

  (c) Oliver Lindemann


pkgId: d6a2f71ce3d5fd6e949e3c97ca05172c3daf8ce926d9e21d4c78912df6faade6
name: python-behatrix
arch: src
version: 0.11
epoch: 0
release: 1
summary: Behatrix - Behavioral Sequences Analysis with permutation test
url: http://www.boris.unito.it/behatrix
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behatrix-0.11-1.src.rpm
checksum_type: sha256
description:
  ![Behatrix logo](images/logo_behatrix.png)
  Researchers who observe and study behavior often collect data in the
  form of sequences of behavioral displays that they need to analyze and
  visualize to test hypotheses. **Behatrix** is free and open-source
  software available for GNU/Linux, Windows and Mac OS X.
  By using a flexible and efficient approach, **Behatrix** allows
  analyzing large sets of behavioral sequences and can organize data into
  contingency tables. The program can also perform permutations test and
  autonomously generate the code for a flow diagram representing the
  transitions between behaviors.
  **Behatrix** can read data exported from [**BORIS**](http://www.boris.unito.it)
  (see [Events as behavioral sequences](http://www.boris.unito.it/user_guide/export_events/#export-events-as-behavioral-sequences))
  and can also be used as a standalone program.

  -   Behavioral sequences statistics (with n-gram size option)
  -   Observed transitions matrix (with n-gram size option)
  -   Generation of the [Graphviz](https://graphviz.org/) script from observed transitions
  -   Flow diagram generation  (with n-gram size option)
  -   Random permutations test (with multiprocessing module) with generation of the transitions significativity matrix
  -   Flow diagram generation with transitions significativity
  -   Behavioral sequences distances: **Levenshtein distances** and **Needleman-Wunsch identities**
  The flow diagram generation requires the the [Graphviz](https://graphviz.org/) open source graph visualization software.

  [Usage of Behatrix](https://github.com/olivierfriard/behatrix/blob/master/user_guide.md)

  [Latest release on GitHub repository](https://github.com/olivierfriard/behatrix/releases/latest)
  [Issues and feature request](https://github.com/olivierfriard/behatrix/issues) on GitHub

  Please consult the [change log page](https://github.com/olivierfriard/behatrix/wiki/revision-history).

rpm_license:
[cell repeats an earlier one in this file: 34478 characters]


pkgId: 0ef26c9921f4c234f29140997b9b7854282ec884fbbc3fdce1cde3065d8a3038
name: python-behave-cucumber-formatter
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Cucumber JSON formatter for pipeline tests
url: https://github.com/BluThaitanium/Cucumber-Behave-Package
rpm_license: THE_UNLICENSED
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-cucumber-formatter-1.0.1-1.src.rpm
checksum_type: sha256
description:
  Or with an `.ini` file:
  ```ini

  [behave.formatters]
  cucumber = behave_cucumber_formatter:PrettyCucumberJSONFormatter
  ```
  and use the shorthand:
  ```bash
  behave --format cucumber
  ```

  ```bash
  pip uninstall behave-cucumber-formatter
  ```


pkgId: 66a0b1f698c112f503a1902650a1327cf02c309ca0a5c941630ed8583a37fa1c
name: python-behave-django
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: Behave BDD integration for Django
url: https://pypi.org/project/behave-django/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-django-1.5.0-1.src.rpm
checksum_type: sha256
description:
  |check-status| |test-status| |python-support| |license| |docs-status| |gitter|
  Behave BDD integration for Django

rpm_license:
  The MIT License (MIT)  Copyright (c) 2015 Mitchel Cabuloy  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 20e2a12d7379eb69939cf08bc23e6cbcf692294d24f9fb68280d810adf47ed43
name: python-behave-django-steps
arch: src
version: 0.7.15
epoch: 0
release: 1
summary: Boilerplate steps for testing Django with Behave
url: https://github.com/BillSchumacher/behave-django-steps
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-django-steps-0.7.15-1.src.rpm
checksum_type: sha256
description:
  [![Coverage Status](https://coveralls.io/repos/github/BillSchumacher/behave-django-steps/badge.svg?branch=main)](https://coveralls.io/github/BillSchumacher/behave-django-steps?branch=main)
  Reduce boilerplate in your behave steps for Django.


pkgId: 19588c1a44d55357daa506a37e67294dfa7fcfc345b9bc4d2122249b533cacd8
name: python-behave-html-formatter
arch: src
version: 0.9.10
epoch: 0
release: 1
summary: HTML formatter for Behave
url: https://github.com/behave-contrib/behave-html-formatter
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-html-formatter-0.9.10-1.src.rpm
checksum_type: sha256
description:
  To use it with behave create `behave.ini` file in project folder (or in home) with
  following content:

  ```ini


  [behave.formatters]
  html = behave_html_formatter:HTMLFormatter
  ```

  and then use it by running behave with `-f`/`--format` parameter, e.g.

  ```console
  behave -f help
  behave -f html
  behave -f html -o behave-report.html
  ```

  You can find information about behave and user-defined formatters in the
  [behave docs](https://behave.readthedocs.io/en/latest/formatters.html).



  You want to help with improving this software? Please create an issue in
  our open bug tracker, or open a pull request directly.

  We use [tox](https://pypi.org/project/tox/) for running linting and tests,
  e.g.

  ```console
  tox
  tox -l
  tox -e flake8,behave
  ```

  For code formatting we use [black](https://pypi.org/project/black/), which
  you can run using our Tox setup, e.g.

  ```console
  tox -e black
  ```

  If you need to change CSS or JavaScript code: First edit the regular files,
  then generate the minified versions like so:

  ```console
  tox -e minify
  ```


pkgId: 693681f945d281272a6ea87c8a7466e1741c881f4d3ccc0f30ad79c85f70a178
name: python-behave-html-pretty-formatter
arch: src
version: 1.12
epoch: 0
release: 1
summary: Pretty HTML Formatter for Behave
url: https://pypi.org/project/behave-html-pretty-formatter/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-html-pretty-formatter-1.12-1.src.rpm
checksum_type: sha256
description:
  - Inspired by [jest-html-reporter](https://github.com/Hargne/jest-html-reporter)
  - Using project [dominate](https://github.com/Knio/dominate) to generate the page



    - https://fedoramagazine.org/automation-through-accessibility/
    - Full technical solution of our team's (Red Hat DesktopQE) automation stack https://modehnal.github.io/




  ```shell
  python3 -m pip install behave-html-pretty-formatter
  ```

  [![PyPI version](https://img.shields.io/pypi/v/behave-html-pretty-formatter.svg?style=flat)](https://pypi.org/project/behave-html-pretty-formatter/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/behave-html-pretty-formatter.svg?style=flat)](https://pypi.org/project/behave-html-pretty-formatter/)



  To use it with Behave create a `behave.ini` file in your project folder
  (or in home) with the following content:

  ```ini


  [behave.formatters]
  html-pretty = behave_html_pretty_formatter:PrettyHTMLFormatter



  [behave.userdata]
  behave.formatter.html-pretty.title_string = Test Suite Reporter

  behave.formatter.html-pretty.pseudo_steps = false

  behave.formatter.html-pretty.pretty_output = true

  behave.formatter.html-pretty.date_format = %d-%m-%Y %H:%M:%S

  behave.formatter.html-pretty.show_summary = false

  behave.formatter.html-pretty.show_unexecuted_steps = true





  behave.formatter.html-pretty.collapse = auto


  behave.formatter.html-pretty.show_retry_attempts = true




  behave.formatter.html-pretty.global_summary = auto

  behave.additional-info.tester = super_worker

  behave.additional-info.location = super_awesome_lab
  ```

  Alternatively, with behave >= v1.2.7.dev3, you can put the same configuration in
  `pyproject.toml`, like so:

  ```toml
  [tool.behave.formatters]
  "html-pretty" = "behave_html_pretty_formatter:PrettyHTMLFormatter"



  [tool.behave.userdata]
  "behave.formatter.html-pretty.title_string" = "Test Suite Reporter"
  "behave.formatter.html-pretty.pseudo_steps" = false
  "behave.formatter.html-pretty.pretty_output" = true
  "behave.formatter.html-pretty.date_format" = "%d-%m-%Y %H:%M:%S"
  "behave.formatter.html-pretty.show_summary" = false
  "behave.formatter.html-pretty.collapse" = "auto"
  "behave.formatter.html-pretty.show_unexecuted_steps" = true
  "behave.formatter.html-pretty.global_summary" = "auto"
  "behave.additional-info.tester" = "super_worker"
  "behave.additional-info.location" = "super_awesome_lab"

  ```

  Then use the formatter by running Behave with the `-f`/`--format` option, e.g.

  ```console
  behave -f help
  behave -f html-pretty
  behave -f html-pretty -o behave-report.html
  ```

  You can find information about behave and user-defined formatters in the
  [behave docs](https://behave.readthedocs.io/en/latest/formatters/).



  - [Default Static Example](#pretty-html-formatter):
  - [High contrast Static Example](#pretty-html-formatter-high-contrast):
    - Colours adjusted.
    - Extra information is added before every decorator about the status of the step.
    - Text is bigger.

  You can switch between the different contrasts with the toggle button.




  Stylesheet follows the browser dark theme, so it reverts background to dark and
  adjusts colors to darker shade.




  - [Pretty HTML Formatter With Summary Expanded and Collapsed Steps](#pretty-html-formatter-with-summary-expanded-and-collapsed-steps):
  - [Pretty HTML Formatter High contrast With Summary Expanded and Collapsed Steps](#pretty-html-formatter-high-contrast-with-summary-expanded-and-collapsed-steps):

  To change the setting use the .ini file.
  ```summary
  behave.formatter.html-pretty.show_summary = true
  ```





  Take a look at the [Common MIME types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types), few of them are useful for us.



  ```python
  data_base64 = base64.b64encode(open("/path/to/image", "rb").read())
  data_encoded = data_base64.decode("utf-8").replace("\n", "")
  ```



  ```python

  "data:<mime_type>;<encoding>,<data_encoded>"

  f"data:image/png;base64,{data_encoded}"
  ```





  ```python
  for formatter in context._runner.formatters:
      if formatter.name == "html-pretty":
          context.formatter = formatter
  ```



  ```python
  icon_data = f"data:image/svg+xml;base64,{data_encoded}"
  context.formatter.set_icon(icon=icon_data)
  ```

  Example use case - an indicator if the test is running under X11 or Wayland:

  ![Examples](design/set_icon_examples.png)



  ```python
  context.formatter.set_title(title="Test Suite Reporter")
  ```

   - This is configurable also from the behave.ini file `behave.formatter.html-pretty.title_string = Test Suite Reporter`




  ```python
  context.formatter.add_html_head_element('<script src="https://example.js.org/my_js_lib.min.js"></script>')
  ```

  Example use case - import custom JS library (e.g. plotly.js).




  Used as an information panel to describe or provide information about the page contents.
  You will need to define your own step where you will set flag for commentary step.

  ```python
  @step('Commentary')
  def commentary_step(context):
      
      scenario = context.formatter.current_scenario
      step = scenario.current_step
      
      step.commentary_override = True
  ```

  Feature file example usage:

  ```gherkin
    @commentary
    Scenario: Example of commentary usage.
      * Start application "zenity" via command "zenity --about"
      * Commentary
        """
        This field is generated from decorator 'Commentary'
        Where you insert text and override step to not print its decorator.
        The text will get printed and will be seen, as you can see, haha.
        """
      * Left click "About" "radio button"

  ```

  Result can be seen in the image examples.






  This is to create shortcut `context.embed()`. There are multiple ways to achieve this.

  If you have Basic setup, you can simply define it like this:

  ```python
  context.embed = context.formatter.embed
  ```

  If you don't have Basic setup, the proper way is the following code

  ```python
  for formatter in context._runner.formatters:
      if formatter.name == "html-pretty":
          context.embed = formatter.embed
  ```

  You can also define custom embed function which does something else when behave is called without `html-pretty` formatter (i.e. for debugging purposes), and overwrite it with `formatter.embed` function only if the formatter is present.

  ```python
  def _embed(mime_type, data, caption):
      if "text" in mime_type:
          
          print(f"{caption}: {data}")

  context.embed = _embed


  if hasattr(context, "formatter"):
      context.embed = context.formatter.embed
  ```



  ```python
  context.embed(mime_type="image/png", data="/path/to/image.png", caption="Screenshot")
  ```



  ```python
  context.embed(mime_type="video/webm", data="/path/to/video.webm", caption="Video")
  ```



  ![Pretty HTML Formatter](design/image_and_video_examples.gif)




  ```python3

  context.formatter.add_html_head_element('<script src="https://cdn.plot.ly/plotly-2.35.2.min.js" charset="utf-8"></script>')


  graph_js = \
  """
  TESTER = document.getElementById('tester');
  TESTER.innerHTML = '';
  Plotly.newPlot( TESTER, [{
  x: [1, 2, 3, 4, 5],
  y: [1, 2, 4, 8, 16] }], {
  margin: { t: 0 } } );
  """


  context.formatter.embed(
      data=f'<div id="tester" style="width:600px;height:250px;"></div><script>{graph_js}</script>',
      mime_type="text/html",
      caption="Example Graph",
      compress=False,
  )


  graph_js_min = graph_js.replace("\n", "").replace("tester", "compressed_tester").strip()
  context.formatter.embed(
      data=f'<div id="compressed_tester" style="width:600px;height:250px;" onclick="{graph_js_min}">Click me to load the graph.</div>',
      mime_type="text/html",
      caption="Example Compressed Graph",
      compress=True,
  )
  ```

  Note: with `compress=True` the decompression is done by javascript, and decompressed script is not executed by browser (additional `onclick` callback is required).

  ![Plotly Example](design/plotly_example.gif)




  These are examples we use on daily basis, we can define more if required.

  ```python
  mime_type="video/webm", data="/path/to/video.webm" or data="<base64_encoded_video>"
  mime_type="image/png", data="/path/to/image.png" or data="<base64_encoded_image>"
  mime_type="text/plain", data="<string>"
  mime_type="text/html", data="<string>"  # data string is pasted as raw HTML (not escaped)
  mime_type="text/markdown", data="<string>"  # data string is converted using markdown pip module
  mime_type="link", data="list(<link>, <label>)"
  ```

  You can simply set `data=data_encoded` generated as described in [Encoding to base64](#encoding-to-base64) section and the formatter will generate the proper [Format](#format-in-which-the-data-is-inserted-to-the-html) based on MIME type, or you can just use the `data="/path/to/file"` and formatter will attempt to convert it.

  Function `embed()` returns object, which can be saved and modified later via `set_data()` and `set_fail_only()` methods. This is if you want to embed some data which are still being processes (output of a background process started in a step, etc.).



  If the testsuite uses `before_scenario()` and `after_scenario()` and you would like to see them as steps in HTML report (for example to have embeds separated from the standard steps), configuration switch in behave.ini file `behave.formatter.html-pretty.pseudo_steps = true` will do the trick, together with calling `context.html_formatter.before_scenario_finish(status)` at the end of `before_scenario()` (analogously for `after_scenario()`). The status is one of `"passed", "failed", "skipped"`. Function will set color class of the pseudo step and also record pseudo step duration.

  ```python


  def before_scenario(context, scenario):
    ...
    
    if error_found:
      context.embed("text", str(error_found), "Error Message")
      context.html_formatter.before_scenario_finish("failed")
      raise error_found
    else:
      context.html_formatter.before_scenario_finish("passed")

  def after_scenario(context, scenario):
    ...
    if error_found:
      context.embed("text", str(error_found), "Error Message")
      context.html_formatter.after_scenario_finish("failed")
      raise error_found
    else:
      context.html_formatter.after_scenario_finish("passed")
  ```



  You want to help with improving this software? Please create an issue in our open bug tracker, or open a pull request directly.

  We use [tox](https://pypi.org/project/tox/) for running linting and tests, e.g.

  ```console
  tox
  tox -l
  tox -e flake8
  ```

  For code formatting we use [black](https://pypi.org/project/black/), which you can run using our Tox setup, e.g.

  ```console
  tox -e black
  ```

  If you need to change CSS or JavaScript code: First edit the regular files, then generate the minified versions like so:

  ```console
  tox -e minify
  ```






  ![Pretty HTML Formatter](design/full_page_example.png)



  ![Pretty HTML Formatter Summary High Contrast](design/full_page_high_contrast_example.png)



  ![Pretty HTML Formatter](design/summary_collapsed_example.png)



  ![Pretty HTML Formatter Summary High Contrast](design/summary_collapsed_high_contrast_example.png)

rpm_license:
[cell repeats an earlier one in this file: 34486 characters]


pkgId: 0d7fc407bd7af252cd6e1a16c57cae2003cd5dc929297ef175ee13c91b80cf2a
name: python-behave-html-pretty-formatter
arch: src
version: 1.12.2
epoch: 0
release: 1
summary: Pretty HTML Formatter for Behave
url: https://pypi.org/project/behave-html-pretty-formatter/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-html-pretty-formatter-1.12.2-1.src.rpm
checksum_type: sha256
description:
  - Inspired by [jest-html-reporter](https://github.com/Hargne/jest-html-reporter)
  - Using project [dominate](https://github.com/Knio/dominate) to generate the page



    - https://fedoramagazine.org/automation-through-accessibility/
    - Full technical solution of our team's (Red Hat DesktopQE) automation stack https://modehnal.github.io/




  ```shell
  python3 -m pip install behave-html-pretty-formatter
  ```

  [![PyPI version](https://img.shields.io/pypi/v/behave-html-pretty-formatter.svg?style=flat)](https://pypi.org/project/behave-html-pretty-formatter/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/behave-html-pretty-formatter.svg?style=flat)](https://pypi.org/project/behave-html-pretty-formatter/)



  To use it with Behave create a `behave.ini` file in your project folder
  (or in home) with the following content:

  ```ini


  [behave.formatters]
  html-pretty = behave_html_pretty_formatter:PrettyHTMLFormatter



  [behave.userdata]
  behave.formatter.html-pretty.title_string = Test Suite Reporter

  behave.formatter.html-pretty.pseudo_steps = false

  behave.formatter.html-pretty.pretty_output = true

  behave.formatter.html-pretty.date_format = %d-%m-%Y %H:%M:%S

  behave.formatter.html-pretty.show_summary = false

  behave.formatter.html-pretty.show_unexecuted_steps = true





  behave.formatter.html-pretty.collapse = auto


  behave.formatter.html-pretty.show_retry_attempts = true




  behave.formatter.html-pretty.global_summary = auto

  behave.additional-info.tester = super_worker

  behave.additional-info.location = super_awesome_lab
  ```

  Alternatively, with behave >= v1.2.7.dev3, you can put the same configuration in
  `pyproject.toml`, like so:

  ```toml
  [tool.behave.formatters]
  "html-pretty" = "behave_html_pretty_formatter:PrettyHTMLFormatter"



  [tool.behave.userdata]
  "behave.formatter.html-pretty.title_string" = "Test Suite Reporter"
  "behave.formatter.html-pretty.pseudo_steps" = false
  "behave.formatter.html-pretty.pretty_output" = true
  "behave.formatter.html-pretty.date_format" = "%d-%m-%Y %H:%M:%S"
  "behave.formatter.html-pretty.show_summary" = false
  "behave.formatter.html-pretty.collapse" = "auto"
  "behave.formatter.html-pretty.show_unexecuted_steps" = true
  "behave.formatter.html-pretty.global_summary" = "auto"
  "behave.additional-info.tester" = "super_worker"
  "behave.additional-info.location" = "super_awesome_lab"

  ```

  Then use the formatter by running Behave with the `-f`/`--format` option, e.g.

  ```console
  behave -f help
  behave -f html-pretty
  behave -f html-pretty -o behave-report.html
  ```

  You can find information about behave and user-defined formatters in the
  [behave docs](https://behave.readthedocs.io/en/latest/formatters/).



  - [Default Static Example](#pretty-html-formatter):
  - [High contrast Static Example](#pretty-html-formatter-high-contrast):
    - Colours adjusted.
    - Extra information is added before every decorator about the status of the step.
    - Text is bigger.

  You can switch between the different contrasts with the toggle button.




  Stylesheet follows the browser dark theme, so it reverts background to dark and
  adjusts colors to darker shade.




  - [Pretty HTML Formatter With Summary Expanded and Collapsed Steps](#pretty-html-formatter-with-summary-expanded-and-collapsed-steps):
  - [Pretty HTML Formatter High contrast With Summary Expanded and Collapsed Steps](#pretty-html-formatter-high-contrast-with-summary-expanded-and-collapsed-steps):

  To change the setting use the .ini file.
  ```summary
  behave.formatter.html-pretty.show_summary = true
  ```





  Take a look at the [Common MIME types](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types), few of them are useful for us.



  ```python
  data_base64 = base64.b64encode(open("/path/to/image", "rb").read())
  data_encoded = data_base64.decode("utf-8").replace("\n", "")
  ```



  ```python

  "data:<mime_type>;<encoding>,<data_encoded>"

  f"data:image/png;base64,{data_encoded}"
  ```





  ```python
  for formatter in context._runner.formatters:
      if formatter.name == "html-pretty":
          context.formatter = formatter
  ```



  ```python
  icon_data = f"data:image/svg+xml;base64,{data_encoded}"
  context.formatter.set_icon(icon=icon_data)
  ```

  Example use case - an indicator if the test is running under X11 or Wayland:

  ![Examples](design/set_icon_examples.png)



  ```python
  context.formatter.set_title(title="Test Suite Reporter")
  ```

   - This is configurable also from the behave.ini file `behave.formatter.html-pretty.title_string = Test Suite Reporter`




  ```python
  context.formatter.add_html_head_element('<script src="https://example.js.org/my_js_lib.min.js"></script>')
  ```

  Example use case - import custom JS library (e.g. plotly.js).




  Used as an information panel to describe or provide information about the page contents.
  You will need to define your own step where you will set flag for commentary step.

  ```python
  @step('Commentary')
  def commentary_step(context):
      
      scenario = context.formatter.current_scenario
      step = scenario.current_step
      
      step.commentary_override = True
  ```

  Feature file example usage:

  ```gherkin
    @commentary
    Scenario: Example of commentary usage.
      * Start application "zenity" via command "zenity --about"
      * Commentary
        """
        This field is generated from decorator 'Commentary'
        Where you insert text and override step to not print its decorator.
        The text will get printed and will be seen, as you can see, haha.
        """
      * Left click "About" "radio button"

  ```

  Result can be seen in the image examples.






  This is to create shortcut `context.embed()`. There are multiple ways to achieve this.

  If you have Basic setup, you can simply define it like this:

  ```python
  context.embed = context.formatter.embed
  ```

  If you don't have Basic setup, the proper way is the following code

  ```python
  for formatter in context._runner.formatters:
      if formatter.name == "html-pretty":
          context.embed = formatter.embed
  ```

  You can also define custom embed function which does something else when behave is called without `html-pretty` formatter (i.e. for debugging purposes), and overwrite it with `formatter.embed` function only if the formatter is present.

  ```python
  def _embed(mime_type, data, caption):
      if "text" in mime_type:
          
          print(f"{caption}: {data}")

  context.embed = _embed


  if hasattr(context, "formatter"):
      context.embed = context.formatter.embed
  ```



  ```python
  context.embed(mime_type="image/png", data="/path/to/image.png", caption="Screenshot")
  ```



  ```python
  context.embed(mime_type="video/webm", data="/path/to/video.webm", caption="Video")
  ```



  ![Pretty HTML Formatter](design/image_and_video_examples.gif)




  ```python3

  context.formatter.add_html_head_element('<script src="https://cdn.plot.ly/plotly-2.35.2.min.js" charset="utf-8"></script>')


  graph_js = \
  """
  TESTER = document.getElementById('tester');
  TESTER.innerHTML = '';
  Plotly.newPlot( TESTER, [{
  x: [1, 2, 3, 4, 5],
  y: [1, 2, 4, 8, 16] }], {
  margin: { t: 0 } } );
  """


  context.formatter.embed(
      data=f'<div id="tester" style="width:600px;height:250px;"></div><script>{graph_js}</script>',
      mime_type="text/html",
      caption="Example Graph",
      compress=False,
  )


  graph_js_min = graph_js.replace("\n", "").replace("tester", "compressed_tester").strip()
  context.formatter.embed(
      data=f'<div id="compressed_tester" style="width:600px;height:250px;" onclick="{graph_js_min}">Click me to load the graph.</div>',
      mime_type="text/html",
      caption="Example Compressed Graph",
      compress=True,
  )
  ```

  Note: with `compress=True` the decompression is done by javascript, and decompressed script is not executed by browser (additional `onclick` callback is required).

  ![Plotly Example](design/plotly_example.gif)




  These are examples we use on daily basis, we can define more if required.

  ```python
  mime_type="video/webm", data="/path/to/video.webm" or data="<base64_encoded_video>"
  mime_type="image/png", data="/path/to/image.png" or data="<base64_encoded_image>"
  mime_type="text/plain", data="<string>"
  mime_type="text/html", data="<string>"  # data string is pasted as raw HTML (not escaped)
  mime_type="text/markdown", data="<string>"  # data string is converted using markdown pip module
  mime_type="link", data="list(<link>, <label>)"
  ```

  You can simply set `data=data_encoded` generated as described in [Encoding to base64](#encoding-to-base64) section and the formatter will generate the proper [Format](#format-in-which-the-data-is-inserted-to-the-html) based on MIME type, or you can just use the `data="/path/to/file"` and formatter will attempt to convert it.

  Function `embed()` returns object, which can be saved and modified later via `set_data()` and `set_fail_only()` methods. This is if you want to embed some data which are still being processes (output of a background process started in a step, etc.).



  If the testsuite uses `before_scenario()` and `after_scenario()` and you would like to see them as steps in HTML report (for example to have embeds separated from the standard steps), configuration switch in behave.ini file `behave.formatter.html-pretty.pseudo_steps = true` will do the trick, together with calling `context.html_formatter.before_scenario_finish(status)` at the end of `before_scenario()` (analogously for `after_scenario()`). The status is one of `"passed", "failed", "skipped"`. Function will set color class of the pseudo step and also record pseudo step duration.

  ```python


  def before_scenario(context, scenario):
      ...
      
      if error_found:
          context.embed("text", str(error_found), "Error Message")
          context.html_formatter.before_scenario_finish("failed")
          raise error_found
      else:
          context.html_formatter.before_scenario_finish("passed")

  def after_scenario(context, scenario):
      ...
      if error_found:
          context.embed("text", str(error_found), "Error Message")
          context.html_formatter.after_scenario_finish("failed")
          raise error_found
      else:
          context.html_formatter.after_scenario_finish("passed")
  ```



  You want to help with improving this software? Please create an issue in our open bug tracker, or open a pull request directly.

  We use [tox](https://pypi.org/project/tox/) for running linting and tests, e.g.

  ```console
  tox
  tox -l
  tox -e flake8
  ```

  For code formatting we use [black](https://pypi.org/project/black/), which you can run using our Tox setup, e.g.

  ```console
  tox -e black
  ```

  If you need to change CSS or JavaScript code: First edit the regular files, then generate the minified versions like so:

  ```console
  tox -e minify
  ```






  ![Pretty HTML Formatter](design/full_page_example.png)



  ![Pretty HTML Formatter Summary High Contrast](design/full_page_high_contrast_example.png)



  ![Pretty HTML Formatter](design/summary_collapsed_example.png)



  ![Pretty HTML Formatter Summary High Contrast](design/summary_collapsed_high_contrast_example.png)

rpm_license:
[cell repeats an earlier one in this file: 34486 characters]


pkgId: 42a50cdae30dc72c33e81dd134179371901bc8ec59f0e36d3b8a6506bd66df93
name: python-behave-pandas
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Provides helper functions to help converting behave tables into pandas dataframes and vice versa.
url: https://github.com/clembou/behave-pandas
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-pandas-0.5.0-1.src.rpm
checksum_type: sha256
description:
  Utility package for the [Behave](https://github.com/behave/behave) BDD testing framework, to make converting gherkin tables
  to and from [pandas](https://github.com/pandas-dev/pandas) data frames a breeze.


  ![Travis CI badge](https://travis-ci.org/clembou/behave-pandas.svg?branch=master)



  ```bash
  pip install behave-pandas
  ```



  * Easily convert a Gherkin table into a pandas data frame with explicit dtype information
  * Easily convert a pandas data frame into a behave table that can be parsed by behave-pandas
  * Support converting data frames with multiple index levels either on columns or rows
  * Handle missing data for dtypes that support it.



  [See the changelog here.](CHANGELOG.md)



  The behave-pandas api is extremely simple, and consists in two functions:

  ```python
  from behave_pandas import table_to_dataframe, dataframe_to_table
  ```



  ```gherkin
  Feature: Table printer

    as a tester
    I want to be able to create gherkin tables from existing data frames

    Scenario: simple index
      Given a gherkin table as input
        | str       | float     | str                 |
        | index_col | float_col | str_col             |
        | egg       | 3.0       | silly walks         |
        | spam      | 4.1       | spanish inquisition |
        | bacon     | 5.2       | dead parrot         |
      When converted to a data frame using 1 row as column names and 1 column as index
      And printed using data_frame_to_table
      Then it prints a valid string copy pasteable into gherkin files
      """
      | object    | float64   | object              |
      | index_col | float_col | str_col             |
      | egg       | 3.0       | silly walks         |
      | spam      | 4.1       | spanish inquisition |
      | bacon     | 5.2       | dead parrot         |
      """
  ```

  Associated steps:

  ```python
  from behave import *
  from behave_pandas import table_to_dataframe, dataframe_to_table

  use_step_matcher("parse")

  @given("a gherkin table as input")
  def step_impl(context,):
      context.input = context.table

  @when('converted to a data frame using {column_levels:d} row as column names and {index_levels:d} column as index')
  def step_impl(context, column_levels, index_levels):
      context.parsed = table_to_dataframe(context.input, column_levels=column_levels, index_levels=index_levels)


  @then("it prints a valid string copy pasteable into gherkin files")
  def step_impl(context):
      assert context.result == context.text


  @step("printed using data_frame_to_table")
  def step_impl(context):
      context.result = dataframe_to_table(context.parsed)
  ```

  Parsed dataframe:

  ```
  >>> context.parsed
             float_col              str_col
  index_col
  egg              3.0          silly walks
  spam             4.1  spanish inquisition
  bacon            5.2          dead parrot

  >>> context.parsed.info()
  <class 'pandas.core.frame.DataFrame'>
  Index: 3 entries, egg to bacon
  Data columns (total 2 columns):
  float_col    3 non-null float64
  str_col      3 non-null object
  dtypes: float64(1), object(1)
  memory usage: 72.0+ bytes
  ```


pkgId: 798b7df392c18ed65d43947a3ccb31c9dd85df6d770a0c6126b866869e92c913
name: python-behave-plain-color-formatter
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Formatter for behave that uses color but not fancy terminal repositioning
url: https://github.com/msabramo/behave-plain-color-formatter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-plain-color-formatter-0.0.2-1.src.rpm
checksum_type: sha256
description:
  Formatter for [behave][] that uses color but not fancy terminal repositioning

  ![screenshot](https://raw.githubusercontent.com/msabramo/behave-plain-color-formatter/master/screenshot.png)


  ```bash
  pip install behave-plain-color-formatter
  ````


  You can specify the formatter directly in the command line using the -f argument:
  ```bash
  behave -f behave_plain_color_formatter:PlainColorFormatter
  ```
  or
  ```bash
  behave --format behave_plain_color_formatter:PlainColorFormatter
  ```

  You can also register the formatter to be available through a simple name:
  ```ini

  [behave.formatters]
  plain.color = behave_plain_color_formatter:PlainColorFormatter
  ```
  and the use it like:
  ```bash
  behave -f plain.color
  ```


  [behave]: https://github.com/behave/behave


pkgId: 8d6435258565d408759cc905b2e7c41197a5f7c26920a788075a1ce1bcf236d6
name: python-behave-testrail-reporter
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Behave library to integrate with Testrail API
url: https://github.com/virtualstock/behave-testrail-reporter/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-testrail-reporter-0.5.1-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/Virtualstock/behave-testrail-reporter.svg?style=svg)](https://circleci.com/gh/Virtualstock/behave-testrail-reporter)
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/7823c0c33c6a4e12917113bfdc8a135b)](https://www.codacy.com/app/Virtualstock/behave-testrail-reporter?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=Virtualstock/behave-testrail-reporter&amp;utm_campaign=Badge_Grade)
  [![Codacy Badge](https://api.codacy.com/project/badge/Coverage/7823c0c33c6a4e12917113bfdc8a135b)](https://www.codacy.com/app/Virtualstock/behave-testrail-reporter?utm_source=github.com&utm_medium=referral&utm_content=Virtualstock/behave-testrail-reporter&utm_campaign=Badge_Coverage)
  [![pullreminders](https://pullreminders.com/badge.svg)](https://pullreminders.com?ref=badge)

  This integration is used to add test results to TestRail automatically when Behave tests are executed.


  Example of the generated report:

  ```
  3 testrail test cases passed, 0 failed, 19 skipped, 2 untested
  Took 0m6.349s
  ```



  Can install it using pipenv

  ```
  $ pipenv install behave-testrail-reporter
  ```

  or using pip

  ```
  $ pip install behave-testrail-reporter
  ```



  Add `TestrailReporter` to behave reporters in your `/features/environment.py` by adding this code in `before_all()`

  ```python
  from behave_testrail_reporter import TestrailReporter

  def before_all(context):
      
      current_branch = os.environ.get('CIRCLE_BRANCH') # Change this to get the current build branch of your CI system
      testrail_reporter = TestrailReporter(current_branch)
      context.config.reporters.append(testrail_reporter)
  ```


  Create a `testrail.yml` config file in the root of your project


  Example structure:


  ```yaml
  base_url: https://your-domain.testrail.io
  projects:
    - name: 'Advanced tests on branch {branch}'
      id: 123
      suite_id: 456
      
      allowed_branch_pattern: '.*'
    - name: 'Smoke tests on branch {branch}'
      id: 1234
      suite_id: 789
      
      allowed_branch_pattern: '.*'
  ```

  Allow only **master** branch and **release1.111.1** to push test results to Testrail:
  ```yaml
  base_url: https://your-domain.testrail.io
  projects:
    - name: 'Full E2E tests on branch {branch}'
      id: 123
      suite_id: 456
      allowed_branch_pattern: '^(master|release\/\d+([\.\d]+)?)$'
  ```

  | yaml key               | Description                                                |
  | ---------------------- | ---------------------------------------------------------- |
  | name                   | Project name                                               |
  | id                     | Testrail project id                                        |
  | suite_id               | Testrail Suite id                                          |
  | allowed_branch_pattern | Regular expression to restrict when a test run is executed |

  **name** - You can use some project variables to create dynamic test run names

  | Variable     | Example                 | Result          |
  | ------------ | ----------------------- | --------------- |
  | {project_id} | 'Test run {project_id}' | Test run 123    |
  | {suite_id}   | 'Test run {suite_id}'   | Test run 456    |
  | {branch}     | 'Test run {branch}'     | Test run master |


  **Environment variables required**

  | Variable name       | Description                 |
  | ------------------- | --------------------------- |
  | TESTRAIL_KEY        | TestRail user password      |
  | TESTRAIL_USER       | TestRail user email address |





  To get test cases marked as success or fail on TestRail we have to add tags with TestRail test case ID
  on each scenario.

  Test case tag structure:

  `prefix` + `test case id`

  `@testrail-` + `C1104`

  See example below:

  ```gherkin
  Feature: Log in and out

      Background:
          Given I am logged out from Hub
          And I navigate to the home page

      @testrail-C1104
      @testrail-C45933
      Scenario: Admin can login
          When I enter the username admin
          And I enter the password admin
          And I click the Login button
          Then I see the admin's landing page
  ```

  Note: some scenarios can cover multiple TestRail cases, for that you just need to add multiple tags.





  ```
  pipenv install --dev
  ```



  Activate your virtual environment and then just run tox.
  ```
  tox
  ```



  If you need to publish a new version of this package you can use this command:

  ```
  python setup.py sdist bdist_wheel
  twine upload dist/*
  ```



  Licensed under `MIT license`. View [license](LICENSE).


pkgId: ae60d2c9cb13d0ddac4d74353914cb4fc092613f7aaae5d421425fa419f76a8e
name: python-behave-webdriver
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Selenium webdriver step library for behave BDD testing
url: https://github.com/spyoungtech/behave-webdriver/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-webdriver-0.3.1-1.src.rpm
checksum_type: sha256
description:
  behave-webdriver is a step library intended to allow users to easily write `selenium`_ webdriver tests with the
  behave BDD testing framework.
  Inspired by the `webdriverio/cucumber-boilerplate`_ project.
  |docs| |status| |version| |pyversions| |coverage|
  For more details, see the `behave-webdriver documentation`_


pkgId: fcc0954502c79381dd406e84b3055ead468c4e91d4b677c650d8508e161eb177
name: python-behave-xray
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Behave JIRA XRAY results uploader
url: https://github.com/fundakol/behave-xray
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave-xray-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPi](https://img.shields.io/pypi/v/behave-xray.png)](https://pypi.python.org/pypi/behave-xray)
  [![Build Status](https://github.com/fundakol/behave-xray/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/fundakol/behave-xray/actions?query=workflow?master)
  [![codecov](https://codecov.io/gh/fundakol/behave-xray/branch/master/graph/badge.svg?token=VV1DMT3605)](https://codecov.io/gh/fundakol/behave-xray)




  ```shell
  $ pip install -U behave-xray
  ```

  or from the source:

  ```shell
  $ python setup.py install
  ```


  Add JIRA tags to Gherkin scenario:

  ```gherkin

  @jira.test_plan('JIRA-3')
  Feature: showing off behave
      Feature's description

    @jira.testcase('JIRA-1')
    Scenario: run a simple test
       Given we have behave installed
        When we implement a test
        Then behave will test it for us!

    @jira.testcase('JIRA-2')
    Scenario Outline: Add two numbers in Calc
      Given Calculator is open
      When I add <a> and <b>
      Then result is <result>

    Examples: Sum
        | a | b  | result |
        | 3 | 4  | 7      |
        | 6 | 10 | 18     |
  ```

  This library also supports the feature files [exported from Xray Cucumber tests](https://docs.getxray.app/pages/viewpage.action?pageId=62267221):
  ```gherkin
  Feature: showing off behave
      Feature's description

    @TEST_JIRA-1
    Scenario: run a simple test
       Given we have behave installed
        When we implement a test
        Then behave will test it for us!

    @TEST_JIRA-2
    Scenario Outline: Add two numbers in Calc
      Given Calculator is open
      When I add <a> and <b>
      Then result is <result>

    Examples: Sum
        | a | b  | result |
        | 3 | 4  | 7      |
        | 6 | 10 | 18     |
  ```



  Set Jira server API base URL in system environments:

  ```shell
  $ export XRAY_API_BASE_URL=<jira URL>
  ```

  Set system environments for [basic authentication](https://developer.atlassian.com/server/jira/platform/basic-authentication/):

  ```shell
  $ export XRAY_API_USER=<jria username>
  $ export XRAY_API_PASSWORD=<user password>
  ```
  Set system environments for [Personal Access Tokens](https://confluence.atlassian.com/enterprise/using-personal-access-tokens-1026032365.html) authentication:
  ```shell
  $ export XRAY_TOKEN=<Xray token>
  ```

  Set system environments for Could server authentication with [Client ID and Client Secret](https://docs.getxray.app/display/XRAYCLOUD/Authentication+-+REST+v2):
  ```shell
  $ export XRAY_CLIENT_ID=<Xray client id>
  $ export XRAY_CLIENT_SECRET=<Xray client secret>
  ```



  Run tests against [Jira Xray Server+DC](https://docs.getxray.app/display/XRAY/REST+API):
  ```shell
  $ behave -f behave_xray:XrayFormatter
  ```

  Run tests against [Jira Xray Cloud](https://docs.getxray.app/display/XRAYCLOUD/REST+API) server:
  ```shell
  $ behave -f behave_xray:XrayCloudFormatter
  ```

  You can register formatter in `behave.ini`:
  ```ini

  [behave.formatters]
  xray = behave_xray:XrayCloudFormatter
  ```

  and use with shorter name:
  ```shell
  $ behave --f xray
  ```



  One can implement `scenario_xray_result` hook to update results for a scenario.

  ```python

  from behave.model import Status
  from behave_xray import hookimpl
  from behave_xray.evidence import text

  @hookimpl
  def scenario_xray_result(result, scenario):
      if scenario.status == Status.failed:
          result.evidences.append(text(data='This is scenario evidence', filename=f'{scenario.name}.txt'))
  ```



  Add summary to a report:

  ```shell
  $ behave -f behave_xray:XrayCloudFormatter -D xray.summary='Report generated by behave'
  ```
  or from `behave.ini` file:

  ```ini

  [behave.userdata]
  xray.summary = Report generated by behave
  ```

  Available options:

  * `xray.summary`
  * `xray.user`
  * `xray.version`
  * `xray.revision`


pkgId: 6456ba47088376a0f5a7892898cb338a4c71a672c0d4b1796b5fe38095f16bb7
name: python-behave2cucumber
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Behave to Cucumber json converter
url: https://github.com/behalf-oss/behave2cucumber
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave2cucumber-1.0.3-1.src.rpm
checksum_type: sha256
description:
  This project helps solving the incompatibilty of Behave's genereated json reports to tools using Cucumber json reports. Its done by reformatting the Behave json to Cucumber json.


pkgId: fd2063dbef6b8307545d404f2a47b275e94057047421ab6ed5d8f3c0ea1c15fd
name: python-behave2cucumber-lawnmowerlatte
arch: src
version: 1.0.4.2
epoch: 0
release: 1
summary: Behave to Cucumber json converter (lawnmowerlatte fork)
url: https://github.com/lawnmowerlatte/behave2cucumber
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behave2cucumber-lawnmowerlatte-1.0.4.2-1.src.rpm
checksum_type: sha256
description:
  This project helps solving the incompatibilty of Behave's genereated json reports to tools using Cucumber json reports. Its done by reformatting the Behave json to Cucumber json. This fork contains a fix by lawnmowerlatte which has not been pulled into the main repo.


pkgId: 3a26865d36809dfc6e397c31b7e3403bc8ed58beb3e655414580737f8abcd3e4
name: python-behavex
arch: src
version: 4.0.7
epoch: 0
release: 1
summary: Agile testing framework on top of Behave (BDD).
url: https://github.com/hrcorval/behavex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behavex-4.0.7-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/behavex)](https://pepy.tech/project/behavex)
  [![PyPI version](https://badge.fury.io/py/behavex.svg)](https://badge.fury.io/py/behavex)
  [![Python Versions](https://img.shields.io/pypi/pyversions/behavex.svg)](https://pypi.org/project/behavex/)
  [![Dependency Status](https://img.shields.io/librariesio/github/hrcorval/behavex)](https://libraries.io/github/hrcorval/behavex)
  [![License](https://img.shields.io/github/license/hrcorval/behavex.svg)](https://github.com/hrcorval/behavex/blob/main/LICENSE)
  [![Build Status](https://github.com/hrcorval/behavex/actions/workflows/python-package.yml/badge.svg)](https://github.com/hrcorval/behavex/actions)
  [![GitHub last commit](https://img.shields.io/github/last-commit/hrcorval/behavex.svg)](https://github.com/hrcorval/behavex/commits/main)




  - [Introduction](#introduction)
  - [Features](#features)
  - [Installation Instructions](#installation-instructions)
  - [Execution Instructions](#execution-instructions)
  - [Constraints](#constraints)
  - [Supported Behave Arguments](#supported-behave-arguments)
  - [Specific Arguments from BehaveX](#specific-arguments-from-behavex)
  - [Parallel Test Executions](#parallel-test-executions)
  - [Test Execution Reports](#test-execution-reports)
  - [Attaching Images and Evidence](#attaching-images-and-evidence)
  - [Test Logs and Metrics](#test-logs-and-metrics)
  - [Muting Test Scenarios](#muting-test-scenarios)
  - [Handling Failing Scenarios](#handling-failing-scenarios)
  - [Displaying Progress Bar in Console](#displaying-progress-bar-in-console)
  - [Show Your Support](#show-your-support)



  **BehaveX** is a BDD testing solution designed to enhance your Behave-based testing workflow by providing additional features and performance improvements. It's particularly beneficial in the following scenarios:

  - **Accelerating test execution**: Significantly reduce test run times through parallel execution by feature or scenario.
  - **Enhancing test reporting**: Generate comprehensive and visually appealing HTML and JSON reports for in-depth analysis and integration with other tools.
  - **Improving test visibility**: Provide detailed evidence, such as screenshots and logs, essential for understanding test failures and successes.
  - **Optimizing test automation**: Utilize features like test retries, test muting, and performance metrics for efficient test maintenance and analysis.
  - **Managing complex test suites**: Handle large test suites with advanced features for organization, execution, and reporting.



  BehaveX provides the following features:

  - **Parallel Test Executions**: Execute tests using multiple processes, either by feature or by scenario.
  - **Enhanced Reporting**: Generate friendly HTML and JSON reports that can be exported and integrated with third-party tools.
  - **Evidence Collection**: Include images/screenshots and additional evidence in the HTML report.
  - **Test Logs**: Automatically compile logs generated during test execution into individual log reports for each scenario.
  - **Test Muting**: Add the `@MUTE` tag to test scenarios to execute them without including them in JUnit reports.
  - **Execution Metrics**: Generate metrics in the HTML report for the executed test suite, including Automation Rate, Pass Rate, Steps execution counter and average execution time.
  - **Dry Runs**: Perform dry runs to see the full list of scenarios in the HTML report without executing the tests. It overrides the `-d` Behave argument.
  - **Auto-Retry for Failing Scenarios**: Use the `@AUTORETRY` tag to automatically re-execute failing scenarios. Also, you can re-run all failing scenarios using the **failing_scenarios.txt** file.

  ![Test Execution Report](https://github.com/hrcorval/behavex/blob/master/img/html_test_report.png?raw=true)
  ![Test Execution Report](https://github.com/hrcorval/behavex/blob/master/img/html_test_report_2.png?raw=true)
  ![Test Execution Report](https://github.com/hrcorval/behavex/blob/master/img/html_test_report_3.png?raw=true)



  To install BehaveX, execute the following command:

  ```bash
  pip install behavex
  ```



  Execute BehaveX in the same way as Behave from the command line, using the `behavex` command. Here are some examples:

  - **Run scenarios tagged as `TAG_1` but not `TAG_2`:**
    ```bash
    behavex -t=@TAG_1 -t=~@TAG_2
    ```

  - **Run scenarios tagged as `TAG_1` or `TAG_2`:**
    ```bash
    behavex -t=@TAG_1,@TAG_2
    ```

  - **Run scenarios tagged as `TAG_1` using 4 parallel processes:**
    ```bash
    behavex -t=@TAG_1 --parallel-processes=4 --parallel-scheme=scenario
    ```

  - **Run scenarios located at specific folders using 2 parallel processes:**
    ```bash
    behavex features/features_folder_1 features/features_folder_2 --parallel-processes=2
    ```

  - **Run scenarios from a specific feature file using 2 parallel processes:**
    ```bash
    behavex features_folder_1/sample_feature.feature --parallel-processes=2
    ```

  - **Run scenarios tagged as `TAG_1` from a specific feature file using 2 parallel processes:**
    ```bash
    behavex features_folder_1/sample_feature.feature -t=@TAG_1 --parallel-processes=2
    ```

  - **Run scenarios located at specific folders using 2 parallel processes:**
    ```bash
    behavex features/feature_1 features/feature_2 --parallel-processes=2
    ```

  - **Run scenarios tagged as `TAG_1`, using 5 parallel processes executing a feature on each process:**
    ```bash
    behavex -t=@TAG_1 --parallel-processes=5 --parallel-scheme=feature
    ```

  - **Perform a dry run of the scenarios tagged as `TAG_1`, and generate the HTML report:**
    ```bash
    behavex -t=@TAG_1 --dry-run
    ```

  - **Run scenarios tagged as `TAG_1`, generating the execution evidence into a specific folder:**
    ```bash
    behavex -t=@TAG_1 -o=execution_evidence
    ```



  - BehaveX is currently implemented on top of Behave **v1.2.6**, and not all Behave arguments are yet supported.
  - Parallel execution is implemented using concurrent Behave processes. This means that any hooks defined in the `environment.py` module will run in each parallel process. This includes the **before_all** and **after_all** hooks, which will execute in every parallel process. The same is true for the **before_feature** and **after_feature** hooks when parallel execution is organized by scenario.



  - no_color
  - color
  - define
  - exclude
  - include
  - no_snippets
  - no_capture
  - name
  - capture
  - no_capture_stderr
  - capture_stderr
  - no_logcapture
  - logcapture
  - logging_level
  - summary
  - quiet
  - stop
  - tags
  - tags-help

  **Important**: Some arguments do not apply when executing tests with more than one parallel process, such as **stop** and **color**.



  - **output-folder** (-o or --output-folder): Specifies the output folder for execution reports (JUnit, HTML, JSON).
  - **dry-run** (-d or --dry-run): Performs a dry-run by listing scenarios in the output reports.
  - **parallel-processes** (--parallel-processes): Specifies the number of parallel Behave processes.
  - **parallel-scheme** (--parallel-scheme): Performs parallel test execution by [scenario|feature].
  - **show-progress-bar** (--show-progress-bar): Displays a progress bar in the console during parallel test execution.



  BehaveX manages concurrent executions of Behave instances in multiple processes. You can perform parallel test executions by feature or scenario. When the parallel scheme is by scenario, the examples of a scenario outline are also executed in parallel.


  ```bash
  behavex --parallel-processes=3
  behavex -t=@<TAG> --parallel-processes=3
  behavex -t=@<TAG> --parallel-processes=2 --parallel-scheme=scenario
  behavex -t=@<TAG> --parallel-processes=5 --parallel-scheme=feature
  behavex -t=@<TAG> --parallel-processes=5 --parallel-scheme=feature --show-progress-bar
  ```



  BehaveX populates the Behave contexts with the `worker_id` user-specific data. This variable contains the id of the current behave process.

  For example, if BehaveX is started with `--parallel-processes 2`, the first instance of behave will receive `worker_id=0`, and the second instance will receive `worker_id=1`.

  This variable can be accessed within the python tests using `context.config.userdata['worker_id']`.





  A friendly test execution report containing information related to test scenarios, execution status, evidence, and metrics. Available at:
  ```bash
  <output_folder>/report.html
  ```


  Contains information about test scenarios and execution status. Available at:
  ```bash
  <output_folder>/report.json
  ```


  One JUnit file per feature, available at:
  ```bash
  <output_folder>/behave/*.xml
  ```
  The JUnit reports have been replaced by the ones generated by the test wrapper, just to support muting tests scenarios on build servers



  You can attach images or screenshots to the HTML report using your own mechanism to capture screenshots or retrieve images. Utilize the **attach_image_file** or **attach_image_binary** methods provided by the wrapper.

  These methods can be called from hooks in the `environment.py` file or directly from step definitions.


  ```python
  from behavex_images import image_attachments

  @given('I take a screenshot from the current page')
  def step_impl(context):
      image_attachments.attach_image_file(context, 'path/to/image.png')
  ```


  ```python
  from behavex_images import image_attachments
  from behavex_images.image_attachments import AttachmentsCondition

  def before_all(context):
      image_attachments.set_attachments_condition(context, AttachmentsCondition.ONLY_ON_FAILURE)

  def after_step(context, step):
      image_attachments.attach_image_binary(context, selenium_driver.get_screenshot_as_png())
  ```

  By default, images are attached to the HTML report only when the test fails. You can modify this behavior by setting the condition using the **set_attachments_condition** method.

  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report.png?raw=true)
  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_2.png?raw=true)
  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_3.png?raw=true)

  For more information, check the [behavex-images](https://github.com/abmercado19/behavex-images) library, which is included with BehaveX 3.3.0 and above.

  If you are using BehaveX < 3.3.0, you can still attach images to the HTML report by installing the **behavex-images** package with the following command:

  > pip install behavex-images



  Providing ample evidence in test execution reports is crucial for identifying the root cause of issues. Any evidence file generated during a test scenario can be stored in a folder path provided by the wrapper for each scenario.

  The evidence folder path is automatically generated and stored in the **"context.evidence_path"** context variable. This variable is updated by the wrapper before executing each scenario, and all files copied into that path will be accessible from the HTML report linked to the executed scenario.



  The HTML report includes detailed test execution logs for each scenario. These logs are generated using the **logging** library and are linked to the specific test scenario. This feature allows for easy debugging and analysis of test failures.



  The HTML report provides a range of metrics to help you understand the performance and effectiveness of your test suite. These metrics include:

  * **Automation Rate**: The percentage of scenarios that are automated.
  * **Pass Rate**: The percentage of scenarios that have passed.
  * **Steps Execution Counter and Average Execution Time**: These metrics provide insights into the execution time and frequency of steps within scenarios.



  BehaveX enhances the traditional Behave dry run feature to provide more value. The HTML report generated during a dry run can be shared with stakeholders to discuss scenario specifications and test plans.

  To execute a dry run, we recommend using the following command:

  > behavex -t=@TAG --dry-run



  In some cases, you may want to mute test scenarios that are failing but are not critical to the build process. This can be achieved by adding the @MUTE tag to the scenario. Muted scenarios will still be executed, but their failures will not be reported in the JUnit reports. However, the execution details will be visible in the HTML report.





  For scenarios that are prone to intermittent failures or are affected by infrastructure issues, you can use the @AUTORETRY tag. This tag enables automatic re-execution of the scenario in case of failure.



  After executing tests, if there are failing scenarios, a **failing_scenarios.txt** file will be generated in the output folder. This file allows you to rerun all failed scenarios using the following command:

  > behavex -rf=./<OUTPUT_FOLDER\>/failing_scenarios.txt

  or

  > behavex --rerun-failures=./<OUTPUT_FOLDER\>/failing_scenarios.txt

  To avoid overwriting the previous test report, it is recommended to specify a different output folder using the **-o** or **--output-folder** argument.

  Note that the **-o** or **--output-folder** argument does not work with parallel test executions.



  When running tests in parallel, you can display a progress bar in the console to monitor the test execution progress. To enable the progress bar, use the **--show-progress-bar** argument:

  > behavex -t=@TAG --parallel-processes=3 --show-progress-bar

  If you are printing logs in the console, you can configure the progress bar to display updates on a new line by adding the following setting to the BehaveX configuration file:

  > [progress_bar]
  >
  > print_updates_in_new_lines="true"



  **If you find this project helpful or interesting, we would appreciate it if you could give it a star** (:star:). It's a simple way to show your support and let us know that you find value in our work.

  By starring this repository, you help us gain visibility among other developers and contributors. It also serves as motivation for us to continue improving and maintaining this project.

  Thank you in advance for your support! We truly appreciate it.


pkgId: 97a44a7e6047d07a875e77b1b1f846534c0fbfa8015a9c38647d02a939351198
name: python-behavex
arch: src
version: 4.0.9
epoch: 0
release: 1
summary: Agile testing framework on top of Behave (BDD).
url: https://github.com/hrcorval/behavex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behavex-4.0.9-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/behavex)](https://pepy.tech/project/behavex)
  [![PyPI version](https://badge.fury.io/py/behavex.svg)](https://badge.fury.io/py/behavex)
  [![Python Versions](https://img.shields.io/pypi/pyversions/behavex.svg)](https://pypi.org/project/behavex/)
  [![Dependency Status](https://img.shields.io/librariesio/github/hrcorval/behavex)](https://libraries.io/github/hrcorval/behavex)
  [![License](https://img.shields.io/github/license/hrcorval/behavex.svg)](https://github.com/hrcorval/behavex/blob/main/LICENSE)
  [![Build Status](https://github.com/hrcorval/behavex/actions/workflows/python-package.yml/badge.svg)](https://github.com/hrcorval/behavex/actions)
  [![GitHub last commit](https://img.shields.io/github/last-commit/hrcorval/behavex.svg)](https://github.com/hrcorval/behavex/commits/main)




  - [Introduction](#introduction)
  - [Features](#features)
  - [Installation Instructions](#installation-instructions)
  - [Execution Instructions](#execution-instructions)
  - [Constraints](#constraints)
  - [Supported Behave Arguments](#supported-behave-arguments)
  - [Specific Arguments from BehaveX](#specific-arguments-from-behavex)
  - [Parallel Test Executions](#parallel-test-executions)
  - [Test Execution Reports](#test-execution-reports)
  - [Attaching Images and Evidence](#attaching-images-and-evidence)
  - [Test Logs and Metrics](#test-logs-and-metrics)
  - [Muting Test Scenarios](#muting-test-scenarios)
  - [Handling Failing Scenarios](#handling-failing-scenarios)
  - [Displaying Progress Bar in Console](#displaying-progress-bar-in-console)
  - [Show Your Support](#show-your-support)



  **BehaveX** is a BDD testing solution designed to enhance your Behave-based testing workflow by providing additional features and performance improvements. It's particularly beneficial in the following scenarios:

  - **Accelerating test execution**: Significantly reduce test run times through parallel execution by feature or scenario.
  - **Enhancing test reporting**: Generate comprehensive and visually appealing HTML and JSON reports for in-depth analysis and integration with other tools.
  - **Improving test visibility**: Provide detailed evidence, such as screenshots and logs, essential for understanding test failures and successes.
  - **Optimizing test automation**: Utilize features like test retries, test muting, and performance metrics for efficient test maintenance and analysis.
  - **Managing complex test suites**: Handle large test suites with advanced features for organization, execution, and reporting.



  BehaveX provides the following features:

  - **Parallel Test Executions**: Execute tests using multiple processes, either by feature or by scenario.
  - **Enhanced Reporting**: Generate friendly HTML and JSON reports that can be exported and integrated with third-party tools.
  - **Evidence Collection**: Include images/screenshots and additional evidence in the HTML report.
  - **Test Logs**: Automatically compile logs generated during test execution into individual log reports for each scenario.
  - **Test Muting**: Add the `@MUTE` tag to test scenarios to execute them without including them in JUnit reports.
  - **Execution Metrics**: Generate metrics in the HTML report for the executed test suite, including Automation Rate, Pass Rate, Steps execution counter and average execution time.
  - **Dry Runs**: Perform dry runs to see the full list of scenarios in the HTML report without executing the tests. It overrides the `-d` Behave argument.
  - **Auto-Retry for Failing Scenarios**: Use the `@AUTORETRY` tag to automatically re-execute failing scenarios. Also, you can re-run all failing scenarios using the **failing_scenarios.txt** file.

  ![Test Execution Report](https://github.com/hrcorval/behavex/blob/master/img/html_test_report.png?raw=true)
  ![Test Execution Report](https://github.com/hrcorval/behavex/blob/master/img/html_test_report_2.png?raw=true)
  ![Test Execution Report](https://github.com/hrcorval/behavex/blob/master/img/html_test_report_3.png?raw=true)



  To install BehaveX, execute the following command:

  ```bash
  pip install behavex
  ```



  Execute BehaveX in the same way as Behave from the command line, using the `behavex` command. Here are some examples:

  - **Run scenarios tagged as `TAG_1` but not `TAG_2`:**
    ```bash
    behavex -t=@TAG_1 -t=~@TAG_2
    ```

  - **Run scenarios tagged as `TAG_1` or `TAG_2`:**
    ```bash
    behavex -t=@TAG_1,@TAG_2
    ```

  - **Run scenarios tagged as `TAG_1` using 4 parallel processes:**
    ```bash
    behavex -t=@TAG_1 --parallel-processes=4 --parallel-scheme=scenario
    ```

  - **Run scenarios located at specific folders using 2 parallel processes:**
    ```bash
    behavex features/features_folder_1 features/features_folder_2 --parallel-processes=2
    ```

  - **Run scenarios from a specific feature file using 2 parallel processes:**
    ```bash
    behavex features_folder_1/sample_feature.feature --parallel-processes=2
    ```

  - **Run scenarios tagged as `TAG_1` from a specific feature file using 2 parallel processes:**
    ```bash
    behavex features_folder_1/sample_feature.feature -t=@TAG_1 --parallel-processes=2
    ```

  - **Run scenarios located at specific folders using 2 parallel processes:**
    ```bash
    behavex features/feature_1 features/feature_2 --parallel-processes=2
    ```

  - **Run scenarios tagged as `TAG_1`, using 5 parallel processes executing a feature on each process:**
    ```bash
    behavex -t=@TAG_1 --parallel-processes=5 --parallel-scheme=feature
    ```

  - **Perform a dry run of the scenarios tagged as `TAG_1`, and generate the HTML report:**
    ```bash
    behavex -t=@TAG_1 --dry-run
    ```

  - **Run scenarios tagged as `TAG_1`, generating the execution evidence into a specific folder:**
    ```bash
    behavex -t=@TAG_1 -o=execution_evidence
    ```



  - BehaveX is currently implemented on top of Behave **v1.2.6**, and not all Behave arguments are yet supported.
  - Parallel execution is implemented using concurrent Behave processes. This means that any hooks defined in the `environment.py` module will run in each parallel process. This includes the **before_all** and **after_all** hooks, which will execute in every parallel process. The same is true for the **before_feature** and **after_feature** hooks when parallel execution is organized by scenario.



  - no_color
  - color
  - define
  - exclude
  - include
  - no_snippets
  - no_capture
  - name
  - capture
  - no_capture_stderr
  - capture_stderr
  - no_logcapture
  - logcapture
  - logging_level
  - summary
  - quiet
  - stop
  - tags
  - tags-help

  **Important**: Some arguments do not apply when executing tests with more than one parallel process, such as **stop** and **color**.



  - **output-folder** (-o or --output-folder): Specifies the output folder for execution reports (JUnit, HTML, JSON).
  - **dry-run** (-d or --dry-run): Performs a dry-run by listing scenarios in the output reports.
  - **parallel-processes** (--parallel-processes): Specifies the number of parallel Behave processes.
  - **parallel-scheme** (--parallel-scheme): Performs parallel test execution by [scenario|feature].
  - **show-progress-bar** (--show-progress-bar): Displays a progress bar in the console during parallel test execution.



  BehaveX manages concurrent executions of Behave instances in multiple processes. You can perform parallel test executions by feature or scenario. When the parallel scheme is by scenario, the examples of a scenario outline are also executed in parallel.


  ```bash
  behavex --parallel-processes=3
  behavex -t=@<TAG> --parallel-processes=3
  behavex -t=@<TAG> --parallel-processes=2 --parallel-scheme=scenario
  behavex -t=@<TAG> --parallel-processes=5 --parallel-scheme=feature
  behavex -t=@<TAG> --parallel-processes=5 --parallel-scheme=feature --show-progress-bar
  ```



  BehaveX populates the Behave contexts with the `worker_id` user-specific data. This variable contains the id of the current behave process.

  For example, if BehaveX is started with `--parallel-processes 2`, the first instance of behave will receive `worker_id=0`, and the second instance will receive `worker_id=1`.

  This variable can be accessed within the python tests using `context.config.userdata['worker_id']`.





  A friendly test execution report containing information related to test scenarios, execution status, evidence, and metrics. Available at:
  ```bash
  <output_folder>/report.html
  ```


  Contains information about test scenarios and execution status. Available at:
  ```bash
  <output_folder>/report.json
  ```


  One JUnit file per feature, available at:
  ```bash
  <output_folder>/behave/*.xml
  ```
  The JUnit reports have been replaced by the ones generated by the test wrapper, just to support muting tests scenarios on build servers



  You can attach images or screenshots to the HTML report using your own mechanism to capture screenshots or retrieve images. Utilize the **attach_image_file** or **attach_image_binary** methods provided by the wrapper.

  These methods can be called from hooks in the `environment.py` file or directly from step definitions.


  ```python
  from behavex_images import image_attachments

  @given('I take a screenshot from the current page')
  def step_impl(context):
      image_attachments.attach_image_file(context, 'path/to/image.png')
  ```


  ```python
  from behavex_images import image_attachments
  from behavex_images.image_attachments import AttachmentsCondition

  def before_all(context):
      image_attachments.set_attachments_condition(context, AttachmentsCondition.ONLY_ON_FAILURE)

  def after_step(context, step):
      image_attachments.attach_image_binary(context, selenium_driver.get_screenshot_as_png())
  ```

  By default, images are attached to the HTML report only when the test fails. You can modify this behavior by setting the condition using the **set_attachments_condition** method.

  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report.png?raw=true)
  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_2.png?raw=true)
  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_3.png?raw=true)

  For more information, check the [behavex-images](https://github.com/abmercado19/behavex-images) library, which is included with BehaveX 3.3.0 and above.

  If you are using BehaveX < 3.3.0, you can still attach images to the HTML report by installing the **behavex-images** package with the following command:

  > pip install behavex-images



  Providing ample evidence in test execution reports is crucial for identifying the root cause of issues. Any evidence file generated during a test scenario can be stored in a folder path provided by the wrapper for each scenario.

  The evidence folder path is automatically generated and stored in the **"context.evidence_path"** context variable. This variable is updated by the wrapper before executing each scenario, and all files copied into that path will be accessible from the HTML report linked to the executed scenario.



  The HTML report includes detailed test execution logs for each scenario. These logs are generated using the **logging** library and are linked to the specific test scenario. This feature allows for easy debugging and analysis of test failures.



  The HTML report provides a range of metrics to help you understand the performance and effectiveness of your test suite. These metrics include:

  * **Automation Rate**: The percentage of scenarios that are automated.
  * **Pass Rate**: The percentage of scenarios that have passed.
  * **Steps Execution Counter and Average Execution Time**: These metrics provide insights into the execution time and frequency of steps within scenarios.



  BehaveX enhances the traditional Behave dry run feature to provide more value. The HTML report generated during a dry run can be shared with stakeholders to discuss scenario specifications and test plans.

  To execute a dry run, we recommend using the following command:

  > behavex -t=@TAG --dry-run



  In some cases, you may want to mute test scenarios that are failing but are not critical to the build process. This can be achieved by adding the @MUTE tag to the scenario. Muted scenarios will still be executed, but their failures will not be reported in the JUnit reports. However, the execution details will be visible in the HTML report.





  For scenarios that are prone to intermittent failures or are affected by infrastructure issues, you can use the @AUTORETRY tag. This tag enables automatic re-execution of the scenario in case of failure.

  You can also specify the number of retries by adding the total retries as a suffix in the @AUTORETRY tag. For example, @AUTORETRY_3 will retry the scenario 3 times if the scenario fails.

  The re-execution will be performed right after a failing execution arises, and the latest execution is the one that will be reported.



  After executing tests, if there are failing scenarios, a **failing_scenarios.txt** file will be generated in the output folder. This file allows you to rerun all failed scenarios using the following command:

  > behavex -rf=./<OUTPUT_FOLDER\>/failing_scenarios.txt

  or

  > behavex --rerun-failures=./<OUTPUT_FOLDER\>/failing_scenarios.txt

  To avoid overwriting the previous test report, it is recommended to specify a different output folder using the **-o** or **--output-folder** argument.

  Note that the **-o** or **--output-folder** argument does not work with parallel test executions.



  When running tests in parallel, you can display a progress bar in the console to monitor the test execution progress. To enable the progress bar, use the **--show-progress-bar** argument:

  > behavex -t=@TAG --parallel-processes=3 --show-progress-bar

  If you are printing logs in the console, you can configure the progress bar to display updates on a new line by adding the following setting to the BehaveX configuration file:

  > [progress_bar]
  >
  > print_updates_in_new_lines="true"



  **If you find this project helpful or interesting, we would appreciate it if you could give it a star** (:star:). It's a simple way to show your support and let us know that you find value in our work.

  By starring this repository, you help us gain visibility among other developers and contributors. It also serves as motivation for us to continue improving and maintaining this project.

  Thank you in advance for your support! We truly appreciate it.


pkgId: 141801bd14aab0cc303b7fe2a5922f37c92c9bb17bc38669437f92017f3bfdb7
name: python-behavex-images
arch: src
version: 3.0.7
epoch: 0
release: 1
summary: BehaveX extension library to attach images to the test execution report.
url: https://github.com/abmercado19/behavex-images
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behavex-images-3.0.7-1.src.rpm
checksum_type: sha256
description:
  This implementation extends the BehaveX library to enable attaching images to the generated HTML report


  pip install behavex-images



  The following methods are provided to manage image attachments in the BehaveX HTML report:
  1. `attach_image_binary(context, image_binary)`
      - This function attaches an image from binary data to the test execution report. It takes two parameters:
          - `context`: The context object which contains various attributes used in the function.
          - `image_binary`: The binary data of the image to be attached.
      - The function determines the binary format to ensure it maps to a JPG or PNG image. Otherwise, it raises an exception.
      - Then, it converts the image to PNG format (if it is not already in that format) to add it to the gallery.

  2. `attach_image_file(context, file_path)`
      - This function attaches an image from a file to the test execution report. It takes two parameters:
          - `context`: The context object which contains various attributes used in the function.
          - `file_path`: The absolute path to the image file to be attached.
      - The function first checks if the file exists at the given path. If it does not, it raises an exception.
      - If the file exists, it checks the file extension. If the extension is not JPG or PNG, it raises an exception.
      - Then, it converts the image to PNG format (if it is not already in that format) to add it to the gallery.

  3. `set_attachments_condition(context, condition)`
      - This function sets the condition to attach images to the HTML report. It takes two parameters:
          - `context`: The context object which contains various attributes used in the function.
          - `condition`: The condition to attach images to the HTML report. Possible values:
            - AttachmentsCondition.ALWAYS: Attach images to the HTML report always.
            - AttachmentsCondition.ONLY_ON_FAILURE: Attach images to the HTML report only when the test fails. This is the default value.
            - AttachmentsCondition.NEVER: Do not attach images to the HTML report, no matter the test result.

  4. `clean_all_attached_images`
      - This function removes all images already attached to the HTML report for the current test scenario.


  The provided methods can be used from the hooks available in the environment.py file, or directly from step definitions to attach images to the HTML report. For example:

  * **Example 1**: Attaching an image file from a step definition
  ```python
  ...
  from behavex_images import image_attachments

  @given('I take a screenshot from current page')
  def step_impl(context):
      image_attachments.attach_image_file(context, 'path/to/image.png')
  ```

  * **Example 2**: Attaching an image binary from the `after_step` hook in environment.py
  ```python
  ...
  from behavex_images import image_attachments
  from behavex_images.image_attachments import AttachmentsCondition

  def before_all(context):
      image_attachements.set_attachments_condition(context, AttachmentsCondition.ONLY_ON_FAILURE)

  def after_step(context, step):
      image_attachements.attach_image_binary(context, selenium_driver.get_screenshot_as_png())
  ```


  ![test execution report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report.png?raw=true)

  ![test execution report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_2.png?raw=true)

  ![test execution report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_3.png?raw=true)


pkgId: 9dcb79049221880ff9ae40c73025b3dd51f50b39d0f9a21795fb14cebb057334
name: python-behavex-images
arch: src
version: 3.0.8
epoch: 0
release: 1
summary: BehaveX extension library to attach images to the test execution report.
url: https://github.com/abmercado19/behavex-images
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behavex-images-3.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/behavex-images)](https://pepy.tech/project/behavex-images)
  [![PyPI version](https://badge.fury.io/py/behavex-images.svg)](https://badge.fury.io/py/behavex-images)
  [![Dependency Status](https://img.shields.io/librariesio/github/abmercado19/behavex-images)](https://libraries.io/github/abmercado19/behavex-images)
  [![License](https://img.shields.io/github/license/abmercado19/behavex-images.svg)](https://github.com/abmercado19/behavex-images/blob/main/LICENSE)
  [![GitHub last commit](https://img.shields.io/github/last-commit/abmercado19/behavex-images.svg)](https://github.com/abmercado19/behavex-images/commits/main)



  An extension for the BehaveX library that enables attaching images to the generated HTML report.



  ```bash
  pip install behavex-images
  ```



  - Attach images to BehaveX HTML reports
  - Support for both binary image data and image files
  - Flexible attachment conditions (always, only on failure, or never)
  - Easy integration with existing BehaveX projects



  The `behavex-images` library provides four main methods for managing image attachments in BehaveX HTML reports:



  ```python
  from behavex_images import image_attachments

  image_attachments.attach_image_binary(context, image_binary)
  ```

  - `context`: The BehaveX context object
  - `image_binary`: Binary data of the image (JPG or PNG)



  ```python
  from behavex_images import image_attachments

  image_attachments.attach_image_file(context, file_path)
  ```

  - `context`: The BehaveX context object
  - `file_path`: Absolute path to the image file (JPG or PNG)



  ```python
  from behavex_images import image_attachments
  from behavex_images.image_attachments import AttachmentsCondition

  image_attachments.set_attachments_condition(context, condition)
  ```

  - `context`: The BehaveX context object
  - `condition`: One of the following `AttachmentsCondition` values:
    - `ALWAYS`: Attach images to every report
    - `ONLY_ON_FAILURE`: Attach images only when a test fails (default)
    - `NEVER`: Do not attach any images



  ```python
  from behavex_images import image_attachments

  image_attachments.clean_all_attached_images(context)
  ```

  - `context`: The BehaveX context object





  ```python
  from behavex_images import image_attachments

  @given('I take a screenshot of the current page')
  def step_impl(context):
      image_attachments.attach_image_file(context, 'path/to/screenshot.png')
  ```



  ```python
  from behavex_images import image_attachments
  from behavex_images.image_attachments import AttachmentsCondition

  def before_all(context):
      image_attachments.set_attachments_condition(context, AttachmentsCondition.ONLY_ON_FAILURE)

  def after_step(context, step):
      
      image_attachments.attach_image_binary(context, context.driver.get_screenshot_as_png())
  ```



  ![Test Execution Report](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report.png?raw=true)

  ![Test Execution Report with Images](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_2.png?raw=true)

  ![Test Execution Report Details](https://github.com/abmercado19/behavex-images/blob/master/behavex_images/img/html_test_report_3.png?raw=true)



  Contributions are welcome! Please feel free to submit a Pull Request.



  This project is licensed under the [MIT License](https://github.com/abmercado19/behavex-images/blob/main/LICENSE).


pkgId: 1377774dfbe677db7e573d70670379829de24585e8eee373a3b01c0335b9cd85
name: python-behaving
arch: src
version: 3.1.5
epoch: 0
release: 1
summary: BDD Behavior-Driven-Development testing
url: https://github.com/ggozad/behaving
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behaving-3.1.5-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/ggozad/behaving/ci.yml)](https://github.com/ggozad/behaving/actions/workflows/ci.yml)
  [![PyPI](https://img.shields.io/pypi/v/behaving)](https://pypi.org/project/behaving/)
  [![Docker Image Version (latest by date)](https://img.shields.io/docker/v/behaving/behaving)](https://hub.docker.com/repository/docker/behaving/behaving)

  _behaving_ is a web application testing framework for
  Behavior-Driven-Development, based on
  [behave](http://pypi.python.org/pypi/behave) and
  [splinter](https://github.com/cobrateam/splinter).

  _behave_ is written in Python and is similar to
  [Cucumber](http://cucumber.io/).
  _behaving_ adds the step-libraries for multi-user web/email/sms/gcm
  interactions, and provides the Python _behaving_ namespace so that
  independent step-libraries can work together.

  Please refer to _behave_'s excellent
  [documentation](http://behave.readthedocs.io/en/latest/) for a guide on
  how to use it, how to write your custom steps and make it possible to
  extend _behaving_.



  Starting to use _behaving_ is pretty easy. Inside some python module,
  add your _features_ consisting each of one or more scenarios. These
  features are Gherkin language files with an extension of `.feature`. In
  the same directory you should have a steps module which imports the
  _behaving_ steps as well as your own custom steps (more on that later in
  the setup\_ section) . Here's a basic example:

  ```gherkin
  Feature: Text presence

      Background:
          Given a browser

      Scenario: Search for BDD
          When I visit "http://www.wikipedia.org/"
          And I fill in "search" with "BDD"
          And I press "go"
          Then I should see "Behavior-driven development" within 5 seconds
  ```



  While the web is the focus of _behaving_, it also includes simple mocks
  for a mail, SMS and a GCM server. These come with a small collection of
  steps allowing you to do things like:

  ```gherkin
  Feature: Email & SMS

      Scenario: Click link in an email
          Given a browser
          When I send an email to "foo@bar.com" with subject "Hello" and body "Try out this website at http://google.com"
          And I click the link in the email I received at "foo@bar.com"
          Then the browser's URL should be "http://google.com/"

      Scenario: Receive SMS with body
          When I send an sms to "+4745690001" with body "Hello world"
          Then I should receive an sms at "+4745690001" containing "world"

      Scenario: Receive GCM Notification
          When I send a gcm message "{"to":"deviceID", "data": {"message": "Foo Bar", "badge": 6}}"
          Then I should receive a gcm notification at "deviceID" containing "{'data': {'message': 'Foo Bar'}}"
  ```

  Typically, it will be your web application that sends
  email/sms/notifications and testing it comes down to configuring the
  application to send email/sms/notifications to the mock servers.



  A lot of web apps today rely on multi-user interactions. To help you
  with those interactions, _behaving_ uses the notion of _personas_. A
  persona within a test runs in its own instance of a browser and you can
  have more than one persona (and its browser instance) running
  concurrently. You switch among personas by calling

  ```gherkin
  Given "PersonaName" as the persona
  ```

  Personas are also typically implemented as simple dictionaries allowing
  them to carry state, save and reuse variables inside a scenario. When a
  persona is first invoked it is created as an empty dictionary. You can
  predefine personas though with set values.

  Let's take the familiar LOTR characters as our test users. On setting up
  the test environment (details later in the setup\_ section), we set up
  the characters basic variables we might be needing in the tests as such:

  ```python
  PERSONAS = {
      'Frodo': dict(
          fullname=u'Frodo Baggins',
          email=u'frodo@shire.com',
          password=u'frodopass',
          mobile='+4745690001',
          address: {
              street: "The Shire",
              zip: "4321"
          }
      ),
      'Gandalf': dict(
          fullname=u'Gandalf the Grey',
          email=u'gandalf@wizardry.com',
          password=u'gandalfpass',
          mobile='+4745690004',
          address: {
              street: "Rivendell street 1",
              zip: "1234"
          }
    ),
    ...
  }
  def before_scenario(context, scenario):
      ...
      context.personas = PERSONAS
  ```

  Within a test and given a persona, you can now use `$var_name` to access
  a variable of a persona. You can also set new variables on personas. So
  the following,

  ```gherkin
  Given "Gandalf" as the persona
  When I fill in "name" with "$fullname"
  And I fill in "street" with "$address.street"
  And I set "title" to the text of "document-title"
  And I fill in "delete" with "$title"
  And I set "address.country" to the text of "country"
  And I set "postaddress" to:
  """
  $fullname
  $address.street, $address.zip, $address.country
  """
  ```

  would fill in the field with id `name` with `Gandalf the Grey`, `street`
  with `Rivendell street 1` set the variable `title` to the text of the
  element with id `document-title` and reuse the variable `title` to fill
  in the field with id `delete`. It would also store the value of the
  field with id "country" in address[`country`]. The `$var_name` pattern
  is also usable in the text received by steps that expect a body of text,
  which means that the `postaddress` persona variable will contain
  Gandalf's complete snail-mail postage address nicely formatted on
  multiple lines.



  Let us assume the following (coming from a real example) scenario.
  [Crypho](https://crypho.com), is an online messaging/sharing site that
  provides users with end-to-end encrypted real-time communications.
  _behaving_ was written to help test Crypho.

  In Crypho, teams collaborate in _spaces_. To invite somebody in a
  _space_ the invitee has to share a token with an invitor, so both can
  verify each other's identity.

  ```gherkin
  Feature: Frodo invites Gandalf to The Shire space

      Given state "the-shire"

      Scenario: Frodo invites Gandalf to The Shire

          Given "Gandalf" as the persona
          When I log in
  ```

  Before the scenarios start, the custom step `Given state "the-shire"`
  executes. This preloads the db with data, sets up the server etc. Then
  the scenario executes:

  First Gandalf logs in. The step `Given "Gandalf" as the persona`, fires
  up a browser that belongs to the persona Gandalf. The following step,
  `When I log in` is a custom step defined as follows:

  ```python
  @when('I log in')
  def log_in(context):

      assert context.persona
      context.execute_steps(u"""
          When I go to Home
              Then I should see an element with id "email" within 2 seconds
          When I fill in "email" with "$email"
          And I press "send-sms"
              Then I should see "We have sent you an SMS with a security code" within 2 seconds
              And I should receive an sms at "$mobile"
              And "token" should be enabled
          When I parse the sms I received at "$mobile" and set "Your Crypho code is {token}"
          And I fill in "token" with "$token"
          And I fill in "password" with "$password"
          And I press "login"
              Then I should see "Crypho" within 5 seconds
      """)
  ```

  Observe above how the current persona (Gandalf) parses the sms it
  receives and saves it as "token". Later Gandalf reuses it to fill in the
  two-factor authentication field.

  Now that Gandalf is logged in, the test proceeds with Frodo. Frodo will
  log in, and invite Gandalf to a private space.

  ```gherkin
  Given "Frodo" as the persona
  When I log in
  And I click the link with text that contains "My spaces"
  And I click the link with text that contains "The Shire"
  And I press "invite-members"
      Then I should see "Invite members" within 1 seconds
  When I fill in "invitees" with "gandalf@wizardry.com"
  And I fill in "invitation-message" with "Come and join us!"
  And I press "send-invitations"
      Then I should see "Your invitations have been sent" within 2 seconds
  ```

  Once the invitations are sent we switch back to Gandalf's browser, who
  should have received a notification in his browser, as well as an email.
  He then proceeds to send an sms to Frodo with the token who completes
  the invitation.

  ```gherkin
  Given "Gandalf" as the persona
  Then I should see "Your invitations have been updated" within 2 seconds
  And I should receive an email at "gandalf@wizardry.com" containing "Frodo Baggins has invited you to join a private workspace in Crypho"
  When I click the link with text that contains "Invitations"
  And I click the link with text that contains "Pending invitations"
      Then I should see "Come and join us!"
  When I set "token" to the text of "invitation-token"
  And I send an sms to "45699900" with body "$token"

  Given "Frodo" as the persona
      Then I should receive an sms at "45699900"
  When I set "FrodoToken" to the body of the sms I received at "45699900"
  And I click the link with text that contains "Invitations"
  And I click the link with text that contains "Enter authorization token"
  And I fill in "auth-token" with "$FrodoToken"
  And I press "Submit"
      Then I should see "The invitation has been accepted." within 5 seconds
      And I should see "Gandalf the Grey has joined the space, invited by Frodo Baggins" within 10 seconds
  ```

  You can see the test in action on video
  [here](http://vimeo.com/63672466/).



  Start by installing _behaving_ by using either `pip` or `easy_install`.
  This will also install dependencies and create the `behave` script with
  which you invoke your tests. If you prefer using buildout, clone the
  package itself from its repository, it contains already a buildout
  configuration.

  Typically you will be having a folder containing all your features and
  steps. For example a directory structure like the following:

  ```
  features/
  features/mytest.feature
  features/myothertest.feature
  features/environment.py
  features/steps/
  features/steps/steps.py
  ```

  In the steps directory you will need to import the _behaving_ steps you
  need. You can also define your own steps. So `steps.py` might look like:

  ```python
  from behave import when
  from behaving.web.steps import *
  from behaving.sms.steps import *
  from behaving.mail.steps import *
  from behaving.notifications.gcm.steps import *
  from behaving.personas.steps import *

  @when('I go to home')
  def go_to_home(context):
      context.browser.visit('https://web/')
  ```

  In `environment.py` you specify settings as well the things that need to
  happen at various stages of testing, i.e. before and after everything, a
  feature run, or a scenario run. For convenience you can import and reuse
  `behaving.environment` which will perform default actions like closing
  all browsers after a scenario, clean the email folder etc.

  It is also possible to use `behaving.web.environment`,
  `behaving.mail.environment`, `behaving.sms.environment` and
  `behaving.personas.environment` on their own, if you don't have need for
  SMS for example.

  An example of an environment that does simply set some variables and
  then rely on default actions for the various stages, might look like the
  following:

  ```python
  import os
  from behaving import environment as benv

  PERSONAS = {}

  def before_all(context):
      import mypackage
      context.attachment_dir = os.path.join(os.path.dirname(mypackage.__file__), 'tests/data')
      context.sms_path = os.path.join(os.path.dirname(mypackage.__file__), '../../var/sms/')
      context.gcm_path = os.path.join(os.path.dirname(mypackage.__file__), '../../var/gcm/')
      context.mail_path = os.path.join(os.path.dirname(mypackage.__file__), '../../var/mail/')
      benv.before_all(context)


  def after_all(context):
      benv.after_all(context)


  def before_feature(context, feature):
      benv.before_feature(context, feature)


  def after_feature(context, feature):
      benv.after_feature(context, feature)


  def before_scenario(context, scenario):
      benv.before_scenario(context, scenario)
      context.personas = PERSONAS

  def after_scenario(context, scenario):
      benv.after_scenario(context, scenario)
  ```

  The following variables are supported and can be set to override
  defaults:

  - `screenshots_dir` (the path where screenshots will be saved. If it
    is set, any failure in a scenario will result in a screenshot of the
    browser at the time when the failure happened.)
  - `attachment_dir` (the path where file attachments can be found)
  - `sms_path` (the path to be used by `smsmock` to save sms. Defaults
    to `current_dir/sms` )
  - `gcm_path` (the path to be used by `gcmmock` to save gcm
    notifications. Defaults to `current_dir/gcm` )
  - `mail_path` (the path to be used by `mailmock` to save mail.
    Defaults to `current_dir/mail` )
  - `default_browser`
  - `default_browser_size` (tuple (width, height), applied to each
    browser as it's created)
  - `max_browser_attempts` (how many times to retry creating the browser
    if it fails)
  - `remote_webdriver_url` (points to your selenium hub url or remote
    webdriver. Defaults to `None`)
  - `browser_args` (a dict of additional keyword arguments used when
    creating a browser)
  - `base_url` (the base url for a browser, allows you to use relative
    paths)
  - `accept_ssl_certs` (setting to `True` will accept self-signed/invalid
    certificates. Defaults to `None`)

  You can run the tests simply by issuing

  ```sh
  ./bin/behave ./features
  ```

  For chrome and docker issues, the code below is useful

  ```python
  from selenium.webdriver.chrome.options import Options
  chrome_options = Options()
  chrome_options.add_argument('--no-sandbox')
  context.browser_args = {
      'options': chrome_options
  }
  ```



  When _behaving_ is installed, it creates three scripts to help you test
  mail, gcm and sms, `mailmock`, `gcmmock` and `smsmock` respectively. You
  can directly invoke them before running your tests, they all take a port
  as well as the directory to output data as parameters. For example,

  ```sh
  ./bin/smsmock -p 8081 -o ./var/sms
  ./bin/gcmmock -p 8082 -o ./var/notifications/gcm
  ./bin/mailmock -p 8083 -o ./var/mail [--no-stdout]
  ```



  - Browsers

    - Given a browser [opens the default browser, i.e. Firefox]
    - Given `brand` as the default browser [sets the default browser to be `brand`, this is the browser name when using the remote webdriver or Firefox, Chrome, Safari]
    - Given the electron app "`app_path`" [for use with electron-based desktop apps]
    - Given browser "`name`" [opens the browser named `name`]
    - When I reload
    - When I go back
    - When I go forward
    - When I resize the browser to `width`x`height`
    - When I resize the viewport to `width`x`height`
    - When I take a screenshot [will save a screenshot of the browser if `screenshots_dir` is set on the environment. Also, if `screenshots_dir` is set, all failing tests will result in a screenshot.]
    - When I execute the script "`script`"
    - When I set the cookie "`key`" to "`value`"
    - When I delete the cookie "`key`"
    - When I delete all cookies
    - When I close the browser "`name`"

  - Frames

    - When I switch to frame with css "`css`"
    - When I switch back to the main page

  - Windows

    - When I open a new window named "`name`" at "`url`"
    - When I name the current window "`name`"
    - When I switch to the window named "`name`"

  - URLs

    - Given the base url "`url`" [sets the base url to `url`, alternatively set `context.base_url` directly in `environment.py`]
    - When I visit "`url`"
    - When I go to "`url`"
    - When I parse the url path and set "`{expression}`"
    - Then the browser's URL should be "`url`"
    - Then the browser's URL should contain "`text`"
    - Then the browser's URL should not contain "`text`"

  - Links

    - When I click the link to "`url`"
    - When I click the link to a url that contains "`url`"
    - When I click the link with text "`text`"
    - When I click the link with text that contains "`text`"

  - Text, element & class presence

    - When I wait for `timeout` seconds
    - When I show the element with id "`id`"
    - When I hide the element with id "`id`"

    - Text

      - Then I should see "`text`"
      - Then I should not see "`text`"
      - Then I should see "`text`" within `timeout` seconds
      - Then I should not see "`text`" within `timeout` seconds

    - ID
      - Then I should see an element with id "`id`"
      - Then I should not see an element with id "`id`"
      - Then I should see an element with id "`id`" within `timeout` seconds
      - Then I should not see an element with id "`id`" within `timeout` seconds

  - CSS

    - Existence
      - Then I should see an element with the css selector "`selector`"
      - Then I should not see an element with the css selector "`selector`"
      - Then I should see an element with the css selector "`selector`" within `timeout` seconds
      - Then I should not see an element with the css selector "`selector`" within `timeout` seconds
      - Then I should see `n` elements with the css selector "`css`"
      - Then I should see at least `n` elements with the css selector "`css`" within `timeout` seconds
    - Visibility
      - Then the element with the css selector "`css`" should be visible
      - Then the element with the css selector "`css`" should be visible within `timeout` seconds
      - Then the element with the css selector "`css`" should not be visible
      - Then the element with the css selector "`css`" should be visible within `timeout` seconds
      - Then {n:d} elements with the css selector "`css`" should be visible
      - Then {n:d} elements with the css selector "`css`" should be visible within `timeout` seconds
      - Then at least {n:d} elements with the css selector "`css`" should be visible
      - Then at least {n:d} elements with the css selector "`css`" should be visible within `timeout` seconds
    - Existence of a class on an element
      - Then the element with xpath "`xpath`" should have the class "`cls`"
      - Then the element with xpath "`xpath`" should not have the class "`cls`"
      - Then the element with xpath "`xpath`" should have the class "`cls`" within `timeout` seconds
      - Then the element with xpath "`xpath`" should not have the class "`cls`" within `timeout` seconds
      - Then "`name`" should have the class "`cls`"
      - Then "`name`" should not have the class "`cls`"
      - Then "`name`" should have the class "`cls`" within `timeout` seconds
      - Then "`name`" should not have the class "`cls`" within `timeout:d` seconds
    - XPath
      - Then I should see an element with xpath "`xpath`"
      - Then I should not see an element with xpath "`xpath`"
      - Then I should see an element with xpath "`xpath`" within `timeout` seconds
      - Then I should not see an element with xpath "`xpath`" within `timeout` seconds

  - Forms

    - When I fill in "`name|id`" with "`value`"
    - When I clear field "`name|id`"
    - When I type "`value`" to "`name|id`" [same as fill, but happens slowly triggering keyboard events]
    - When I choose "`value`" from "`name`"
    - When I check "`name|id`"
    - When I uncheck "`name|id`"
    - When I toggle "`name|id`"
    - When I select "`value`" from "`name`""
    - When I select by text "`text`" from "`name`""
    - When I press "`name|id|text|innerText`"
    - When I press the element with xpath "`xpath`"
    - When I attach the file "`path`" to "`name`"
    - When I set the innner HTML of the element with id "`id`" to "`contents`" [Sets html on a `contenteditable` element with id `id` to `contents`]
    - When I set the innner HTML of the element with class "`class`" to "`contents`"
    - When I set the innner HTML of the element with class "`class`" to "`contents`"
    - When I send "`KEY`" to "`name`"
    - When I focus on "`name`"
    - Then field "`name`" should have the value "`value`"
    - Then field "`name`" should have the value "`value`" within `timeout` seconds
    - Then the selection "`name`" should have the options "`valueA, valueB`" selected
    - Then "`name`" should be enabled
    - Then "`name`" should be disabled
    - Then "`name`" should not be enabled
    - Then "`name`" should be valid
    - Then "`name`" should be invalid
    - Then "`name`" should not be valid
    - Then "`name`" should be required
    - Then "`name`" should not be required

  - HTML tables

    - Then the table with id "`id`" should be
      | header1 | header2 | ... | header(m) |
      | cell00 | cell01 | ... | cell0m |
      | cell10 | cell11 | ... | cell1m |
      ...
      | celln0 | celln1 | ... | cellnm |

    - Then the table with xpath "`xpath`" should be
      | header1 | header2 | ... | header(m) |
      | cell00 | cell01 | ... | cell0m |
      | cell10 | cell11 | ... | cell1m |
      ...
      | celln0 | celln1 | ... | cellnm |

    - Then the table with id "`id`" should contain the rows
      | cell00 | cell01 | ... | cell0m |
      | cell10 | cell11 | ... | cell1m |

    - Then the table with xpath "`xpath`" should contain the rows
      | cell00 | cell01 | ... | cell0m |
      | cell10 | cell11 | ... | cell1m |

    - Then the table with id "`id`" should not contain the rows
      | cell00 | cell01 | ... | cell0m |
      | cell10 | cell11 | ... | cell1m |

    - Then the table with xpath "`xpath`" should not contain the rows
      | cell00 | cell01 | ... | cell0m |
      | cell10 | cell11 | ... | cell1m |

    - Then row `row_no` in the table with id "`id`" should be
      | cell00 | cell01 | ... | cell0m |

    - Then row `row_no` in the table with xpath "`xpath`" should be
      | cell00 | cell01 | ... | cell0m |

    - Then the value of the cell in row `row_no`, column `col_no` in the table with id "`id`" should be "`value`"

    - Then the value of the cell in row `row_no`, column `col_no` in the table with xpath "`xpath`" should be "`value`"

    - Then the value of the cell in row `row_no`, column "`col_header`" in the table with id "`id`" should be "`value`"

    - Then the value of the cell in row `row_no`, column "`col_header`" in the table with xpath "`xpath`" should be "`value`"

  - Alerts & prompts

    - When I enter "`text`" to the alert - When I accept the alert - When I dismiss the alert - Then I should see an alert - Then I should see an alert within `timeout` seconds - Then I should see an alert containing "`text`" - Then I should see an alert containing "`text`" within `timeout` seconds

  - Mouse

    - When I mouse over the element with xpath "`xpath`"
    - When I mouse out of the element with xpath "`xpath`"

  - Downloads

    - Then the file "`filename`" with contents "`text`" should have been downloaded within `timeout` seconds
    - Then the file "`filename`" should have been downloaded within `timeout` seconds

  - Persona interaction & variables

    - When I set "`key`" to the text of "`id|name`"
    - When I set "`key`" to the attribute "`attr`" of the element with xpath "`xpath`"
    - When I evaluate the script "`script`" and assign the result to "`key`"



  - When I click the link in the email I received at "`address`"
  - When I parse the email I received at "`address`" and set "`expression`"
  - When I clear the email messages
  - Then I should receive an email at "`address`"
  - Then I should receive an email at "`address`" with subject "`subject`"
  - Then I should receive an email at "`address`" containing "`text`"
  - Then I should receive an email at "`address`" with attachment "`filename`"
  - Then I should not have received any emails at "`address`"



  - When I set "`key`" to the body of the sms I received at "`number`"
  - When I parse the sms I received at "`number`" and set "`expression`"
  - Then I should receive an sms at "`number`"
  - Then I should receive an sms at "`number`" containing "`text`"



  - When I send a gcm message "{"to":"deviceID", "data": {"message":"Foo Bar", "badge": 6}}"
  - Then I should receive a gcm notification at "deviceID" containing "{'data': {'message': 'Foo Bar'}}"
  - Then I should have received any gcm notifications at "deviceID"



  - Given "`name`" as the persona
  - When I set "`key`" to "`value`"
  - When I set "`key`" to:
    """ `some longer body of text`
     `usually multiline`
    """
  - When I clone persona "`source`" to "`target`"
  - Then "`key`" is set to "`value`"



  - When I pause the tests



  A `Dockerfile` as well as a complete setup using `docker-compose` are provided to help you create selenium grid configurations that run your tests. In addition dev container configuration is included if VSCode is your thing.

  In addition we provide pre-build images on docker hub for the `linux/amd64` and `linux/arm64` platforms. Use

  ```bash
  docker pull behaving/behaving:latest
  ```

  to pull the image.



  You can run all behaving tests as follows:

  Start docker compose:

  ```
  docker-compose up
  ```

  Open a shell in the behaving container:

  ```
  docker-compose exec behaving bash
  ```

  Run behaving tests:

  ```
  behave tests/features
  ```


pkgId: d7b06af94e35017b1e04c6b4ca1a5dbe004e7cde2abda4cf2d4150a6e261758e
name: python-behringer-mixer
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Module to get basic information from Behringer digital mixers eg X32/XAir etc.
url: https://github.com/wrodie/behringer-mixer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behringer-mixer-0.4.5-1.src.rpm
checksum_type: sha256
description:
  Python module to get basic information from Behringer digital mixers eg X32/XAir etc.

  Initial inspiration (and some code) comes from https://github.com/onyx-and-iris/xair-api-python.


  This module is a simple interface to a series of Behringer digital mixers.  It does NOT support all parameters or controls.  It is primarily focussed on getting and setting fader information.  It supports getting this information, both on a once off basis and subscribing for real-time updates.

  It currently supports the following functionality for all channels/busses/matrices/auxin/dcas/main/lr:
  - Fader Value (float and dB) [get/set]
  - Fader Mute status [get/set]
  - Fader Name [get]

  It also supports
  - Current scene/snapshot [get]
  - Change scene/snapshot [set]
  - Control USB Player/Recorder [get/set]
  - Current USB Filename [get]
  - Firmware version

  If you want a module that allows you to control the full functionality of the mixer, eg configuring effects/eq etc then I would recommend checking out https://github.com/onyx-and-iris/xair-api-python instead.



  -   Python 3.10 or greater



  ```
  pip install behringer-mixer
  ```



  This module depends on the asyncio module to handle multiple runnings tasks simultaneously.


  ```python
  import asyncio
  import logging
  from behringer_mixer import mixer_api

  def updates_function(data):
      print(f"The property {data.get('property')} has been set to {data.get('value')}")

  async def main():
      mixer  = mixer_api.create("X32", ip="192.168.201.149", logLevel=logging.WARNING)
      await mixer.start()
      state = await mixer.reload()
      state = mixer.state()
      print(state)
      asyncio.create_task(mixer.subscribe(updates_function))
      await mixer.set_value("/ch/1/mix_fader", 10)
      await asyncio.sleep(20)

  if __name__ == "__main__":
      asyncio.run(main())
  ```


  The data returned by both the `state` and `subscription` callback function is based on a number of property keys for the mixer.  While these keys are 'similar' to the values used in the OSC commands they are not always the same.

  Each key is a mixture of a base 'group' key eg `/ch/1/` and a more specific key.
  They keys have also been altered slightly to maintain a consistent approach between different mixers. eg. For channel/bus numbers the leading zero has been removed. on the XAir mixers the main fader is `/main/lr` whereas on the X32 it is `/main/st`.  This modules returns both as `/main/st`.


  The code is written to support the following mixer types:
  - `X32`
  - `XR18`
  - `XR16`
  - `XR12`

  The following keyword arguments may be passed:

  -   `ip`: ip address of the mixer (Required)
  -   `port`: mixer port, defaults to 10023 for x32 and 10024 for xair
  -   `delay`: a delay between each command, defaults to 20ms.
      -   a note about delay, stability may rely on network connection. For wired connections the delay can be safely reduced.
  -   `logLevel`: the level of logging, defaults to warning (enums from logging eg logging.DEBUG)

  The create function only creates an instance of the mixer, it does not 'connect' to it.
  You should call the `mixer.start()` function to prepare communication and then call `mixer.validate_connection()` to check that the connection to the mixer worked.


  Returns the firmware version of the mixer.
  `

  Returns information about the mixer, giving the number of channels/busses etc as well as the base part of the 'address' for that component.
  ```
          {
              "channel": {
                  "number": 32,
                  "base_address": "ch",
              },
              "bus": {
                  "number": 16,
                  "base_address": "bus",
              },
              "matrix": {
                  "number": 6,
                  "base_address": "mtx",
              },
              "dca": {
                  "number": 8,
                  "base_address": "dca",
              },
              "fx": {
                  "number": 10,
                  "base_address": "fx",
              },
              "auxrtn": {
                  "number": 8,
                  "base_address": "auxrtn",
              },
              "scenes": {
                  "number": 100,
                  "base_address": "scene",
              },
          }
  ```


  Returns a unix timestamp giving the last time data was received from the mixer.


  Changes the current/scene snapshot of the mixer.
  `scene_number` is the scene number as stored on the mixer.


  Returns the network name of the mixer.


  This is a low level call and returns the response of a previous `send` call. You should not need to call this, but rely on the managed state instead.


  Causes the the mixer to be requeried for it's current state. This only updates the module's internal state.  You would then need to call `mixer.state()` to receive the updated state.


  This is a low level call to send an OSC message to the mixer.  As this is a low level call, the address of the OSC message being sent would have to conform to that required by the mixer in its documenation, no changing of the address is performed.  This call does not update the internal state. You should not need to call this, but rely on the managed state instead.


  Tells the mixer to update a particular field parameter to the `value` specified.
  `address` should be in the format returned by the `mixer.state()` call.
  `value` should be in a format appropriate to the address being used. The module does no checking on the appropriateness of the value.
  This call also updates the internal state of the module.


  Starts the OSC server to process messages. Data will not be returned/processed unless this has been run


  Returns the current state of the mixer. If the optional address parameter is provided then the current state of that address is returned.  If the parameter is not provided then the entire state is returned as a dictionary of values.
  ```
  {
  	'/ch/1/mix_fader': 0.75,
  	'/ch/1/mix_fader_db': 0.0,
      ...
  	'/ch/1/mix_on': False,
  	'/ch/2/mix_on': False,
  	'/ch/1/config_name': 'VOX 1',
  	...
  	'/bus/1/mix_fader': 0.37829911708831787,
  	'/bus/1/mix_fader_db': -19.7,
  	...
  	'/bus/4/mix_on': True,
  	...
  	'/bus/2/config_name': '',
  	...
  	'/dca/3/config_name': 'Drums',
  	...
  	'/main/st/mix_fader': 0.7497556209564209,
  	'/main/st/mix_fader_db': -0.0,
  	'/main/st/mix_on': True,
  	...
  	'/scene/current': 6
  }
  ```


  Stops the OSC server and the ability to process messages


  This registers a `callback_function` that is called whenever there is a change at the mixer on one of the monitored properties.
  The callback function will receive one dictionary parameter that contains the data that has been updated.
  The content of this data parameter is as follows

  ```python
  {
      'property': '/ch/01/mix_fader',
      'value': 0.85
  }
  ```


  Returns true if the module has received data from the mixer in the last 15 seconds.


  Register a function to be called when the subscription status changes.  This function is called when `subscription_connected()` changes.


  Stops the module listening to real time updates


  Returns `True` if the connection to the mixer is successful, `False` otherwise.




  These tests attempt to connect to a mixer to exercise get/set from the channels.
  The tests will change the state of the mixer, so it is recommended you save the current settings before running.
  It is also recommended that any amplifier is turned off as feedback could occur if signals are present on the channels.

  To run all tests:

  `pytest -v`.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details



  [XAir OSC Commands](https://behringer.world/wiki/doku.php?id=x-air_osc)

  [X32 OSC Commands](https://wiki.munichmakerlab.de/images/1/17/UNOFFICIAL_X32_OSC_REMOTE_PROTOCOL_%281%29.pdf)



  [Onyx-and-Iris](https://github.com/onyx-and-iris) for writing the XAir Python module


pkgId: 903479f0dddd60c5726a44354f0aa414b308d9d3bf90b73ba9e85d912c359842
name: python-behringer-mixer
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: Module to get basic information from Behringer digital mixers eg X32/XAir etc.
url: https://github.com/wrodie/behringer-mixer
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-behringer-mixer-0.4.6-1.src.rpm
checksum_type: sha256
description:
  Python module to get basic information from Behringer digital mixers eg X32/XAir etc.

  Initial inspiration (and some code) comes from https://github.com/onyx-and-iris/xair-api-python.


  This module is a simple interface to a series of Behringer digital mixers.  It does NOT support all parameters or controls.  It is primarily focussed on getting and setting fader information.  It supports getting this information, both on a once off basis and subscribing for real-time updates.

  It currently supports the following functionality for all channels/busses/matrices/auxin/dcas/main/lr/mono:
  - Fader Value (float and dB) [get/set]
  - Fader Color (index 0-15 and color name) [get/set]
  - Fader Mute status [get/set]
  - Fader Name [get]

  It also supports
  - Current scene/snapshot [get]
  - Change scene/snapshot [set]
  - Control USB Player/Recorder [get/set]
  - Current USB Filename [get]
  - Firmware version

  If you want a module that allows you to control the full functionality of the mixer, eg configuring effects/eq etc then I would recommend checking out https://github.com/onyx-and-iris/xair-api-python instead.



  -   Python 3.10 or greater



  ```
  pip install behringer-mixer
  ```



  This module depends on the asyncio module to handle multiple runnings tasks simultaneously.


  ```python
  import asyncio
  import logging
  from behringer_mixer import mixer_api

  def updates_function(data):
      print(f"The property {data.get('property')} has been set to {data.get('value')}")

  async def main():
      mixer  = mixer_api.create("X32", ip="192.168.201.149", logLevel=logging.WARNING)
      await mixer.start()
      state = await mixer.reload()
      state = mixer.state()
      print(state)
      asyncio.create_task(mixer.subscribe(updates_function))
      await mixer.set_value("/ch/1/mix_fader", 10)
      await asyncio.sleep(20)

  if __name__ == "__main__":
      asyncio.run(main())
  ```


  The data returned by both the `state` and `subscription` callback function is based on a number of property keys for the mixer.  While these keys are 'similar' to the values used in the OSC commands they are not always the same.

  Each key is a mixture of a base 'group' key eg `/ch/1/` and a more specific key.
  They keys have also been altered slightly to maintain a consistent approach between different mixers. eg. For channel/bus numbers the leading zero has been removed. on the XAir mixers the main fader is `/main/lr` whereas on the X32 it is `/main/st`.  This modules returns both as `/main/st`.


  The code is written to support the following mixer types:
  - `X32`
  - `XR18`
  - `XR16`
  - `XR12`

  The following keyword arguments may be passed:

  -   `ip`: ip address of the mixer (Required)
  -   `port`: mixer port, defaults to 10023 for x32 and 10024 for xair
  -   `delay`: a delay between each command, defaults to 20ms.
      -   a note about delay, stability may rely on network connection. For wired connections the delay can be safely reduced.
  -   `logLevel`: the level of logging, defaults to warning (enums from logging eg logging.DEBUG)

  The create function only creates an instance of the mixer, it does not 'connect' to it.
  You should call the `mixer.start()` function to prepare communication and then call `mixer.validate_connection()` to check that the connection to the mixer worked.


  Returns the firmware version of the mixer.
  `

  Returns information about the mixer, giving the number of channels/busses etc as well as the base part of the 'address' for that component.
  ```
          {
              "channel": {
                  "number": 32,
                  "base_address": "ch",
              },
              "bus": {
                  "number": 16,
                  "base_address": "bus",
              },
              "matrix": {
                  "number": 6,
                  "base_address": "mtx",
              },
              "dca": {
                  "number": 8,
                  "base_address": "dca",
              },
              "fx": {
                  "number": 10,
                  "base_address": "fx",
              },
              "auxrtn": {
                  "number": 8,
                  "base_address": "auxrtn",
              },
              "scenes": {
                  "number": 100,
                  "base_address": "scene",
              },
          }
  ```


  Returns a unix timestamp giving the last time data was received from the mixer.


  Changes the current/scene snapshot of the mixer.
  `scene_number` is the scene number as stored on the mixer.


  Returns the network name of the mixer.


  This is a low level call and returns the response of a previous `send` call. You should not need to call this, but rely on the managed state instead.


  Causes the the mixer to be requeried for it's current state. This only updates the module's internal state.  You would then need to call `mixer.state()` to receive the updated state.


  This is a low level call to send an OSC message to the mixer.  As this is a low level call, the address of the OSC message being sent would have to conform to that required by the mixer in its documenation, no changing of the address is performed.  This call does not update the internal state. You should not need to call this, but rely on the managed state instead.


  Tells the mixer to update a particular field parameter to the `value` specified.
  `address` should be in the format returned by the `mixer.state()` call.
  `value` should be in a format appropriate to the address being used. The module does no checking on the appropriateness of the value.
  This call also updates the internal state of the module.


  Starts the OSC server to process messages. Data will not be returned/processed unless this has been run


  Returns the current state of the mixer. If the optional address parameter is provided then the current state of that address is returned.  If the parameter is not provided then the entire state is returned as a dictionary of values.
  ```
  {
  	'/ch/1/mix_fader': 0.75,
  	'/ch/1/mix_fader_db': 0.0,
      ...
  	'/ch/1/mix_on': False,
  	'/ch/2/mix_on': False,
  	'/ch/1/config_name': 'VOX 1',
  	'/ch/1/config_color': 4,
  	'/ch/1/config_color_name': 'BL',
  	...
  	'/bus/1/mix_fader': 0.37829911708831787,
  	'/bus/1/mix_fader_db': -19.7,
  	...
  	'/bus/4/mix_on': True,
  	...
  	'/bus/2/config_name': '',
  	...
  	'/dca/3/config_name': 'Drums',
  	'/dca/3/config_color': 10,
  	'/dca/3/config_color_name': 'GNi',
  	...
  	'/main/st/mix_fader': 0.7497556209564209,
  	'/main/st/mix_fader_db': -0.0,
  	'/main/st/mix_on': True,
  	...
  	'/scene/current': 6
  }
  ```


  Stops the OSC server and the ability to process messages


  This registers a `callback_function` that is called whenever there is a change at the mixer on one of the monitored properties.
  The callback function will receive one dictionary parameter that contains the data that has been updated.
  The content of this data parameter is as follows

  ```python
  {
      'property': '/ch/01/mix_fader',
      'value': 0.85
  }
  ```


  Returns true if the module has received data from the mixer in the last 15 seconds.


  Register a function to be called when the subscription status changes.  This function is called when `subscription_connected()` changes.


  Stops the module listening to real time updates


  Returns `True` if the connection to the mixer is successful, `False` otherwise.




  These tests attempt to connect to a mixer to exercise get/set from the channels.
  The tests will change the state of the mixer, so it is recommended you save the current settings before running.
  It is also recommended that any amplifier is turned off as feedback could occur if signals are present on the channels.

  To run all tests:

  `pytest -v`.



  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details



  [XAir OSC Commands](https://behringer.world/wiki/doku.php?id=x-air_osc)

  [X32 OSC Commands](https://wiki.munichmakerlab.de/images/1/17/UNOFFICIAL_X32_OSC_REMOTE_PROTOCOL_%281%29.pdf)



  [Onyx-and-Iris](https://github.com/onyx-and-iris) for writing the XAir Python module


pkgId: 965ed7eea56f889b59961d0baf461768d149a55c5f8fe1f9fe932c841d300101
name: python-beiboot
arch: src
version: 1.4.3
epoch: 0
release: 1
summary: Getdeck Beiboot client project.
url: https://getdeck.dev
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beiboot-1.4.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://github.com/Getdeck/beiboot/raw/main/docs/static/img/logo.png" alt="Gefyra Logo"/>
  </p>


  _Getdeck Beiboot_ (or just Beiboot for brevity) is a Kubernetes-in-Kubernetes solution. It was born from the idea to
  provide Getdeck users a simple yet flexible solution to spin up **hybrid cloud development** infrastructure. This is
  useful for Kubernetes development workloads which grew too large to run on a development machine (or with pony workloads
  on MacOS and Windows machines).


  The Beiboot client is a Python API to manage Beiboot clusters. It can set up and tear down Kubernetes instances
  as well as establish connections.


pkgId: d9290fb209f15ee3202444cc17ac7dd20a27122d510f69d5961b443d36a64865
name: python-belarusianconverter
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Library for convertation Belarusian texts from Cyrillic to other Belarusian alphabets
url: https://github.com/alelisicyna/BelarusianConverter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belarusianconverter-0.0.6-1.src.rpm
checksum_type: sha256
description:
  Library for convertation Belarusian texts from Cyrillic to other Belarusian alphabets

  ```py
  $ pip install belarusianconverter
  ```

  ```py

  from BelarusianConverter import BelarusianConverter



  script = BelarusianConverter()


  if __name__ == '__main__':
    text = script.convert(0, 'А хто там ідзе?') # example
    print(text) # Return: "A chto tam idzie?"

  '''
    BelarusianConverter.convert(alphabet: int, text: str, plosive_g = False, assimilation = False, iotation = False)
    alphabet:
      0 - LatinMuzyckajaPrauda (K. Kalinoŭski)
      1 - Latin1929 (B. Taraškievič)
      2 - Latin1962 (Ja. Stankievič)
      3 - LatinUnitedNations
      4 - Romanization2023
      5 - Arabic (Belarusian Tatars)
    plosive_g:
      True: H -> G in some words
      False: keep the original text
    assimilation:
      True: add a soft assimilation
      False: keep the original text
    iotation:
      True: I -> Ji/J after vowels
      False: keep the original text
  '''

  ```


  About Belarusian Latin: [Wikipedia](https://en.wikipedia.org/wiki/Belarusian_Latin_alphabet)
  About Belarusian Arabic: [Wikipedia](https://en.wikipedia.org/wiki/Belarusian_Arabic_alphabet)


pkgId: c942d61278f6c2b61e121acc79cee0687aada75daefcc6bd2923fc3e7c581e3d
name: python-belay
arch: src
version: 0.22.6
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/BrianPugh/belay
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belay-0.22.6-1.src.rpm
checksum_type: sha256
description:
  Belay is for people creating a software project that needs to interact with hardware.
  Examples include:
  * Control a motor so a webcam is always pointing at a person.
  * Turn on an LED when you receive a notification.
  * Read a potentiometer to control system volume.
  The Belay Package Manager is for people that want to use public libraries, and get them on-device in
  an easy, repeatable, dependable manner.


pkgId: 2419b30b5a4ad3a728072ec64bc123ec94571a692bcfbf25c9b0482292b66685
name: python-belch
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Password list generator
url: https://github.com/croketillo/belch
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belch-0.4.0-1.src.rpm
checksum_type: sha256
description:
  BELCH Password List Generator is a simple tool to generate password
  lists based on a given pattern. You can specify the password pattern and
  generate multiple unique passwords.

rpm_license:
[cell repeats an earlier one in this file: 34486 characters]


pkgId: aa99aafa28f768d7aa225b30e55593711508684683896e5b2c407afd89950630
name: python-belfry_magicbell
arch: src
version: 2.3.3
epoch: 0
release: 1
summary: Fork of the unofficial Python SDK for MagicBell
url: https://github.com/BelfrySoftware/magicbell-python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belfry_magicbell-2.3.3-1.src.rpm
checksum_type: sha256
description:
  This is an unofficial Python SDK for [MagicBell](https://magicbell.com) open sourced with ❤️ by <a href="https://noteable.io">Noteable</a>, a collaborative notebook platform that enables teams to use and visualize data, together.
  [Install](#installation) | [Getting Started](#getting-started) | [Examples](./examples) | [License](./LICENSE) | [Code of Conduct](./CODE_OF_CONDUCT.md) | [Contributing](./CONTRIBUTING.md)

  Python 3.8+


  ```shell
  poetry add belfry_magicbell
  ```
  Then import the package:
  ```python
  import belfry_magicbell
  ```

  ```shell
  pip install belfry_magicbell
  ```
  Then import the package:
  ```python
  import belfry_magicbell
  ```

  ```python
  import belfry_magicbell
  from belfry_magicbell.configuration import Configuration
  config = Configuration(
      api_key="YOUR_API_KEY",
      api_secret="YOUR_API_SECRET",
  )
  async with belfry_magicbell.MagicBell(config) as mb:
      
      await mb.realtime.create_notification(
          belfry_magicbell.WrappedNotification(
              notification=belfry_magicbell.Notification(
                  title="My first notification from python!",
                  recipients=[belfry_magicbell.Recipient(email="dan@example.com")],
              )
          )
      )
  ```

  Most API calls require your belfry_magicbell project API Key and API Secret.
  Some API calls (i.e. projects) require your belfry_magicbell user JWT (enterprise only).
  See the [MagicBell API documentation](https://www.magicbell.com/docs/rest-api/reference#authentication) for more information.

  Configuration can be done explicitly using the `belfry_magicbell.Configuration` class,
  or implicitly by setting environment variables with the `MAGICBELL_` prefix.

  ```python
  from belfry_magicbell.configuration import Configuration

  config = Configuration(
      api_key="YOUR_API_KEY",
      api_secret="YOUR_API_SECRET",
  )
  ```

  ```shell
  export MAGICBELL_API_KEY="YOUR_API_KEY"
  export MAGICBELL_API_SECRET="YOUR_API_SECRET"
  ```
  ```python
  from belfry_magicbell.configuration import Configuration
  config = Configuration()
  ```

  For more examples see the [`examples` directory](./docs/examples).


pkgId: c085c41a51f5ef7394bff989b79dd5016146e86eec93d4014e334b7e7baeceef
name: python-belfry_python_anvil
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Fork of Anvil API
url: https://www.useanvil.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belfry_python_anvil-4.0.1-1.src.rpm
checksum_type: sha256
description:
  ![Horizontal Lockupblack](https://user-images.githubusercontent.com/293079/169453889-ae211c6c-7634-4ccd-8ca9-8970c2621b6f.png#gh-light-mode-only)
  ![Horizontal Lockup copywhite](https://user-images.githubusercontent.com/293079/169453892-895f637b-4633-4a14-b997-960c9e17579b.png#gh-dark-mode-only)



  [![PyPI Version](https://img.shields.io/pypi/v/python-anvil.svg)](https://pypi.org/project/python-anvil)
  [![PyPI License](https://img.shields.io/pypi/l/python-anvil.svg)](https://pypi.org/project/python-anvil)

  This is a library that provides an interface to access the [Anvil API](https://www.useanvil.com/developers) from applications
  written in the Python programming language.

  [Anvil](https://www.useanvil.com/developers/) provides easy APIs for all things paperwork.

  1. [PDF filling API](https://www.useanvil.com/products/pdf-filling-api/) - fill out a PDF template with a web request and structured JSON data.
  2. [PDF generation API](https://www.useanvil.com/products/pdf-generation-api/) - send markdown or HTML and Anvil will render it to a PDF.
  3. [Etch e-sign with API](https://www.useanvil.com/products/etch/) - customizable, embeddable, e-signature platform with an API to control the signing process end-to-end.
  4. [Anvil Workflows (w/ API)](https://www.useanvil.com/products/workflows/) - Webforms + PDF + e-sign with a powerful no-code builder. Easily collect structured data, generate PDFs, and request signatures.

  Learn more on our [Anvil developer page](https://www.useanvil.com/developers/). See the [API guide](https://www.useanvil.com/docs) and the [GraphQL reference](https://www.useanvil.com/docs/api/graphql/reference/) for full documentation.



  General API documentation: [Anvil API docs](https://www.useanvil.com/docs)





  * Python 3.7.2+



  Install it directly into an activated virtual environment:

  ```shell
  $ pip install python-anvil
  ```

  or add it to your [Poetry](https://python-poetry.org/) project:

  ```shell
  $ poetry add python-anvil
  ```


pkgId: bfdeb5a4642ca536d37906dc226ee50cbe0b63231f4ecdd2eda22310bc491ae8
name: python-beliefppg
arch: src
version: 0.3.1
epoch: 0
release: 1
description:
  You can install the pip package using:
  ```bash
  pip install beliefppg
  ```

url: https://github.com/eth-siplab/BeliefPPG
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-beliefppg-0.3.1-1.src.rpm
checksum_type: sha256
summary:
  Taking multi-channel PPG and Accelerometer signals as input, BeliefPPG predicts the instantaneous heart rate and provides an uncertainty estimate for the prediction.


pkgId: 30d8b2293f9ec90f1b546e5977a480aec71d09cb417068939901449766876376
name: python-believe
arch: src
version: 1.0.14
epoch: 0
release: 1
summary: A easy to use validator for json content
url: https://pypi.org/project/believe/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-believe-1.0.14-1.src.rpm
checksum_type: sha256
description:
  * We often need to compare expected results in our test. It's lousy to check expected result under the following way.

  ```
  import uuid

  class TestCases:
      def test_user(self):
          user = {
                      "name": "John",
                      "id": "30e7b1e2-4c80-44c2-8fe5-23bad73ed8f2"
                  }
          assert set("name", "id") == set(user.keys())
          assert isinstance(user["name"], str)
          assert 0 < len(user["name"]) < 64
          assert isinstance(user["id"], str)
          uuid.UUID(user["id"])
  ```

  * By using this package, we could compare the value using the following way. It's easier to read and maintain.

  ```
  import believe as B

  class TestCases:
      def test_user(self):
          user = {
                      "name": "John",
                      "id": "30e7b1e2-4c80-44c2-8fe5-23bad73ed8f2"
                  }
          assert user == {"name": B.AnyStr(min_len=1, max_len=63),
                          "id": B.AnyUUID()}

  ```

  * If you are looking for web framework input validation, I suggest use [FastAPI](https://fastapi.tiangolo.com/). It properly integrate with openapi as well.


  ```
  pip install believe
  ```


  ```
  import believe as B
  import time


  assert B.AnyStr() == "any_str"


  assert B.AnyStr(min_len=1, max_len=10) == "a"


  assert B.AnyIntStr() == "123"


  assert B.AnyUUID() == "732c0743-2638-47d5-902d-0daa3080348b"


  assert B.AnySHA1() == "b130c4b97d0640eaf3f45f7360a5b4dbbf561f58"


  assert B.AnyIPV4() == "1.2.3.4"


  assert B.AnyInt(min_value=1, max_value=10) == 5


  assert B.AnyFloat(min_value=1.0, max_value=10.0) == 5.0 # 1.0 <= X <= 10.0


  assert B.OneOf("one", "two") == "one"


  assert B.AnyOrder([1, 2, 3]) == [2, 1, 3]



  assert B.Almost(time.time(), ts_range=3) == time.time() # Allow 3 sec gap


  assert B.Nullable(B.AnyStr()) == None
  assert B.Nullable(B.AnyStr()) == "123"


  assert B.Any(bytes) == b'123'


  assert B.Not(B.OneOf("A", "B")) == "C"


  assert B.ListOf(B.AnyStr()) == ["A", "B", "C"]
  assert B.ListOf(B.AnyStr(), n_item=3) == ["A", "B", "C"]  # exact 3 items
  assert B.ListOf(B.AnyStr(), min_item=1) == ["A", "B", "C"]  # >= 1 items
  assert B.ListOf(B.AnyStr(), max_item=5) == ["A", "B", "C"]  # <= 5 items
  ```


  ```

  assert B.AnyJsonStr({"foo": "bar"}) == '{"foo": "bar"}'



  assert B.AnyUrl("https://foo.com/") == "https://foo.com:443/"
  assert B.AnyUrl("http://foo.com/") == "http://foo.com:80/"

  assert B.AnyUrl("https://foo.com/bar?p1=1&p2=2") == "https://foo.com/bar?p2=2&p1=1"


  assert B.Dict({"name": B.AnyStr(), "value": B.Optional(B.AnyStr())}) == {"name": "abc"}
  assert B.Dict({"name": B.AnyStr(), "value": B.Optional(B.AnyStr())}) == {"name": "abc", "value": "def"}



  assert B.DictOf(B.AnyUUID(), B.OneOf("ok", "fail")) == {"732c0743-2638-47d5-902d-0daa3080348b": "ok",
                                                          "5cfd50ba-c3d3-4fb7-b2fe-e9a6e039ad29": "fail"}
  ```


  ```

  import believe as B
  validator = B.Dict({"name": B.AnyInt()})

  B.validate(validator, {"name": "ken"})  # believe.error.ValidateError: [e_path=$.name] 'ken' != AnyInt()
  ```


  ```
  import believe as B
  import time

  result_json = {"name": "john",
                 "age": 32,
                 "download_link": "https://download.server.com/?name=john&id=abc",
                 "role": "admin",
                 "address": "10.1.2.3",
                 "updated_at": int(time.time()),
                 "tags": ["admin", "john"]}

  exp_result = B.Dict({"name": B.AnyStr(min_len=1, max_len=64),
                       "age": B.AnyInt(min_value=0, max_value=200),
                       "download_link": B.AnyUrl("https://download.server.com/?id=abc&name=john"),
                       "role": B.OneOf("admin", "user"),
                       "address": B.AnyIPV4(),
                       "updated_at": B.Almost(int(time.time())),
                       "tags": B.ListOf(B.AnyStr()),
                       "extra": B.Optional(B.Nullable(B.AnyStr()))})
  B.validate(exp_result, result_json)
  ```


pkgId: ddfb4ca71933604df884bfc1a4fb7470bb0928ffa2e7dddef11bd434b065b2e5
name: python-bell-avr-libraries
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Common Python libraries used by parts of Bell AVR
url: https://github.com/bellflight/AVR-Python-Libraries
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bell-avr-libraries-0.1.13-1.src.rpm
checksum_type: sha256
description:
  To install the base package, run:

  ```bash
  pip install bell-avr-libraries
  ```

  Additionally, the `mqtt` and `serial` extras are available if you want to use
  the MQTT or PCC functionality.

  ```bash
  pip install bell-avr-libraries[mqtt,serial]
  ```





  ```python
  from bell.avr import mqtt
  ```

  These are MQTT utilities that are used to have a consistent messaging protocol
  throughout all the AVR software modules.

  The first part of this are the payloads for the MQTT messages themselves. As AVR
  exclusively uses JSON, these are all
  [`TypedDict`](https://docs.python.org/3/library/typing.html#typing.TypedDict)s
  that have all of the required fields for a message.

  Example:

  ```python
  from bell.avr.mqtt.payloads import AvrPcmSetBaseColorPayload

  payload = AvrPcmSetBaseColorPayload((128, 232, 142, 0))
  ```

  The second part of the MQTT libraries, is the `MQTTModule` class.
  This is a boilerplate module for AVR that makes it very easy to send
  and recieve MQTT messages and do something with them.

  Example:

  ```python
  from bell.avr.mqtt.client import MQTTModule
  from bell.avr.mqtt.payloads import AvrFcmVelocityPayload, AvrPcmSetServoOpenClosePayload


  class Sandbox(MQTTModule):
      def __init__(self) -> None:
          super().__init__()
          self.topic_map = {"avr/fcm/velocity": self.show_velocity}

      def show_velocity(self, payload: AvrFcmVelocityPayload) -> None:
          vx = payload["vX"]
          vy = payload["vY"]
          vz = payload["vZ"]
          v_ms = (vx, vy, vz)
          print(f"Velocity information: {v_ms} m/s")

      def open_servo(self) -> None:
          payload = AvrPcmSetServoOpenClosePayload(servo=0, action="open")
          self.send_message("avr/pcm/set_servo_open_close", payload)


  if __name__ == "__main__":
      box = Sandbox()
      box.run()
  ```

  The `topic_map` dictionary is a class attribute that maps topics to subscribe to
  and a function that will handle an incoming payload. The `payload` argument
  should match the appropriate `Payload` class for that topic.

  Additionally, the `message_cache` attribute is a dictionary that holds
  a copy of the last payload sent by that module on a given topic. The keys are the
  topic strings, and the values are the topic payloads.



  ```python
  from bell.avr import utils
  ```

  These are general purpose utilities.



  ```python
  from bell.avr.utils import decorators
  ```

  There are 3 different function decorators available, which are helpful for MQTT
  message callbacks. First is the `try_except` decorator, which wraps the
  function in a `try: except:` statement and will log any exceptions to the console:

  ```python
      @decorators.try_except
      def assemble_hil_gps_message(self) -> None:
          ...
  ```

  Additionally, there is the `reraise` argument, which can be set to `True` to raise
  any exceptions that are encountered. This is helpful if you still want exceptions
  to propagate up, but log them.

  There is an async version of this decorator as well with an `async_` prefix.

  ```python
      @decorators.async_try_except()
      async def connected_status_telemetry(self) -> None:
          ...
  ```

  The last decorator is `run_forever` which will run the wrapped function forever,
  with a given `period` or `frequency`.

  ```python
      @decorators.run_forever(frequency=5)
      def read_data(self) -> None:
          ...
  ```



  ```python
  from bell.avr.utils import timing
  ```

  Here is a `rate_limit` function which take a callable and a
  period or frequency, and only run the callable at that given rate.

  ```python
  for _ in range(10):
      
      timing.rate_limit(add, period=5)
      time.sleep(1)
  ```

  This works tracking calls to the `rate_limit` function from a line number
  within a file, so multiple calls to `rate_limit` say within a loop
  with the same callable and period will be treated seperately. This allows
  for dynamic frequency manipulation.



  ```python
  from bell.avr import serial
  ```

  These are serial utilities that help facilitate finding and communicating
  with the AVR peripherial control computer.



  ```python
  from bell.avr.serial import client
  ```

  The `SerialLoop` class is a small wrapper around the `pyserial` `serial.Serial`
  class which adds a `run` method that will try to read data from the serial device
  as fast as possible.

  ```python
  ser = client.SerialLoop()
  ```



  ```python
  from bell.avr.serial import client
  ```

  The `PeripheralControlComputer` class sends serial messages
  to the AVR peripherial control computer, via easy-to-use class methods.

  ```python
  import bell.avr.serial.client
  import bell.avr.serial.pcc
  import threading

  client = bell.avr.serial.client.SerialLoop()
  client.port = port
  client.baudrate = baudrate
  client.open()

  pcc = bell.avr.serial.pcc.PeripheralControlComputer(client)

  client_thread = threading.Thread(target=client.run)
  client_thread.start()

  pcc.set_servo_max(0, 100)
  ```



  ```python
  from bell.avr.serial import ports
  ```

  Here is a `list_serial_ports` function which returns a list of detected serial
  ports connected to the system.

  ```python
  serial_ports = ports.list_serial_ports()

  ```



  Install [`poetry`](https://python-poetry.org/) and run
  `poetry install --extras mqtt --extras serial` to install of the dependencies
  inside a virtual environment.

  Build the auto-generated code with `poetry run python build.py`. From here,
  you can now produce a package with `poetry build`.

  To add new message definitions, add entries to the `bell/avr/mqtt/messages.jsonc` file.
  The 3 parts of a new message are as follows:

  1. "topic": This is the full topic path for the message. This must be all lower case and
     start with "avr/".
  2. "payload": These are the keys of the payload for the message.
     This is a list of key entries (see below).
  3. "docs": This is an optional list of Markdown strings that explains what this
     message does. Each list item is a new line.

  The key entries for a message have the following elements:

  1. "key": This is the name of the key. Must be a valid Python variable name.
  2. "type": This is the data type of the key such as `Tuple[int, int, int, int]`.
     Must be a valid Python type hint. Otherwise, this can be a list of more
     key entries, effectively creating a nested dictionary.
  3. "docs": This is an optional list of Markdown strings that explains what the
     key is. Each list item is a new line.

  The `bell/avr/mqtt/schema.json` file will help ensure the correct schema is maintained,
  assuming you are using VS Code.







  - `"id"` (`int`):
      The ID of the AprilTag
  - `"pos"` (`AvrApriltagsRawTagsPos`)
  - `"rotation"` (`Tuple[Tuple[float, float, float], Tuple[float, float, float], Tuple[float, float, float]]`):
      The 3x3 rotation matrix



  - `"x"` (`float`):
      The position in meters of the camera relative to the AprilTag's X frame
  - `"y"` (`float`):
      The position in meters of the camera relative to the AprilTag's Y frame
  - `"z"` (`float`):
      The position in meters of the camera relative to the AprilTag's Z frame



  The position of the vehicle in world frame in centimeters

  - `"n"` (`float`):
      The +north position of the vehicle relative to the world origin in world frame
  - `"e"` (`float`):
      The +east position of the vehicle relative to the world origin in world frame
  - `"d"` (`float`):
      The +down position of the vehicle relative to the world origin in world frame



  - `"id"` (`int`):
      The ID of the AprilTag
  - `"horizontal_dist"` (`float`):
      The horizontal scalar distance from vehicle to AprilTag, in centimeters
  - `"vertical_dist"` (`float`):
      The vertical scalar distance from vehicle to AprilTag, in centimeters
  - `"angle_to_tag"` (`float`):
      The angle formed by the vector pointing from the vehicles body to the AprilTag in world frame relative to world-north
  - `"heading"` (`float`):
      The heading of the vehicle in world frame
  - `"pos_rel"` (`AvrApriltagsVisibleTagsPosRel`):
      The relative position of the vehicle to the tag in world frame in centimeters
  - `"pos_world"` (`AvrApriltagsVisibleTagsPosWorld`):
      The position of the vehicle in world frame in centimeters (if the tag has no truth data, this will not be present in the output)



  The relative position of the vehicle to the tag in world frame in centimeters

  - `"x"` (`float`):
      The x (+north/-south) position of the vehicle relative to the AprilTag in world frame
  - `"y"` (`float`):
      The y (+east/-west) position of the vehicle relative to the AprilTag in world frame
  - `"z"` (`float`):
      The z (+down/-up) position of the vehicle relative to the AprilTag in world frame



  The position of the vehicle in world frame in centimeters (if the tag has no truth data, this will not be present in the output)

  - `"x"` (`Optional[float]`):
      The x position of the vehicle relative to the world origin (this is the ship) in world frame (for reference the mountain is **north** of the beach)
  - `"y"` (`Optional[float]`):
      The y position of the vehicle relative to the world origin in world frame
  - `"z"` (`Optional[float]`):
      The z position of the vehicle relative to the world origin in world frame





  Topic: `avr/apriltags/fps`

  This reports the framerate of AprilTag processing

  - `"fps"` (`int`):
      Number of frames of video data processed in the last second



  Topic: `avr/apriltags/raw`

  This topic publishes the raw AprilTag data

  - `"tags"` (`List[AvrApriltagsRawTags]`)



  Topic: `avr/apriltags/selected`

  This topic publishes its best candidate for position feedback

  - `"tag_id"` (`int`):
      The id of the tag
  - `"pos"` (`AvrApriltagsSelectedPos`):
      The position of the vehicle in world frame in centimeters
  - `"heading"` (`float`)



  Topic: `avr/apriltags/visible`

  This topic publishes the transformed AprilTag data

  - `"tags"` (`List[AvrApriltagsVisibleTags]`)



  Topic: `avr/autonomous/building/drop`

  This enables or disables a building payload drop. This is not used by any Bell code, but available to students to listen to.

  - `"id"` (`int`):
      0-index ID of the relevant building
  - `"enabled"` (`bool`):
      Boolean of whether the building should have drop enabled



  Topic: `avr/autonomous/enable`

  This enables or disables autonomous mode. This is not used by any Bell code, but available to students to.

  - `"enabled"` (`bool`)



  Topic: `avr/fcm/attitude/euler`

  This reports the current attitude of the drone from the flight controller.

  - `"roll"` (`float`):
      Roll in degrees
  - `"pitch"` (`float`):
      Pitch in degrees
  - `"yaw"` (`float`):
      Yaw in degrees



  Topic: `avr/fcm/battery`

  This reports battery information from the flight controller.

  - `"voltage"` (`float`):
      Battery voltage
  - `"soc"` (`float`):
      State of charge (0 - 100)



  Topic: `avr/fcm/events`

  This reports events from the flight controller such as flight mode changes.

  - `"name"` (`str`):
      The name of the event.
  - `"payload"` (`str`):
      The payload of the event.



  Topic: `avr/fcm/gps_info`

  This reports the current status of the flight controller's GPS connection.

  - `"num_satellites"` (`int`):
      Number of visible satellites in use. HIL GPS will appear as 13.
  - `"fix_type"` (`str`):
      GPS fix type



  Topic: `avr/fcm/hil_gps_stats`

  This reports statistics on the HIL GPS data that is fed into the flight controller.

  - `"num_frames"` (`int`):
      This is the number of messages that have been sent to the flight controller since the software has started.



  Topic: `avr/fcm/location/global`

  This reports the current position of the drone in global coordinates from the flight controller.

  - `"lat"` (`float`):
      Latitude in degrees
  - `"lon"` (`float`):
      Longitude in degrees
  - `"alt"` (`float`):
      Altitude relative to takeoff altitude in meters
  - `"hdg"` (`float`):
      Heading in degrees.



  Topic: `avr/fcm/location/home`

  This reports the current position of the drone's home position in global coordinates.

  - `"lat"` (`float`):
      Latitude in degrees of the home position
  - `"lon"` (`float`):
      Longitude in degrees of the home position
  - `"alt"` (`float`):
      Altitude relative to the home position in meters



  Topic: `avr/fcm/location/local`

  This reports the current position of the drone in local coordinates from the flight controller.

  - `"dX"` (`float`):
      X position in a local North/East/Down coordinate system in meters
  - `"dY"` (`float`):
      Y position in a local North/East/Down coordinate system in meters
  - `"dZ"` (`float`):
      Z position in a local North/East/Down coordinate system in meters



  Topic: `avr/fcm/status`

  This reports general status of the flight controller.

  - `"armed"` (`bool`):
      Boolean of if the drone is currently armed
  - `"mode"` (`str`):
      Current flight mode, which is one of the following:
      - 'UNKNOWN'
      - 'READY'
      - 'TAKEOFF'
      - 'HOLD'
      - 'MISSION'
      - 'RETURN_TO_LAUNCH'
      - 'LAND'
      - 'OFFBOARD'
      - 'FOLLOW_ME'
      - 'MANUAL'
      - 'ALTCTL'
      - 'POSCTL'
      - 'ACRO'
      - 'STABILIZED'
      - 'RATTITUDE'



  Topic: `avr/fcm/velocity`

  This reports the current velocity vectors of the drone from the flight controller.

  - `"vX"` (`float`):
      X velocity in a local North/East/Down coordinate system in meters per second
  - `"vY"` (`float`):
      Y velocity in a local North/East/Down coordinate system in meters per second
  - `"vZ"` (`float`):
      Z velocity in a local North/East/Down coordinate system in meters per second



  Topic: `avr/fusion/attitude/euler`

  This reports the computed attitude of the drone from our sensor fusion.

  - `"psi"` (`float`):
      Roll in radians
  - `"theta"` (`float`):
      Pitch in radians
  - `"phi"` (`float`):
      Yaw in radians



  Topic: `avr/fusion/attitude/heading`

  This reports the computed heading of the drone from our sensor fusion.

  - `"heading"` (`float`):
      Heading in degrees



  Topic: `avr/fusion/attitude/quat`

  This reports the computed attitude of the drone from our sensor fusion.

  - `"w"` (`float`):
      Quaternion w value
  - `"x"` (`float`):
      Quaternion x value
  - `"y"` (`float`):
      Quaternion y value
  - `"z"` (`float`):
      Quaternion z value



  Topic: `avr/fusion/climbrate`

  This reports the computed rate of climb of the drone from our sensor fusion.

  - `"climb_rate_fps"` (`float`):
      Rate of climb in feet per second



  Topic: `avr/fusion/course`

  This reports the computed course of the drone from our sensor fusion.

  - `"course"` (`float`):
      Course in degrees



  Topic: `avr/fusion/geo`

  This reports the computed position of the drone in global coordinates from our sensor fusion.

  - `"lat"` (`float`):
      Latitude in degrees
  - `"lon"` (`float`):
      Longitude in degrees
  - `"alt"` (`float`):
      Altitude relative to takeoff altitude in meters



  Topic: `avr/fusion/groundspeed`

  This reports the computed groundspeed of the drone from our sensor fusion.

  - `"groundspeed"` (`float`):
      Groundspeed of the drone in meters per second. This is a normal vector of the N and E velocities.



  Topic: `avr/fusion/hil_gps`

  This is the raw data that will get converted to a MAVLink message and sent to the flight controller for HIL GPS. <https://mavlink.io/en/messages/common.html#HIL_GPS>

  - `"time_usec"` (`int`):
      UNIX epoch timestamp in microseconds
  - `"fix_type"` (`int`):
      0-1: no fix, 2: 2D fix, 3: 3D fix.
  - `"lat"` (`int`):
      WGS84 Latitude * 10000000
  - `"lon"` (`int`):
      WGS84 Longitude * 10000000
  - `"alt"` (`int`):
      Altitude from sea level in mm. Positive for up.
  - `"eph"` (`int`):
      GPS HDOP horizontal dilution of position
  - `"epv"` (`int`):
      GPS VDOP vertical dilution of position
  - `"vel"` (`int`):
      GPS ground speed in centimeters per second
  - `"vn"` (`int`):
      GPS velocity in north direction in centimeters per second
  - `"ve"` (`int`):
      GPS velocity in east direction in centimeters per second
  - `"vd"` (`int`):
      GPS velocity in down direction in centimeters per second
  - `"cog"` (`int`):
      Course over ground in degrees
  - `"satellites_visible"` (`int`):
      Number of satellites visible. This is hardcoded to 13 for our HIL GPS.
  - `"heading"` (`int`):
      Custom heading field. This is the heading in degrees * 100.



  Topic: `avr/fusion/position/ned`

  This reports the computed position of the drone in local coordinates from our sensor fusion.

  - `"n"` (`float`):
      X position in a local North/East/Down coordinate system in meters
  - `"e"` (`float`):
      Y position in a local North/East/Down coordinate system in meters
  - `"d"` (`float`):
      Z position in a local North/East/Down coordinate system in meters



  Topic: `avr/fusion/velocity/ned`

  This reports the computed velocity vectors of the drone from our sensor fusion.

  - `"Vn"` (`float`):
      X velocity in a local North/East/Down coordinate system in meters per second
  - `"Ve"` (`float`):
      Y velocity in a local North/East/Down coordinate system in meters per second
  - `"Vd"` (`float`):
      Z velocity in a local North/East/Down coordinate system in meters per second



  Topic: `avr/pcm/fire_laser`

  Fires the laser for a 0.25 sec pulse. Has a cooldown of 0.5 sec.

  There is no content for this class



  Topic: `avr/pcm/set_base_color`

  This sets the color of the LED strip on the PCC

  - `"wrgb"` (`Tuple[int, int, int, int]`):
      A list of 4 `int`s between 0 and 255 to set the base color of the LEDs. This is in order of White, Red, Green, Blue. Example: [0, 0, 255, 0] would be Green.



  Topic: `avr/pcm/set_laser_off`

  Turns off laser (laser off from blip mode - but doesn't prevent fire_laser)

  There is no content for this class



  Topic: `avr/pcm/set_laser_on`

  Turns on laser (in blip mode - 0.1 second on every 0.5. sec)

  There is no content for this class



  Topic: `avr/pcm/set_servo_abs`

  This sets the absolute position of a specific servo. SERVOMIN 150 is closed, and SERVOMAX 425 is open. We need to send a High and Low byte due to limitations of the API

  - `"servo"` (`int`):
      ID of the servo to set the percent as an `int`. This is 0-indexed.
  - `"absolute"` (`int`):
      Absolute position between SERVOMIN 150 and SERVOMAX 425



  Topic: `avr/pcm/set_servo_max`

  This sets the maximum pulse width of a specific servo.

  - `"servo"` (`int`):
      ID of the servo to set the maximum pulse width as an `int`. This is 0-indexed.
  - `"max_pulse"` (`int`):
      A `int` between 0 and 1000.



  Topic: `avr/pcm/set_servo_min`

  This sets the minimum pulse width of a specific servo.

  - `"servo"` (`int`):
      ID of the servo to set the minimum pulse width as an `int`. This is 0-indexed.
  - `"min_pulse"` (`int`):
      A `int` between 0 and 1000.



  Topic: `avr/pcm/set_servo_open_close`

  This opens or closes a specific servo.

  - `"servo"` (`int`):
      ID of the servo to open or close as an `int`. This is 0-indexed.
  - `"action"` (`Literal["open", "close"]`):
      Either the literal string "open" or "close".



  Topic: `avr/pcm/set_servo_pct`

  This sets the percentage of a specific servo. 0 is closed, and 100 is open.

  - `"servo"` (`int`):
      ID of the servo to set the percent as an `int`. This is 0-indexed.
  - `"percent"` (`int`):
      A `int` between 0 and 100.



  Topic: `avr/pcm/set_temp_color`

  This sets the color of the LED strip on the PCC temporarily

  - `"wrgb"` (`Tuple[int, int, int, int]`):
      A list of 4 `int`s between 0 and 255 to set the base color of the LEDs. This is in order of White, Red, Green, Blue. Example: [0, 0, 255, 0] would be Green.
  - `"time"` (`float`):
      Optional `float` for the number of seconds the color should be set for. Default is 0.5.



  Topic: `avr/status/light/apriltags`

  There is no content for this class



  Topic: `avr/status/light/fcm`

  There is no content for this class



  Topic: `avr/status/light/pcm`

  There is no content for this class



  Topic: `avr/status/light/thermal`

  There is no content for this class



  Topic: `avr/status/light/vio`

  There is no content for this class



  Topic: `avr/thermal/reading`

  This publishes data from the thermal camera

  - `"data"` (`str`):
      The raw data from the thermal camera are integer values from an 8x8 grid of pixels. This data is then converted into a bytearray and base64 encoded. Any example of how to unpack this data:

      ```python
      import base64
      import json

      data = json.loads(payload)["data"]
      base64_decoded = data.encode("utf-8")
      as_bytes = base64.b64decode(base64_decoded)
      pixel_ints = list(bytearray(as_bytes))
      ```



  Topic: `avr/vio/confidence`

  This reports the tracking camera's confidence

  - `"tracker"` (`float`):
      Number between 0 and 100 of tracking confidence



  Topic: `avr/vio/heading`

  This reports the measued heading of the drone from the tracking camera.

  - `"degrees"` (`float`):
      Heading in degrees



  Topic: `avr/vio/orientation/eul`

  This reports the measued attitude of the drone from the tracking camera.

  - `"psi"` (`float`):
      Roll in radians
  - `"theta"` (`float`):
      Pitch in radians
  - `"phi"` (`float`):
      Yaw in radians



  Topic: `avr/vio/orientation/quat`

  This reports the measued attitude of the drone from the tracking camera.

  - `"w"` (`float`):
      Quaternion w value
  - `"x"` (`float`):
      Quaternion x value
  - `"y"` (`float`):
      Quaternion y value
  - `"z"` (`float`):
      Quaternion z value



  Topic: `avr/vio/position/ned`

  This reports the measured position of the drone in local coordinates from the tracking camera.

  - `"n"` (`float`):
      X position in a local North/East/Down coordinate system in meters
  - `"e"` (`float`):
      Y position in a local North/East/Down coordinate system in meters
  - `"d"` (`float`):
      Z position in a local North/East/Down coordinate system in meters



  Topic: `avr/vio/resync`

  This reports significant position differences from the tracking camera, and detected AprilTags at known positions.

  - `"n"` (`float`):
      X position difference in a local North/East/Down coordinate system in meters
  - `"e"` (`float`):
      Y position difference in a local North/East/Down coordinate system in meters
  - `"d"` (`float`):
      Z position difference in a local North/East/Down coordinate system in meters
  - `"heading"` (`float`):
      Heading difference in degrees



  Topic: `avr/vio/velocity/ned`

  This reports the measued velocity vectors of the drone from the tracking camera.

  - `"n"` (`float`):
      X velocity in a local North/East/Down coordinate system in meters per second
  - `"e"` (`float`):
      Y velocity in a local North/East/Down coordinate system in meters per second
  - `"d"` (`float`):
      Z velocity in a local North/East/Down coordinate system in meters per second


pkgId: 570e99b9c5f8759576e1f6e9a6889da00319f4d17b88b307d604123bc8a81a24
name: python-bellande-node-importance
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Robots Limit
url: https://github.com/Robotics-Sensors/bellande_node_importance
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bellande-node-importance-0.1.0-1.src.rpm
checksum_type: sha256
description:
  - [![Organization Website](https://img.shields.io/badge/Explore%20Our-Website-0099cc?style=for-the-badge)](https://robotics-sensors.github.io)


  - [![Organization Github ](https://img.shields.io/badge/Explore%20Our-Github-0099cc?style=for-the-badge)](https://github.com/Robotics-Sensors)


  - **Ronaldson Bellande**


  - [![Bellande Node Importance Models & Executables ](https://img.shields.io/badge/Bellande%20Node%20Importance-Models/Executables-0099cc?style=for-the-badge)](https://github.com/Artificial-Intelligence-Computer-Vision/bellande_node_importance_models_executables)


  ```















  url: https://bellande-robotics-sensors-research-innovation-center.org

  endpoint_path:
      bellande_node_importance: /api/Bellande_Node_Importance/node_importance

  Bellande_Framework_Access_Key: bellande_web_api_opensource
  ```


  ```
  {
    "license": [
      "Copyright (C) 2024 Bellande Robotics Sensors Research Innovation Center, Ronaldson Bellande",
      "This program is free software: you can redistribute it and/or modify",
      "it under the terms of the GNU General Public License as published by",
      "the Free Software Foundation, either version 3 of the License, or",
      "(at your option) any later version.",
      "",
      "This program is distributed in the hope that it will be useful,",
      "but WITHOUT ANY WARRANTY; without even the implied warranty of",
      "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the",
      "GNU General Public License for more details.",
      "",
      "You should have received a copy of the GNU General Public License",
      "along with this program.  If not, see <https://www.gnu.org/licenses/>.",
      "GNU General Public License v3.0 or later"
    ],
    "url": "https://bellande-robotics-sensors-research-innovation-center.org",
    "endpoint_path": {
      "bellande_node_importance": "/api/Bellande_Node_Importance/node_importance"
    },
    "Bellande_Framework_Access_Key": "bellande_web_api_opensource"
  }
  ```


  ```
  {
      "node": {
          "coords": [5.0, 5.0, 5.0],
          "segment": 1
      },
      "nodes": [
          {"coords": [4.0, 4.0, 4.0], "segment": 1},
          {"coords": [6.0, 6.0, 6.0], "segment": 1}
      ],
      "important_nodes": {
          "1": [{"coords": [4.0, 4.0, 4.0], "segment": 1}],
          "2": [{"coords": [15.0, 15.0, 15.0], "segment": 2}]
      },
      "adjacent_segments": {
          "1": [2],
          "2": [1]
      },
      "grid_steps": [10.0, 10.0, 10.0],
      "min_segment_coverage": 0.5,
      "auth": {
          "authorization_key": "bellande_web_api_opensource"
      }
  }
  ```


  - [![Website API Testing](https://img.shields.io/badge/Bellande%20API-Testing-0099cc?style=for-the-badge)](https://bellande-robotics-sensors-research-innovation-center.org/api/bellande_node_importance_experiment)


  ```
  curl -X 'POST' \
    'https://bellande-robotics-sensors-research-innovation-center.org/api/Bellande_Node_Importance/node_importance' \
    -H 'accept: application/json' \
    -H 'Content-Type: application/json' \
    -d '{
      "node": {
          "coords": [5.0, 5.0, 5.0],
          "segment": 1
      },
      "nodes": [
          {"coords": [4.0, 4.0, 4.0], "segment": 1},
          {"coords": [6.0, 6.0, 6.0], "segment": 1}
      ],
      "important_nodes": {
          "1": [{"coords": [4.0, 4.0, 4.0], "segment": 1}],
          "2": [{"coords": [15.0, 15.0, 15.0], "segment": 2}]
      },
      "adjacent_segments": {
          "1": [2],
          "2": [1]
      },
      "grid_steps": [10.0, 10.0, 10.0],
      "min_segment_coverage": 0.5,
      "auth": {
          "authorization_key": "bellande_web_api_opensource"
      }
  }'
  ```


  - https://pypi.org/project/bellande_node_importance


  - `$ pip install bellande_node_importance`


  ```
  bellande_node_importance_api \
    --node '{"coords": [5.0, 5.0, 5.0], "segment": 1}' \
    --nodes '[{"coords": [4.0, 4.0, 4.0], "segment": 1}, {"coords": [6.0, 6.0, 6.0], "segment": 1}]' \
    --important-nodes '{"1": [{"coords": [4.0, 4.0, 4.0], "segment": 1}], "2": [{"coords": [15.0, 15.0, 15.0], "segment": 2}]}' \
    --adjacent-segments '{"1": [2], "2": [1]}' \
    --grid-steps '[10.0, 10.0, 10.0]' \
    --min-segment-coverage 0.5
  ```


  - `$ pip install --upgrade bellande_node_importance`

  ```
  Name: bellande_node_importance
  Summary: Determines node importance in n-dimensional space based on coverage and connectivity
  Home-page: github.com/RonaldsonBellande/bellande_node_importance
  Author: Ronaldson Bellande
  Author-email: ronaldsonbellande@gmail.com
  License: GNU General Public License v3.0
  ```


  ```
  Coming Soon
  ```


  - [![Preprint](https://img.shields.io/badge/Preprint-Bellande%20Node%20Importance-0099cc?style=for-the-badge)](https://dapp.orvium.io/deposits/6650ccb8afb407dc8beb0ff2/view)


  This Algorithm or Models is distributed under the [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/), see [LICENSE](https://github.com/RonaldsonBellande/bellande_node_importance/blob/main/LICENSE) and [NOTICE](https://github.com/RonaldsonBellande/bellande_node_importance/blob/main/LICENSE) for more information.


pkgId: 8ac994587422d1e9e4f85744837a558a58e6cecd883d494e330fc4943a7def79
name: python-bellatrex
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: A toolbox for Building Explanations through a LocaLly AccuraTe Rule EXtractor
url: https://github.com/Klest94/Bellatrex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bellatrex-0.2.3-1.src.rpm
checksum_type: sha256
description:
  <a name="logo-anchor"></a>
  <p align="center">
  <img src="https://github.com/Klest94/Bellatrex/blob/main-dev/app/bellatrex-logo.png?raw=true" alt="Bellatrex Logo" width="60%"/>
  </p>



  Random Forest models can be difficult to interpret, and Bellatrex addresses this challenge by generating explanations that are easy to understand, and by providing insights into how the model arrived at its predictions. Bellatrex does so by Building Explanations through a LocalLy AccuraTe Rule EXtractor (hence the name: Bellatrex) for a given test instance, by extracting only a few, diverse rules. See [the published paper](https://ieeexplore.ieee.org/abstract/document/10105927) for more details. The code for reproducing its results is available in a different [GitHub branch](https://github.com/Klest94/Bellatrex/tree/archive/reproduce-Dedja2023).

  To illustrate how Bellatrex works, let's consider an example: when a user provides a test instance to Bellatrex, the tool begins by 1) pre-selecting a subset of the rules used to make the prediction; it then creates 2) a vector representation of such rules and 3) projects them to a low-dimensional space; Bellatrex then 4) clusters such representations to pick a rule from each cluster to explain the instance prediction. One rule per cluster is shown to the end user through visually appealing plots, and the tool's GUI allows users to explore similar rules to those extracted.

  <table>
    <tr>
      <td align="center">
        <img src="https://github.com/Klest94/Bellatrex/blob/main-dev/app/illustration-Bellatrex.png?raw=true" alt="Bellatrex image" width="90%"/>
      </td>
    </tr>
    <tr>
      <td align="left">
        <em>Overview of Bellatrex, starting from top left, proceeding clockwise, we reach the output with related explanations on the bottom left. </em>
      </td>
    </tr>
  </table>


  Another strength of Bellatrex lies in its ability to handle several prediction tasks within `scikit-learn` implementations of Random Forests. For instance, Bellatrex can generate explanations for binary classification and multi-label predictions  tasks with `RandomForestClassifier`, as well as single- or multi-output regression tasks with `RandomForestRegressor`. Moreover, Bellatrex is compatible with scikit-survival's `RandomSurvivalForest`, allowing it to generate explanations for time-to-event predictions in the presence of right-censored data.


  This repository contains:
  - instructions to run Bellatrex on your machine
  - an overview of the datasets used to test the effectiveness of the method
  - access to such datasets, as they appear after the pre-processing step.



  To install the standard version of Bellatrex, run:

  ```
  pip install bellatrex
  ```

  In case the previous step does not work, then the ``pip`` distribution is not working as expected so please [contact us](https://mail.google.com/mail/u/0/?fs=1&tf=cm&source=mailto&to=daneel.olivaw94@gmail.com), and in the meantime try with a manual [clone](https://github.com/Klest94/Bellatrex) from the repository.




  For an enhanced user experience that includes interactive plots, you can etiher  pip install the following additional packages:
  ```
  pip install dearpygui==1.6.2
  pip install dearpygui-ext==0.9.5
  ```
  Or install everything at once with:

  ```
  pip install bellatrex[gui]
  ```


  **Note:** When running Bellatrex with the GUI for multiple test samples, the program will generate an interactive window. The process may take a couple of seconds, and the the user has to click at least once within the generated window in order to activate the interactive mode. Once this is done, the user can explore the generated rules by clicking on the corresponding representation. To show the Bellatrex explanation for the next sample, close the interactive window and wait until Bellatrex generates the explanation for the new sample.



  If you have downloaded the content of this folder and installed the packages successfully, you can dive into the [`tutorial.ipynb`](https://github.com/Klest94/Bellatrex/blob/main-dev/tutorial.ipynb) code and try Bellatrex yourself.


pkgId: 631ae66f41758c2fe13e27074c2b18d1f9de2636da4eff13765daa78cad9dfbe
name: python-bellows
arch: src
version: 0.40.6
epoch: 0
release: 1
summary: Library implementing EZSP
url: https://pypi.org/project/bellows/
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bellows-0.40.6-1.src.rpm
checksum_type: sha256
description:
  [![Build](https://github.com/zigpy/bellows/workflows/CI/badge.svg?branch=dev)](https://github.com/zigpy/bellows/workflows/CI/badge.svg?branch=dev)
  [![Coverage Status](https://codecov.io/gh/zigpy/bellows/branch/dev/graph/badge.svg?token=Y1994N9D74)](https://codecov.io/gh/zigpy/bellows)

  `bellows` is a Python 3 library implementation for the [zigpy](https://github.com/zigpy/zigpy) project to add Zigbee radio support for Silicon Labs EM35x ("Ember") and EFR32 ("Mighty Gecko") based Zigbee coordinator devices using the EZSP (EmberZNet Serial Protocol) interface.

  The project can be used as a stand-alone library, however, the main goal of this project is to add native support for EmberZNet Zigbee radio based USB stick devices (a.k.a. "Ember" and "Mighty Gecko" based adapters/dongles/modules) to Home Assistant's built-in ZHA (Zigbee Home Automation) integration component, allowing Home Assistant with such hardware to nativly support direct control of compatible Zigbee devices, such as; Philips HUE, GE, Ledvance, Osram Lightify, Xiaomi/Aqara, IKEA Tradfri, Samsung SmartThings, and many more.

  - https://www.home-assistant.io/integrations/zha/

  bellows interacts with the Zigbee Network Coprocessor (NCP) with EmberZNet PRO Zigbee coordinator firmware using the EZSP protocol serial interface APIs via via UART for Silicon Labs EM35x and EFR32 Zigbee radio module/chips hardware. The library currently supports the Silicon Labs EZSP (EmberZNet Serial Protocol) API versions v4/v5/v6/v7/v8 for Silabs older EM35x "Ember" and their newer EFR32 "Mighty Gecko" SoCs using ASH protocols over a serial interface.



  EmberZNet based Zigbee radios using the EZSP protocol (via the [bellows](https://github.com/zigpy/bellows) library for zigpy)
   - [Tube's Zigbee Gateways (Silabs EFR32 variant)](https://github.com/tube0013/tube_gateways) Note! ESP32 based Ethernet bridge available as pre-assembed or as a DIY project.
   - [ITEAD Sonoff ZBBridge](https://www.itead.cc/smart-home/sonoff-zbbridge.html) (**Note! WiFi-based bridges are not recommended for ZHA with EZSP radios.** Also, this first have to be flashed with [Tasmota firmware and EmberZNet firmware](https://www.digiblur.com/2020/07/how-to-use-sonoff-zigbee-bridge-with.html))
   - ITead Zigbee 3.0 USB Dongle (EFR32MG21) Model 9888010100045 Note! Currently not recommended due to stability issues.
   - [Nortek GoControl QuickStick Combo Model HUSBZB-1 (Z-Wave & Zigbee Ember 3581 USB Adapter)](https://www.nortekcontrol.com/products/2gig/husbzb-1-gocontrol-quickstick-combo/) (Note! Not a must but recommend [upgrade the EmberZNet NCP application firmware](https://github.com/walthowd/husbzb-firmware))
   - [Elelabs Zigbee USB Adapter](https://elelabs.com/products/elelabs_usb_adapter.html) (Note! Not a must but recommend [upgrade the EmberZNet NCP application firmware](https://github.com/Elelabs/elelabs-zigbee-ezsp-utility))
   - [Elelabs Zigbee Raspberry Pi Shield](https://elelabs.com/products/elelabs_zigbee_shield.html) (Note! Not a must but recommend [upgrade the EmberZNet NCP application firmware](https://github.com/Elelabs/elelabs-zigbee-ezsp-utility))
   - [DEFARO SprutStick Pro (also known as Defaro SprutStick ZigBee 2 Pro)](https://defaro.ru/index.php/product/89-controllers/257-sprutstick-pro)
   - Telegesis ETRX357USB/ETRX357USB-LRS/TRX357USB-LRS+8M (Note! This first have to be [flashed with other EmberZNet firmware](https://github.com/walthowd/husbzb-firmware))
   - [IKEA Billy EZSP - DIY ICC-1 / ICC-A-1 module from IKEA TRÅDFRI devices](https://github.com/MattWestb/IKEA-TRADFRI-ICC-A-1-Module). (Note! This first have to be hacked and flashed with other EmberZNet firmware)
   - [Tuya TYGWZ01 and rebranded Lidl Silvercrest Smart Home Gateway](https://paulbanks.org/projects/lidl-zigbee/) (Note! This first have to be hacked and flashed with other EmberZNet firmware)
   - Bitron Video/Smabit BV AV2010/10 USB-Stick (a.k.a. Telekom Magenta Stick) based on Silicon Labs Ember 3587
   - [EByte E180-Z120B SMD Module and EByte E180-Z120B-TB Evaluation Board](https://www.cnx-software.com/2020/04/27/ebyte-e180-zg120b-tb-zigbee-3-0-evaluation-board-features-silicon-labs-efr32mg1b-zigbee-thread-soc/) (Note! This first have to be [hacked and flashed with other EmberZNet firmware](https://github.com/zha-ng/EZSP-Firmware/tree/master/EByte-E180-Z120B))



  zigpy requires a robust connection between the zigpy radio library and the serial port of the Zigbee radio. With solutions such as _ITEAD Sonoff ZBBridge_ or a Ser2Net serial proxy connection over a WiFi network it is expected to see `NCP entered failed state. Requesting APP controller restart` in the logs. This is a normal part of the operation and indicates there was a drop in communication which caused packet loss to occurred between the zigpy radio library and the Zigbee radio. The use of serial network proxies/bridges/servers over WiFi is therefore not recommended when wanting a stable Zigbee environment with zigpy.



  bellows requires that the Zigbee adapter/board/module is pre-flashed/flashed with compatible firmware with EmberZNet PRO Zigbee Stack that uses the standard Silicon Labs EZSP (EmberZNet Serial Protocol) APIs for ASH protocol over a serial interface.

  Silabs used to provide two main NCP images pre-build with firmware for EM35x, one image supported hardware flow control with a baud rate of 115200 and the other image supported software flow control with a rate of 57600.

  Silicon Labs no longer provide pre-build firmware images, so now you have to build and compile firmware with their Simplicity Studio SDK for EmberZNet PRO Zigbee Protocol Stack Software. Simplicity Studio is a free download but building and compiling EmberZNet PRO Zigbee firmware images required that you have the serialnumber of an official Zigbee devkit registered to your Silicon Labs user account.


  -  For firmware requirements and recommended firmware see the [Zigpy Wiki](https://github.com/zigpy/zigpy/wiki/Coordinator-Firmware-Updates).
  -  [Elelabs EZSP Firmware Update Utility (should work with most EFR32 based Zigbee coordinators with Silicon Labs standard bootloader)](https://github.com/Elelabs/elelabs-zigbee-ezsp-utility).
  -  [Docker firmware updater image by walthowd upgrading Nortek/GoControl/Linear HUSBZB-1 and Telegesis ETRX357 Zigbee coordinator adapters](https://github.com/walthowd/husbzb-firmware).



  Silicon Labs does not currently have a consolidated list of changes by EmberZNet SDK or EZSP protocol version. The EZSP additions, changes and deletions have only ever been listed in the "Zigbee EmberZNet Release Notes" (EmberZNet SDK) under the "New items" section as well as the matching UG100 EZSP Reference Guide included with each EmberZNet SDK release.

  The largest change was between EZSP v4 (first added in EmberZNet 4.7.2 SDK) and EZSP v5 that was added in EmberZNet 5.9.0 SDK which requires the Legacy Frame ID 0xFF. The change from EZSP v5 to EZSP v6 was done in EmberZNet 6.0.0 SDK. The change from EZSP v6 to EZSP v7 was in EmberZNet 6.4.0 SDK. EmberZNet 6.7.0 SDK added EZSP v8 (and Secure EZSP Protocol Version 2).

  Perhaps more important to know today is that EZSP v5, v6 and v7 (EmberZNet 6.6.x.x) use the same framing format, but EmberZNet 6.7.x.x/EZSP v8 introduced new framing format and expanded command id field from 8 bits to 16 bits and is and is not backward compatible.



  This project is in early stages, so it is likely that APIs will change.

  Currently implemented features are:

   * EZSP UART Gateway Protocol
   * EZSP application protocol
   * CLI wrapping basic ZigBee network operations (eg, scanning and forming a
     network)
   * ZDO functionality (with CLI)
   * ZCL functionality (with CLI)
   * An application framework with device state persistence

  An example use of the CLI:

  ```
  $ export EZSP_DEVICE=/dev/ttyUSB1
  $ bellows devices
  Device:
    NWK: 0x1ee4
    IEEE: 00:0d:6f:00:05:7d:2d:34
    Endpoints:
      1: profile=0x104, device_type=None, clusters=[0, 1, 3, 32, 1026, 1280, 2821]
      2: profile=0xc2df, device_type=None, clusters=[0, 1, 3, 2821]
  Device:
    NWK: 0x64a6
    IEEE: d0:52:a8:00:e0:be:00:05
    Endpoints:
      1: profile=0x104, device_type=None, clusters=[0]
      2: profile=0xfc01, device_type=None, clusters=[]
  $ bellows zdo 00:0d:6f:00:05:7d:2d:34 get_endpoint 1
  <SimpleDescriptor endpoint=1 profile=260 device_type=1026 device_version=0 input_clusters=[0, 1, 3, 32, 1026, 1280, 2821] output_clusters=[25]>
  $ bellows zcl 00:0d:6f:00:05:7d:2d:34 1 1026 read_attribute 0
  0=1806
  ```



  - To configure use of a locally connected USB adapter device path its serial interface by specifying the TTY (serial com) port, example : `/dev/ttyUSB1`
    - It is worth noting that while a few adapters have an embedded USB core (like EM3588 based devices) which will likely work with any baud rate speed, most USB sticks/dongles have an external USB to serial converter/bridge chip (eg Silabs CP210x, FTDI FT23x, or WCH CH340) which require you to set a specific baud rate. It should as such be noted that some NCP firmware images require the use of 115200 baud rate speed while others use 57600 baud rate speed, also, some use no flow control (NSW flow control) while others require use of either software flow control (SW or XON/XOFF flow control) or hardware flow control (HW or RTS/CTS flow control).
    - If a USB radio is not recognized, it might be necessary to make the serial adapters device id known to driver, e.g. [CP210x driver by Silicon Labs](https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers).
    - Find the device id (as listed by the command `lsusb`). For the Bitron Video/Smabit BV AV2010/10 that might for example be *10c4 8b34*.
    - Unplug the device.
    - Enter the following commands (replace the example id *10c4 8b34* with the real one listed by `lsusb` on your system):
    ```
    sudo -s
    modprobe cp210x
    echo 10c4 8b34 > /sys/bus/usb-serial/drivers/cp210x/new_id
    ```
    - Plug in the dongle. It should now be recognized properly as ttyUSBx.


  - To configure the use of a remote Ethernet or WiFi based network connected bridge/proxy Zigbee adapter, like exammple Sonoff ZBBridge or ZiGate WiFi Gateway, enter `socket://<adapter-IP>:<port>` and use 115200 baud rate as the port speed.



  Warning! Please note that this is a highly experimental feature! Theoretically this allows backing up and restoring NCP state between the hardware version.

  NVRAM backup can be performed to migrate between different radio hardware as long as they **based on the same chip**. Anything else will not work. If this is done between different hardwares, the EUI64 is going to be different on the new hardware meaning the binding tables on all the devices are going to be wrong.

  ```console
  To export TC config, see bellows backup --help usually it is just bellows backup > your-backup-file.txt.
  The backup contains your network key, so you probably should keep that file secure.
  To import, see bellows restore --backup-file your-backup-file.txt
  ```

  Note! The restoration does not restore NCP children and relies on children just to find a new parent. You either have to reconfigure all the devices (recommended so the bindings are updated) or alternatively you could override the EUI64 on the new hardware, essentially producing a clone. Be very careful if you decide to go with the latter route. You can change the EUI64 only once and once you set it it is impossible to change it without a specialized hardware (SWD programmer).

  Tested migrations:

   - To-Do



  Testing a new release of the bellows library before it is released in Home Assistant.

  If you are using Supervised Home Assistant (formerly known as the Hassio/Hass.io distro):
  - Add https://github.com/home-assistant/hassio-addons-development as "add-on" repository
  - Install "Custom deps deployment" addon
  - Update config like:
    ```
    pypi:
      - bellows==0.16.0
    apk: []
    ```
    where 0.16.0 is the new version
  - Start the addon

  If you are instead using some custom python installation of Home Assistant then do this:
  - Activate your python virtual env
  - Update package with ``pip``
    ```
    pip install bellows==0.16.0



  New packages of tagged versions are also released via the "bellows" project on PyPI
    - https://pypi.org/project/bellows/

  Older packages of tagged versions are still available on the "bellows-homeassistant" project on PyPI
    - https://pypi.org/project/bellows-homeassistant/



   * EZSP UART Gateway Protocol Reference:
     https://www.silabs.com/Support%20Documents/TechnicalDocs/UG101.pdf
   * EZSP Reference Guide:
     http://www.silabs.com/Support%20Documents/TechnicalDocs/UG100-EZSPReferenceGuide.pdf
   * EZSP UART Host Interfacing Reference Guide: https://www.silabs.com/documents/public/application-notes/an706-ezsp-uart-host-interfacing-guide.pdf
    * Silicon Labs forum https://www.silabs.com/community/wireless/zigbee-and-thread/forum



  If you are looking to make a contribution to this project we suggest that you follow the steps in these guides:
  - https://github.com/firstcontributions/first-contributions/blob/master/README.md
  - https://github.com/firstcontributions/first-contributions/blob/master/github-desktop-tutorial.md

  Some developers might also be interested in receiving donations in the form of hardware such as Zigbee modules or devices, and even if such donations are most often donated with no strings attached it could in many cases help the developers motivation and indirect improve the development of this project.


pkgId: a16ed4fab11eb4935d1fab05a48376b11f6f7851b120fde864ecc96c7355202a
name: python-belt-nlp
arch: src
version: 1.1.0
epoch: 0
release: 1
url: https://github.com/mim-solutions/bert_for_longer_texts
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belt-nlp-1.1.0-1.src.rpm
checksum_type: sha256
summary:
  BELT (BERT For Longer Texts). BERT-based text classification model for processing texts longer than 512 tokens.

description:
  🚀**New in version 1.1.0: support for multilabel and regression**. See [the examples](#examples)🚀





  The BERT model can process texts of the maximal length of 512 tokens (roughly speaking tokens are equivalent to words). It is a consequence of the model architecture and cannot be directly adjusted. Discussion of this issue can be found [here](https://github.com/google-research/bert/issues/27). Method to overcome this issue was proposed by Devlin (one of the authors of BERT) in the previously mentioned discussion: [comment](https://github.com/google-research/bert/issues/27#issuecomment-435265194). The main goal of our project is to implement this method and allow the BERT model to process longer texts during prediction and fine-tuning. We dub this approach BELT (**BE**RT For **L**onger **T**exts).

  More technical details are described in the [documentation](https://mim-solutions.github.io/bert_for_longer_texts/). We also prepared the comprehensive blog post: [part 1](https://www.mim.ai/fine-tuning-bert-model-for-arbitrarily-long-texts-part-1/), [part 2](https://www.mim.ai/fine-tuning-bert-model-for-arbitrarily-long-texts-part-2/).



  The limitations of the BERT model to the 512 tokens come from the very beginning of the transformers models. Indeed, the attention mechanism, invented in the groundbreaking 2017 paper [Attention is all you need](https://arxiv.org/abs/1706.03762), scales quadratically with the sequence length. Unlike RNN or CNN models, which can process sequences of arbitrary length, transformers with the full attention (like BERT) are infeasible (or very expensive) to process long sequences.
  To overcome the issue, alternative approaches with sparse attention mechanisms were proposed in 2020: [BigBird](https://arxiv.org/abs/2007.14062) and [Longformer](https://arxiv.org/abs/2004.05150).



  Let us now clarify the key differences between the BELT approach to fine-tuning and the sparse attention models BigBird and Longformer:
  - The main difference is that BigBird and Longformers are not modified BERTs. They are models with different architectures. Hence, they need to be pre-trained from scratch or downloaded.
  - This leads to the main advantage of the BELT approach - it uses any pre-trained BERT or RoBERTa models. A quick look at the HuggingFace Hub confirms that there are about 100 times more resources for [BERT](https://huggingface.co/models?other=bert) than for [Longformer](https://huggingface.co/models?other=longformer). It might be easier to find the one appropriate for the specific task or language.
  - On the other hand, we have not done any benchmark tests yet. We believe that the comparison of the BELT approach with the models with sparse attention might be very instructive. Some work in this direction was done in the 2022 paper [Extend and Explain: Interpreting Very Long Language Models](https://proceedings.mlr.press/v193/stremmel22a/stremmel22a.pdf). The authors cited our implementation under the former name `roberta_for_longer_texts`. We encourage more research in this direction.



  The project requires Python 3.9+ to run. We recommend training the models on the GPU. Hence, it is necessary to install `torch` version compatible with the machine. The version of the driver depends on the machine - first, check the version of GPU drivers by the command `nvidia-smi` and choose the newest version compatible with these drivers according to [this table](https://docs.nvidia.com/cuda/cuda-toolkit-release-notes/index.html) (e.g.: 11.1). Then we install `torch` to get the compatible build. [Here](https://pytorch.org/get-started/previous-versions/), we find which torch version is compatible with the CUDA version on our machine.

  Another option is to use the CPU-only version of torch:
  ```
  pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
  ```
  Next, we recommend installing via pip:
  ```
  pip3 install belt-nlp
  ```

  If you want to clone the repo in order to run tests or notebooks, you can use the `requirements.txt` file.



  Two main classes are implemented:
  - `BertClassifierTruncated` - base binary classification model, longer texts are truncated to 512 tokens
  - `BertClassifierWithPooling` - extended model for longer texts (more details in the [documentation](https://mim-solutions.github.io/bert_for_longer_texts/))



  The main methods are:
  - `fit` - fine-tune the model to the training set, use the list of raw texts and labels
  - `predict_classes` - calculate the list of classifications for the given list of raw texts. The model must be fine-tuned before that.
  - `predict_scores` - calculate the list of probabilities for the given list of raw texts. The model must be fine-tuned before that.



  As a default, the standard English `bert-base-uncased` model is used as a pre-trained model. However, it is possible to use any Bert or Roberta model. To do this, use the parameter `pretrained_model_name_or_path`.
  It can be either:
  - a string with the name of a pre-trained model configuration to download from huggingface library, e.g.: `roberta-base`.
  - a path to a directory with the downloaded model, e.g.: `./my_model_directory/`.


  To make sure everything works properly, run the command ```pytest tests -rA```. As a default, during tests, models are trained on small samples on the CPU.



  All examples use public datasets from huggingface hub.


  - [standard approach](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/notebooks/binary_classification/base.ipynb)
  - [belt](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/notebooks/binary_classification/belt.ipynb)


  - [standard approach](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/notebooks/multiclass/base.ipynb)
  - [belt](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/notebooks/multiclass/belt.ipynb)
  - **Notice the effectiveness of the BELT approach here: the test accuracy increased by 10%.**


  - [standard approach](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/notebooks/regression/base.ipynb)
  - [belt](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/notebooks/regression/belt.ipynb)


  The project was created at [MIM AI](https://www.mim.ai/) by:
  - [Michał Brzozowski](https://github.com/MichalBrzozowski91)
  - [Marek Wachnicki](https://github.com/mwachnicki)

  If you want to contribute to the library, see the [contributing info](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/CONTRIBUTING.md).



  See [CHANGELOG.md](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/CHANGELOG.md).


  See the [LICENSE](https://github.com/mim-solutions/bert_for_longer_texts/blob/main/LICENSE.txt) file for license rights and limitations (MIT).



  File `requirements.txt` can be updated using the command:
  ```
  bash pip-freeze-without-torch.sh > requirements.txt
  ```
  This script saves all dependencies of the current active environment except `torch`.

  In order to add the next version of the package to pypi, do the following steps:
  - First, increment the package version in `pyproject.toml`.
  - Then build the new version: run `python3.9 -m build` from the main folder.
  - Finally, upload to pypi: `twine upload dist/*` (two newly created files).


pkgId: 5736d2777023f75994c873fce412d53ff727dd8b95ea369049a164cb28ca749e
name: python-belvo-python
arch: src
version: 0.39.1
epoch: 0
release: 1
summary: Belvo Python SDK
url: https://github.com/belvo-finance/belvo-python
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belvo-python-0.39.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Belvo Python SDK</h1>
  <p align="center">
      <a href="https://pypi.org/project/belvo-python/"><img alt="PyPI" src="https://img.shields.io/pypi/v/belvo-python?style=for-the-badge"></a>
      <a href="https://pypistats.org/packages/belvo-python"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/belvo-python?style=for-the-badge"></a>
      <a href="https://app.circleci.com/pipelines/github/belvo-finance/belvo-python"><img alt="CircleCI (.com)" src="https://img.shields.io/travis/com/belvo-finance/belvo-python/master?style=for-the-badge"></a>
      <a href="https://coveralls.io/github/belvo-finance/belvo-python"><img alt="Coveralls github" src="https://img.shields.io/coveralls/github/belvo-finance/belvo-python?style=for-the-badge"></a>
      <a href="https://github.com/psf/black"><img alt="Coveralls github" src="https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge"></a>
  </p>


  Please be advised that this SDK has transitioned to limited maintenance mode and will no longer receive updates for new features. Essential security updates will continue to be provided until **December 31, 2023**.

  After this date, the SDK will be archived and no further updates will be released. While you are welcome to continue using the code please note that you will be solely responsible for managing and implementing any required security patches or updates.


  How to use `belvo-python`: https://belvo-finance.github.io/belvo-python/

  If you want to check the full documentation about Belvo API: https://developers.belvo.com

  Or if you want to more information about:
  * [Getting Belvo API keys](https://developers.belvo.com/docs/get-started-in-5-minutes#get-your-belvo-api-keys)
  * [Using Connect Widget](https://developers.belvo.com/docs/connect-widget)
  * [Testing in sandbox](https://developers.belvo.com/docs/test-in-sandbox)
  * [Using webhooks and recurrent links](https://developers.belvo.com/docs/webhooks)



  * Python 3.6+



  Install using `pip`:
  ```
  $ pip install belvo-python
  ```



  When your user successfully links their account using the [Connect Widget](https://developers.belvo.com/docs/connect-widget), your implemented callback funciton will return the `link_id` required to make further API to retrieve information.

  ```python

  from pprint import pprint

  from belvo.client import Client
  from belvo.enums import AccessMode


  client = Client("your-secret-key-id", "your-secret-key", "sandbox")


  link_id = result_from_callback_function.id


  client.Accounts.create(link=link_id)


  for account in client.Accounts.list(type="checking"):
      pprint(account)
  ```




  You can also manually create the link using the SDK. However, for security purposes, we highly recommend, that you use the [Connect Widget](https://developers.belvo.com/docs/connect-widget) to create the link and follow the **Usage (create link via widget)** example.


  ```python

  from pprint import pprint

  from belvo.client import Client
  from belvo.enums import AccessMode


  client = Client("your-secret-key-id", "your-secret-key", "sandbox")


  link = client.Links.create(
      institution="erebor_mx_retail",
      username="johndoe",
      password="supersecret",
      access_mode=AccessMode.SINGLE
  )


  client.Accounts.create(link=link["id"])


  for account in client.Accounts.list(type="checking"):
      pprint(account)
  ```



  By default, when you use our SDK, we automatically return the [error](https://developers.belvo.com/docs/integration-overview#error-handling). However, if you prefer to receive the exception, you need to set the `raise_exception` optional parameter to `True`.



  ```python
  from pprint import pprint
  from belvo.client import Client
  from belvo.enums import AccessMode
  from belvo.exceptions import RequestError


  client = Client("my-secret-key-id", "my-secret-key", "sandbox")

  try:
      
      link = client.Links.create(
          access_mode=AccessMode.SINGLE,
          institution="erebor_mx_retail",
          username="<username>",
          password="<pass>",
          raise_exception=True, # Set this optional paramter
      )
  except RequestError as e:
      
      pprint(e)
  else:
      
      pprint(link)

  ```



  To release a new version of the SDK to PyPI:
  - Create a new branch from master.
  - Use `make new-version major|minor|patch` to bump a new version.
  - Create a new pull request for the new version.
  - Once the new version is merged in `master`, create a `tag` matching the new version.


  **Anyone** can do something to make `belvo-python` better, so contributors are always welcome!
  If you wish to submit a pull request, please be sure check the items on this list:
  - [ ] Tests related to the changed code were executed
  - [ ] The source code has been coded following the OWASP security best practices (https://owasp.org/www-pdf-archive/OWASP_SCP_Quick_Reference_Guide_v2.pdf).
  - [ ] Commit message properly labeled
  - [ ] There is a ticket associated to each PR.

  For more details about contributing to this project, please take a look to our [guidelines](CONTRIBUTING.md).


pkgId: 9e67f36231f0f5a0ea23d7d8ece901524f558a1933640da0c0f1319cfce2b33d
name: python-belvys
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Package to fetch data through the REST API of energy portfolio management software "Belvis".
url: https://pypi.org/project/belvys/
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-belvys-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Belvys is a package to fetch data through the REST API of energy portfolio management software "Belvis".


pkgId: a1d57fa7c56e2b153690d61b05b06ac6f02c87b0253f49b8b0b339444de9458b
name: python-bemi-django
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Automatic data change tracking for Django
url: https://github.com/BemiHQ/bemi-django
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bemi-django-0.0.8-1.src.rpm
checksum_type: sha256
description:
   26          | todo  | CREATE    | {}                                                 | {"id": 26, "task": "Sleep", "is_completed": false}  | {"user_id": 187234, "endpoint": "/todo", "method": "POST", "SQL": "INSERT INTO ..."}      | 2023-12-11 17:09:09+00
   27          | todo  | CREATE    | {}                                                 | {"id": 27, "task": "Eat", "is_completed": false}    | {"user_id": 187234, "endpoint": "/todo", "method": "POST", "SQL": "INSERT INTO ..."}      | 2023-12-11 17:09:11+00
   28          | todo  | CREATE    | {}                                                 | {"id": 28, "task": "Repeat", "is_completed": false} | {"user_id": 187234, "endpoint": "/todo", "method": "POST", "SQL": "INSERT INTO ..."}      | 2023-12-11 17:09:13+00
   26          | todo  | UPDATE    | {"id": 26, "task": "Sleep", "is_completed": false} | {"id": 26, "task": "Sleep", "is_completed": true}   | {"user_id": 187234, "endpoint": "/todo/complete", "method": "PUT", "SQL": "UPDATE ..."}   | 2023-12-11 17:09:15+00
   27          | todo  | DELETE    | {"id": 27, "task": "Eat", "is_completed": false}   | {}                                                  | {"user_id": 187234, "endpoint": "/todo/27", "method": "DELETE", "SQL": "DELETE FROM ..."} | 2023-12-11 17:09:18+00
  ```
  Check out our [Django docs](https://docs.bemi.io/orms/django) for more details.

  Bemi is designed to be lightweight and secure. It takes a practical approach to achieving the benefits of [event sourcing](https://blog.bemi.io/rethinking-event-sourcing/) without requiring rearchitecting existing code, switching to highly specialized databases, or using unnecessary git-like abstractions on top of databases. We want your system to work the way it already does with your existing database to allow keeping things as simple as possible.
  Bemi plugs into both the database and application levels, ensuring 100% reliability and a comprehensive understanding of every change.
  On the database level, Bemi securely connects to PostgreSQL's [Write-Ahead Log](https://www.postgresql.org/docs/current/wal-intro.html) and implements [Change Data Capture](https://blog.bemi.io/cdc/). This allows tracking even the changes that get triggered via direct SQL.
  On the application level, this Python package automatically passes application context to the replication logs to enhance the low-level database changes. For example, information about a user who made a change, an API endpoint where the change was triggered, a worker name that automatically triggered database changes, etc.
  Bemi workers then stitch the low-level data with the application context and store this information in a structured easily queryable format, as depicted below:
  ![bemi-architechture](https://docs.bemi.io/img/architecture.png)
  The cloud solution includes worker ingesters, queues for fault tolerance, and a serverless PostgreSQL. If you are interested in running a self-hosted version yourself, see our [self-hosting docs](https://docs.bemi.io/self-hosting).

  Distributed under the terms of the [LGPL-3.0 License](LICENSE).
  If you need to modify and distribute the code, please release it to contribute back to the open-source community.


pkgId: 9f2306e3bd3df230460527474be1c0c9f08dd1ddc6fc6a15f109c4a9b01fd4ff
name: python-bempp-cl
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: The Bempp boundary element library
url: https://pypi.org/project/bempp-cl/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bempp-cl-0.3.2-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/bempp-cl/badge/?version=latest)](https://bempp-cl.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.02879/status.svg)](https://doi.org/10.21105/joss.02879)

  Bempp-cl is an open-source boundary element method library that can be used to assemble all the standard integral kernels for
  Laplace, Helmholtz, modified Helmholtz, and Maxwell problems. The library has a user-friendly Python interface that allows the
  user to use BEM to solve a variety of problems, including problems in electrostatics, acoustics and electromagnetics.

  Bempp-cl began life as BEM++, and was a Python library with a C++ computational core. The ++ slowly changed into pp as
  functionality gradually moved from C++ to Python with only a few core routines remaining in C++. Bempp-cl is the culmination
  of efforts to fully move to Python. It is an almost complete rewrite of Bempp: the C++ core has been replaced by highly SIMD
  optimised just-in-time compiled OpenCL kernels, or alternatively, by just-in-time compiled Numba routines, which are
  automatically used on systems that do not provide OpenCL drivers. User visible functionality is strictly separated from the
  implementation of computational routines, making it easy to add other discretisation technologies in the future (e.g. future
  support for SYCL-based heterogeneous compute devices).


  Bempp-cl can be installed from this repository by running:
  ```bash
  python setup.py install
  ```

  Full installation instuctions, including installation of dependencies, can be found at
  [bempp.com/installation.html](https://bempp.com/installation.html).


  Full documentation of Bempp can be found at [bempp.com/documentation](https://bempp.com/documentation/index.html)
  and in [the Bempp Handbook](https://bempp.com/handbook). Automatically generated documentation of the Python API
  can be found on [Read the Docs](https://bempp-cl.readthedocs.io/en/latest/).


  The functionality of the library can be tested by running:
  ```bash
  python -m pytest test/unit
  ```
  Larger validation tests that compare the output with the previous version of Bempp can be run with:
  ```bash
  python -m pytest test/validation
  ```


  Errors in the library should be added to the [GitHub issue tracker](https://github.com/bempp/bempp-cl/issues).

  Questions about the library and its use can be asked on the [Bempp Discourse](https://bempp.discourse.group).


  Bempp-cl is licensed under an MIT licence. Full text of the licence can be found [here](LICENSE.md).

rpm_license:
  Copyright 2019-2020 The Bempp Team (www.bempp.com)  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: abf92192f631f6affed4c2242159b8c59171d41a9ca9be7adba65dcc0a3bc33e
name: python-benGRN
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: benchmarking gene regulatory networks
url: https://pypi.org/project/benGRN/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benGRN-1.2.4-1.src.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/jkobject/benGRN/branch/main/graph/badge.svg?token=benGRN_token_here)](https://codecov.io/gh/jkobject/benGRN)
  [![CI](https://github.com/jkobject/benGRN/actions/workflows/main.yml/badge.svg)](https://github.com/jkobject/benGRN/actions/workflows/main.yml)
  [![PyPI version](https://badge.fury.io/py/benGRN.svg)](https://badge.fury.io/py/benGRN)
  [![Downloads](https://pepy.tech/badge/benGRN)](https://pepy.tech/project/benGRN)
  [![Downloads](https://pepy.tech/badge/benGRN/month)](https://pepy.tech/project/benGRN)
  [![Downloads](https://pepy.tech/badge/benGRN/week)](https://pepy.tech/project/benGRN)
  [![GitHub issues](https://img.shields.io/github/issues/jkobject/benGRN)](https://img.shields.io/github/issues/jkobject/benGRN)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![DOI](https://img.shields.io/badge/DOI-10.1101%2F2024.07.29.605556-blue)](https://doi.org/10.1101/2024.07.29.605556)

  Benchmark your gene regulatory networks inference algorithm (from scRNAseq or bulk RNAseq dataset) with BenGRN

  The package is supposed to work with [GRnnData](https://cantinilab.github.io/GRnnData/) and only uses biological ground truth datasets.

  It can run Genie3 & pyscenic on your data as a comparison

  It has 3 main different types of key ground truth data to compare your GRN to:

  - Mc Calla et al.'s ChIP+Perturb ground truth
  - omnipath's literature curated ground truth
  - genome wide perturb seq 's dataset

  You can find the documentation [here](https://www.jkobject.com/benGRN/)



  ```bash
  pip install bengrn
  ```



  ```bash
  git clone https://github.com/jkobject/benGRN.git
  pip install -e benGRN
  ```



  ```py
  from bengrn import BenGRN
  from bengrn import some_test_function


  grndata

  BenGRN(grndata).do_tests()

  some_test_function(grndata)
  ```

  see the notebooks in [docs](https://www.jkobject.com/benGRN/):

  1. [omnipath](https://www.jkobject.com/benGRN/notebooks/bench_omni_genie3)
  2. [genome wide perturb seq](https://www.jkobject.com/benGRN/notebooks/bench_perturbseq_genie3_transp/)
  3. [Mc Calla](https://www.jkobject.com/benGRN/notebooks/bench_sroy_genie3_transp/)



  Read the [CONTRIBUTING.md](CONTRIBUTING.md) file.

  Awesome Benchmark of Gene Regulatory Networks created by @jkobject


pkgId: 371023589010727d628a6f7d1392a5fb1a780fa530c9a40a81702fbdc73a33db
name: python-benatools
arch: src
version: 0.0.117
epoch: 0
release: 1
summary: Utilities package for XGBoost, CatBoost, LightGBM, Tensorflow and Pytorch
url: https://github.com/benayas1/benatools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benatools-0.0.117-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/benatools)](https://pepy.tech/project/benatools)
  [![Downloads](https://pepy.tech/badge/benatools/month)](https://pepy.tech/project/benatools/month)
  [![Documentation Status](https://readthedocs.org/projects/benatools/badge/?version=latest)](https://benatools.readthedocs.io/en/latest/?badge=latest)

  This is a "wrapper" library containing utilities and resources that can be used for many purposes.

  I keep including code and functionality to this library, so it is still in a very very very initial stage.


pkgId: b59666bb32dcfbecbedce0fc7417c5b71494e10234624ce2912feb7337d1d928
name: python-benchclients
arch: src
version: 2024.3.29.1
epoch: 0
release: 1
summary: Clients for the Conbench ecosystem
url: https://github.com/conbench/conbench/tree/main/benchclients
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchclients-2024.3.29.1-1.src.rpm
checksum_type: sha256
description:
  A simple, low-dependency Python library with clients for calling the Conbench API and
  potentially other APIs in the Conbench ecosystem



  The benchclients package can be installed [from PyPI](https://pypi.org/project/benchclients/)
  with

  ``` sh
  pip install benchclients
  ```

  or direct from GitHub with

  ``` sh
  pip install benchclients@git+https://github.com/conbench/conbench.git@main#subdirectory=benchclients/python
  ```

  or with your preferred environment management system. Package code should rarely change,
  and the number of dependencies should remain very minimal.



  The package is structured such that all users should need is client classes that it
  exposes. As of writing, there is only one such useful class: `benchclients.ConbenchClient`.
  However, clients for other APIs can easily be created by inheriting from the
  `benchclients.BaseAdapter` class, which defines core methods for making HTTP requests
  (e.g. `.get()`, `.post()`, etc.) set up to handle retries and logging and so on.





  Configuration and credentials for `ConbenchClient` can be handled by three environment
  variables set before class instantiation:

  - `CONBENCH_URL`: The URL of the Conbench server. Required.
  - `CONBENCH_EMAIL`: The email to use for Conbench login. Only required for GETting if the
  server is private.
  - `CONBENCH_PASSWORD`: The password to use for Conbench login. Only required for GETting
  if the server is private.

  Alternatively, you can instantiate the client with the `url`, `email`, and `password` keyword arguments - like:

  ``` python
  conbench = ConbenchClient(url="https://conbench.ursa.dev",
                            email="test@example.com",
                            password="xxxxxx"
                            )
  ```



  If environment variables are set before instantiation, or the keyword arguments are used, `ConbenchClient` will handle
  auth, so users can get right to making requests:

  ``` python
  import logging
  import os

  from benchclients import ConbenchClient, log


  os.environ["CONBENCH_URL"] = "https://conbench.ursa.dev"
  log.setLevel(logging.DEBUG)

  conbench = ConbenchClient()

  benchmark_result_id = "4e0e569d82724667b3e929dedb730edc"
  res = conbench.get(f"/benchmarks/{benchmark_result_id}")


  res






































  ```


pkgId: 369f787bdaebb478311cf019e56c1d2f15e1dac2ba7a4b8f05ad4e2b48d18b6d
name: python-benchling-api-client
arch: src
version: 2.0.342
epoch: 0
release: 1
summary: Autogenerated Python client from OpenAPI Python Client generator
url: https://pypi.org/project/benchling-api-client/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchling-api-client-2.0.342-1.src.rpm
checksum_type: sha256
description:
  A client generated from Benchling's OpenAPI definition files using openapi-python-client.

  Rather than using this package directly, we recommend using the
  [Benchling SDK](https://pypi.org/project/benchling-sdk/), which has extra scaffolding to make some endpoints
  easier to use and has been released to general availability.


pkgId: 3a3c74d3a0b05b480f04359eee121d36b93d176a1f7b62f9892a9951221a84a1
name: python-benchling-sdk
arch: src
version: 1.20
epoch: 0
release: 1
summary: SDK for interacting with the Benchling Platform.
url: https://pypi.org/project/benchling-sdk/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchling-sdk-1.20-1.src.rpm
checksum_type: sha256
description:
  A Python 3.8+ SDK for the [Benchling](https://www.benchling.com/) platform designed to provide typed, fluent
  interactions with [Benchling APIs](https://docs.benchling.com/reference).



  Install the dependency via [Poetry](https://python-poetry.org/) (if applicable):

  ```bash
  poetry add benchling-sdk
  ```

  Or [Pip](https://pypi.org/project/pip/):

  ```bash
  pip install benchling-sdk
  ```



  Documentation for the SDK is kept up-to-date at [docs.benchling.com](https://docs.benchling.com), and you can get started with
  it using this guide:
  [https://docs.benchling.com/docs/getting-started-with-the-sdk](https://docs.benchling.com/docs/getting-started-with-the-sdk).



  To report issues with using the SDK, contact [support@benchling.com](mailto:support@benchling.com).


pkgId: 644b4717ff57be6b4d6fae4afb20a59e4d7fc00b6c1f55b92a6442ee942e9bad
name: python-benchlingapi
arch: src
version: 2.1.12
epoch: 0
release: 1
summary: An unofficial python wrapper for the Benchling API
url: https://www.github.com/klavinslab/benchling-api
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchlingapi-2.1.12-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/benchlingapi.svg)](https://badge.fury.io/py/benchlingapi)

  The (unofficial) python API wrapper for Benchling. For more information,
  see documentation at https://klavinslab.github.io/benchling-api/index.



  ```
  pip install benchlingapi -U
  ```



  Initialize a session using your Benchling-provided API key:

  ```python
  from benchlingapi import Session
  session = Session("your_secret_benchling_api_key")
  ```

  From there, you can access various models:

  ```python
  session.DNASequence
  session.AASequence
  session.Oligo
  session.Folder
  session.Project
  session.Registry
  session.Translation
  session.EntitySchema
  session.Batch
  session.CustomEntity
  ```

  Finding models:

  ```python

  dna = session.DNASequence.one()


  dna = session.DNASequence.find('sdg_4tg23')


  proteins = session.AASequence.last(50)


  registry = session.Registry.find_by_name("Klavins Lab Registry")
  ```

  Updating models:

  ```python
  dna = session.DNASequence.one()
  dna.name = "My new name"
  dna.bases = "AGGTAGGGTAGGGCCAGAGA"


  dna.update()
  ```

  Saving new models:

  ```python
  folder = session.Folder.find_by_name("My API Folder")
  dna = session.DNASequence(
      name = 'my new dna',
      bases = 'AGGTAGGATGGCCA',
      folder_id = folder.id,
      is_circular = False
  )


  dna.save()
  ```

  Registering models to your registry:

  ```python
  dna.set_schema("My DNA Schema")
  dna.register()
  ```

  See the documentation for more information: https://klavinslab.github.io/benchling-api/index



  Testing is done using `pytest`. Tests will create live requests to a Benchling account.
  Since testing is done live, a Benchling account will need to be setup along with testing
  data.

  To run tests, you must have a Benchling Account with an API key. Tests require a file in
  'tests/secrets/config.json' with the following format:

  ```
  {
    "credentials": {
      "api_key": "asdahhjwrthsdfgadfadfgadadsfa"
    },
    "sharelinks": [
      "https://benchling.com/s/seq-asdfadsfaee"
    ],
    "project": {
      "name": "API"
    },
    "trash_folder": {
      "name": "API_Trash"
    },
    "inventory_folder": {
      "name": "API_Inventory"
    }
  }
  ```

  On the Benchling side of things, in the account liked to the `credentials["api_key"]`, you must
  have a project corresponding to the `project["name"]` value above. Within this project, you should
  have two folder corresponding to the `trash_folder` and `inventory_folder` values above. Additionally,
  you should have at least one example of an AminoAcid, DNASequence, CustomEntity, and Oligo stored within
  your `inventory_folder`. Tests will copy the examples from the `inventory_folder` for downstream tests.
  After the tests, conclude, inventory in the `trash_folder` will get archived.


pkgId: a50faad99ec4201b8833cee1059ea5f5ad84b9705f8502634a729aa12908db6c
name: python-benchmark-4dn
arch: src
version: 0.5.25
epoch: 0
release: 1
url: https://github.com/SooLee/Benchmark/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchmark-4dn-0.5.25-1.src.rpm
checksum_type: sha256
summary:
  Benchmark functions that returns total space, mem, cpu given input size and parameters for the CWL workflows

description:
  Note: From `0.5.3` we have a new function that takes in cpu and memory and returns a sorted list of instance dictionaries.
  ```
  get_instance_types(cpu=1, mem_in_gb=0.5, instances=instance_list(), top=10, rank='cost_in_usd')
  ```
  Keys in each instance dictionary:
  ```
  'cost_in_usd', 'mem_in_gb', 'cpu', 'instance_type', 'EBS_optimized', 'EBS_optimization_surcharge'
  ```


pkgId: 1591656e88a44105dc8a0957ea6fbcf73480823deb702dabdfd5664643531e5b
name: python-benchmark-runner
arch: src
version: 1.0.680
epoch: 0
release: 1
summary: Benchmark Runner Tool
url: https://github.com/redhat-performance/benchmark-runner
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchmark-runner-1.0.680-1.src.rpm
checksum_type: sha256
description:
  [![Actions Status](https://github.com/redhat-performance/benchmark-runner/actions/workflows/Perf_Env_Build_Test_CI.yml/badge.svg)](https://github.com/redhat-performance/benchmark-runner/actions)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/benchmark-runner.svg)](https://pypi.org/project/benchmark-runner/)
  [![Container Repository on Quay](https://quay.io/repository/projectquay/quay/status "Container Repository on Quay")](https://quay.io/repository/benchmark-runner/benchmark-runner?tab=tags)
  [![Coverage Status](https://coveralls.io/repos/github/redhat-performance/benchmark-runner/badge.svg?branch=main)](https://coveralls.io/github/redhat-performance/benchmark-runner?branch=main&kill_cache=1)
  [![Documentation Status](https://readthedocs.org/projects/benchmark-runner/badge/?version=latest)](https://benchmark-runner.readthedocs.io/en/latest/?badge=latest)
  [![python](https://img.shields.io/pypi/pyversions/benchmark-runner.svg?color=%2334D058)](https://pypi.org/project/benchmark-runner)
  [![License](https://img.shields.io/pypi/l/benchmark-runner.svg)](https://github.com/redhat-performance/benchmark-runner/blob/main/LICENSE)

  **benchmark-runner** is a containerized Python lightweight and flexible framework for running benchmark workloads
  on Kubernetes/OpenShift runtype kinds Pod, kata and VM.
  This framework support the following embedded workloads:
  * [hammerdb](https://hammerdb.com/): running hammerdb workload on the following databases: MSSQL, Mariadb, Postgresql in Pod, Kata or VM with [Configuration](benchmark_runner/common/template_operations/templates/hammerdb)
  * [stressng](https://wiki.ubuntu.com/Kernel/Reference/stress-ng): running stressng workload in Pod, Kata or VM [Configuration](benchmark_runner/common/template_operations/templates/stressng)
  * [uperf](http://uperf.org/): running uperf workload in Pod, Kata or VM with [Configuration](benchmark_runner/common/template_operations/templates/uperf)
  * [vdbench](https://wiki.lustre.org/VDBench/): running vdbench workload in Pod, Kata or VM with [Configuration](benchmark_runner/common/template_operations/templates/vdbench)
  * [bootstorm](https://en.wiktionary.org/wiki/boot_storm): calculate VMs boot load time [Configuration](benchmark_runner/common/template_operations/templates/bootstorm)
  ** For hammerdb mssql must run once [permission](https://github.com/redhat-performance/benchmark-runner/blob/main/benchmark_runner/common/ocp_resources/custom/template/02_mssql_patch_template.sh)
  Benchmark-runner grafana dashboard example:
  ![](media/grafana.png)
  Reference:
  * The benchmark-runner package is located in [PyPi](https://pypi.org/project/benchmark-runner)
  * The benchmark-runner container image is located in [Quay.io](https://quay.io/repository/benchmark-runner/benchmark-runner)

  Documentation is available at [benchmark-runner.readthedocs.io](https://benchmark-runner.readthedocs.io/en/latest/)
  ![](media/docker2.png)
  _**Table of Contents**_
  <!-- TOC -->
  - [Benchmark-Runner](#benchmark-runner)
    - [Documentation](#documentation)
    - [Run workload using Podman or Docker](#run-workload-using-podman-or-docker)
    - [Run workload in Pod using Kubernetes or OpenShift](#run-workload-in-pod-using-kubernetes-or-openshift)
    - [Grafana dashboards](#grafana-dashboards)
    - [Inspect Prometheus Metrics](#inspect-prometheus-metrics)
    - [How to develop in benchmark-runner](#how-to-develop-in-benchmark-runner)
  <!-- /TOC -->

  The following options may be passed via command line flags or set in the environment:
  **mandatory:** KUBEADMIN_PASSWORD=$KUBEADMIN_PASSWORD
  **mandatory:** $KUBECONFIG [ kubeconfig file path]
  **mandatory:** WORKLOAD=$WORKLOAD
  Choose one from the following list:
  `['stressng_pod', 'stressng_vm', 'stressng_kata', 'uperf_pod', 'uperf_vm', 'uperf_kata', 'hammerdb_pod_mariadb', 'hammerdb_vm_mariadb', 'hammerdb_kata_mariadb', 'hammerdb_pod_mariadb_lso', 'hammerdb_vm_mariadb_lso', 'hammerdb_kata_mariadb_lso', 'hammerdb_pod_postgres', 'hammerdb_vm_postgres', 'hammerdb_kata_postgres', 'hammerdb_pod_postgres_lso', 'hammerdb_vm_postgres_lso', 'hammerdb_kata_postgres_lso', 'hammerdb_pod_mssql', 'hammerdb_vm_mssql', 'hammerdb_kata_mssql', 'hammerdb_pod_mssql_lso', 'hammerdb_vm_mssql_lso', 'hammerdb_kata_mssql_lso', 'vdbench_pod', 'vdbench_kata', 'vdbench_vm', 'clusterbuster', 'bootstorm_vm']`
  ** clusterbuster workloads: cpusoaker, files, fio, uperf. for more details [see](https://github.com/RobertKrawitz/OpenShift4-tools)
  Not mandatory:
  **auto:** NAMESPACE=benchmark-operator [ The default namespace is benchmark-operator ]
  **auto:** ODF_PVC=True [ True=ODF PVC storage, False=Ephemeral storage, default True ]
  **auto:** EXTRACT_PROMETHEUS_SNAPSHOT=True [ True=extract Prometheus snapshot into artifacts, false=don't, default True ]
  **auto:** SYSTEM_METRICS=False [ True=collect metric, False=not collect metrics, default False ]
  **auto:** RUNNER_PATH=/tmp [ The default work space is /tmp ]
  **optional:** PIN_NODE_BENCHMARK_OPERATOR=$PIN_NODE_BENCHMARK_OPERATOR [node selector for benchmark operator pod]
  **optional:** PIN_NODE1=$PIN_NODE1 [node1 selector for running the workload]
  **optional:** PIN_NODE2=$PIN_NODE2 [node2 selector for running the workload, i.e. uperf server and client, hammerdb database and workload]
  **optional:** ELASTICSEARCH=$ELASTICSEARCH [ elasticsearch service name]
  **optional:** ELASTICSEARCH_PORT=$ELASTICSEARCH_PORT
  **optional:** CLUSTER=$CLUSTER [ set CLUSTER='kubernetes' to run workload on a kubernetes cluster, default 'openshift' ]
  **optional:scale** SCALE=$SCALE [For Vdbench/Bootstorm: Scale in each node]
  **optional:scale** SCALE_NODES=$SCALE_NODES [For Vdbench/Bootstorm: Scale's node]
  **optional:scale** REDIS=$REDIS [For Vdbench only: redis for scale synchronization]
  **optional:** LSO_DISK_ID=$LSO_DISK_ID [LSO_DISK_ID='scsi-<replace_this_with_your_actual_disk_id>' For using LSO Operator in hammerdb]
  **optional:** WORKER_DISK_IDS=$WORKER_DISK_IDS [WORKER_DISK_IDS For ODF/LSO workloads hammerdb/vdbench]
  For example:
  ```sh
  podman run --rm -e WORKLOAD="hammerdb_pod_mariadb" -e KUBEADMIN_PASSWORD="1234" -e PIN_NODE_BENCHMARK_OPERATOR="node_name-0" -e PIN_NODE1="node_name-1" -e PIN_NODE2="node_name-2" -e log_level=INFO -v /root/.kube/config:/root/.kube/config --privileged quay.io/benchmark-runner/benchmark-runner:latest
  ```
  or
  ```sh
  docker run --rm -e WORKLOAD="hammerdb_vm_mariadb" -e KUBEADMIN_PASSWORD="1234" -e PIN_NODE_BENCHMARK_OPERATOR="node_name-0" -e PIN_NODE1="node_name-1" -e PIN_NODE2="node_name-2" -e log_level=INFO -v /root/.kube/config:/root/.kube/config --privileged quay.io/benchmark-runner/benchmark-runner:latest
  ```
  SAVE RUN ARTIFACTS LOCAL:
  1. add `-e SAVE_ARTIFACTS_LOCAL='True'` or `--save-artifacts-local=true`
  2. add `-v /tmp:/tmp`
  3. git clone -b v1.0.3 https://github.com/cloud-bulldozer/benchmark-operator /tmp/benchmark-operator

  ![](media/benchmark-runner-demo.gif)

  ![](media/benchmark-runner-k8s-demo.gif)

  [TBD]

  There are 2 grafana dashboards templates:
  1. [FuncCi dashboard](benchmark_runner/grafana/func/dashboard.json)
  2. [PerfCi dashboard](benchmark_runner/grafana/perf/dashboard.json)
  ** PerfCi dashboard is generated automatically in [Build GitHub actions](https://github.com/redhat-performance/benchmark-runner/blob/main/.github/workflows/Perf_Env_Build_Test_CI.yml) from [main.libsonnet](benchmark_runner/grafana/perf/jsonnet/main.libsonnet)
  ** After importing json in grafana, you need to configure elasticsearch data source. (for more details: see [HOW_TO.md](HOW_TO.md))

  The CI jobs store snapshots of the Prometheus database for each run as part of the artifacts.  Within the artifact directory is a Prometheus snapshot directory named:
  ```
  promdb-YYYY_MM_DDTHH_mm_ss+0000_YYYY_MM_DDTHH_mm_ss+0000.tar
  ```
  The timestamps are for the start and end of the metrics capture; they
  are stored in UTC time (`+0000`).  It is possible to run containerized
  Prometheus on it to inspect the metrics.  *Note that Prometheus
  requires write access to its database, so it will actually write to
  the snapshot.* So for example if you have downloaded artifacts for a
  run named `hammerdb-vm-mariadb-2022-01-04-08-21-23` and the Prometheus
  snapshot within is named
  `promdb_2022_01_04T08_21_52+0000_2022_01_04T08_45_47+0000`, you could run as follows:
  ```
  $ local_prometheus_snapshot=/hammerdb-vm-mariadb-2022-01-04-08-21-23/promdb_2022_01_04T08_21_52+0000_2022_01_04T08_45_47+0000
  $ chmod -R g-s,a+rw "$local_prometheus_snapshot"
  $ sudo podman run --rm -p 9090:9090 -uroot -v "$local_prometheus_snapshot:/prometheus" --privileged prom/prometheus --config.file=/etc/prometheus/prometheus.yml --storage.tsdb.path=/prometheus --storage.tsdb.retention.time=100000d --storage.tsdb.retention.size=1000PB
  ```
  and point your browser at port 9090 on your local system, you can run queries against it, e.g.
  ```
  sum(irate(node_cpu_seconds_total[2m])) by (mode,instance) > 0
  ```
  It is important to use the `--storage.tsdb.retention.time` option to
  Prometheus, as otherwise Prometheus may discard the data in the
  snapshot.  And note that you must set the time bounds on the
  Prometheus query to fit the start and end times as recorded in the
  name of the promdb snapshot.

  see [HOW_TO.md](HOW_TO.md)


pkgId: d8a8e92e2252f1855bcc8c66a895f6970b25ca5665888fe736a9083904d7964e
name: python-benchnirs
arch: src
version: 1.5.3
epoch: 0
release: 1
summary: Benchmarking framework for machine learning with fNIRS
url: https://gitlab.com/HanBnrd/benchnirs
rpm_license: GNU GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchnirs-1.5.3-1.src.rpm
checksum_type: sha256
description:
  <img title="BenchNIRS" align="right" width="150" height="150" src="https://hanbnrd.gitlab.io/assets/img/logos/benchnirs.png" alt="BenchNIRS">

  *Benchmarking framework for machine learning with fNIRS*

  **Quick links**
  &rarr; [*Journal article*](https://www.frontiersin.org/articles/10.3389/fnrgo.2023.994969)
  &rarr; [*BenchNIRS source code*](https://gitlab.com/HanBnrd/benchnirs)
  &rarr; [*Install BenchNIRS*](https://hanbnrd.gitlab.io/benchnirs/install.html)
  &rarr; [*Documentation*](https://hanbnrd.gitlab.io/benchnirs)
  &rarr; [*Examples*](https://hanbnrd.gitlab.io/benchnirs/examples.html)
  &rarr; [*Issue tracker*](https://gitlab.com/HanBnrd/benchnirs/-/issues)


  [![DOI](https://img.shields.io/badge/doi-10.3389%2Ffnrgo.2023.994969-blue)](https://doi.org/10.3389/fnrgo.2023.994969)
  [![License](https://img.shields.io/badge/license-GNU%20GPLv3%2b-lightgrey)](https://gitlab.com/HanBnrd/benchnirs/-/blob/main/LICENSE)
  [![Pipeline](https://gitlab.com/HanBnrd/benchnirs/badges/main/pipeline.svg)](https://gitlab.com/HanBnrd/benchnirs)
  [![PyPI version](https://img.shields.io/pypi/v/benchnirs)](https://pypi.org/project/benchnirs/)


  ![Example of figure](https://gitlab.com/HanBnrd/benchnirs/-/raw/v1.0/example.png)


  **Features**
  - loading of open access datasets
  - signal processing and feature extraction on fNIRS data
  - training, hyperparameter tuning and evaluation of machine learning models (including deep learning)
  - production of training graphs, metrics and other useful figures for evaluation
  - benchmarking and comparison of machine learning models
  - supervised, self-supervised and transfer learning
  - much more!



  The documentation of the framework with examples can be found [here](https://hanbnrd.gitlab.io/benchnirs).



  A checklist of recommendations towards best practices for machine learning with fNIRS can be found [here](./CHECKLIST.md). We welcome contributions from the community in order to improve it, please see below for more information on how to contribute.



  1. Download and install Python 3.9 or greater, for example with [Miniconda](https://docs.conda.io/projects/miniconda/en/latest/index.html).

  2. To install the package with *pip* (cf. [PyPI](https://pypi.org/project/benchnirs/)), open a terminal (eg. Anaconda Prompt) and type:
  ```bash
  pip install benchnirs
  ```

  3. Download the datasets (see below).

  > Alternatively to install from source in development mode, download and unzip the [repository](https://gitlab.com/HanBnrd/benchnirs/-/archive/main/benchnirs-main.zip) (or clone it with Git), and run `devinstall.py`.



  - *Herff et al. 2014* (n-back task): you can download the dataset by making a request [here](http://www.csl.uni-bremen.de/CorpusData/download.php?crps=fNIRS).
  - *Shin et al. 2018* (n-back and word generation tasks): you can download the dataset [here](http://doc.ml.tu-berlin.de/simultaneous_EEG_NIRS/NIRS/NIRS_01-26_MATLAB.zip).
  - *Shin et al. 2016* (mental arithmetic task): you can download the dataset by filling out the form [here](http://doc.ml.tu-berlin.de/hBCI). Then click on *NIRS_01-29* to download the fNIRS data.
  - *Bak et al. 2019* (motor execution task): you can download the dataset [here](https://figshare.com/ndownloader/files/18069143).



  To update *BenchNIRS* to the latest version with *pip*, open a terminal (eg. Anaconda Prompt) and type:
  ```bash
  pip install --upgrade benchnirs
  ```



  A set of example scripts showing how to use the framework can be found [here](https://hanbnrd.gitlab.io/benchnirs/examples.html).



  *BenchNIRS* enables to evaluate your model in Python with simplicity on an open access dataset supported:
  ```python
  import benchnirs as bn

  epochs = bn.load_dataset('bak_2019_me', path)
  data = bn.process_epochs(epochs['right', 'left', 'foot'])
  results = bn.deep_learn(my_model, *data)

  print(results)
  ```



  Contributions from the community to this repository are highly appreciated. We are mainly interested in contributions to:
  - improving the recommendation checklist
  - adding support for new open access datasets
  - adding support for new machine learning models
  - adding more fNIRS signal processing techniques
  - improving the documentation
  - tracking bugs

  Contributions are encouraged under the form of [issues](https://gitlab.com/HanBnrd/benchnirs/-/issues) (for reporting bugs or requesting new features) and [merge requests](https://gitlab.com/HanBnrd/benchnirs/-/merge_requests) (for fixing bugs and implementing new features).
  Please refer to [this tutorial](https://docs.gitlab.com/ee/user/project/repository/forking_workflow.html) for creating merge requests from a fork of the repository.



  If you are using *BenchNIRS*, please cite [this article](https://doi.org/10.3389/fnrgo.2023.994969):
  ```
  @article{benerradi2023benchmarking,
    title={Benchmarking framework for machine learning classification from fNIRS data},
    author={Benerradi, Johann and Clos, Jeremie and Landowska, Aleksandra and Valstar, Michel F and Wilson, Max L},
    journal={Frontiers in Neuroergonomics},
    volume={4},
    year={2023},
    publisher={Frontiers Media},
    url={https://www.frontiersin.org/articles/10.3389/fnrgo.2023.994969},
    doi={10.3389/fnrgo.2023.994969},
    issn={2673-6195}
  }
  ```

  > If you are using the datasets of the framework, please also cite those related works:
  >
  > [*Herff et al. 2014*](https://doi.org/10.3389/fnhum.2013.00935)
  > ```
  > @article{herff2014mental,
  > 	title={Mental workload during n-back task—quantified in the prefrontal cortex using fNIRS},
  > 	author={Herff, Christian and Heger, Dominic and Fortmann, Ole and Hennrich, Johannes and Putze, Felix and Schultz, Tanja},
  > 	journal={Frontiers in human neuroscience},
  > 	volume={7},
  > 	pages={935},
  > 	year={2014},
  > 	publisher={Frontiers}
  > }
  > ```
  >
  > [*Shin et al. 2018*](https://doi.org/10.1038/sdata.2018.3)
  > ```
  > @article{shin2018simultaneous,
  > 	title={Simultaneous acquisition of EEG and NIRS during cognitive tasks for an open access dataset},
  > 	author={Shin, Jaeyoung and Von L{\"u}hmann, Alexander and Kim, Do-Won and Mehnert, Jan and Hwang, Han-Jeong and M{\"u}ller, Klaus-Robert},
  > 	journal={Scientific data},
  > 	volume={5},
  > 	pages={180003},
  > 	year={2018},
  > 	publisher={Nature Publishing Group}
  > }
  > ```
  >
  > [*Shin et al. 2016*](https://doi.org/10.1109/TNSRE.2016.2628057)
  > ```
  > @article{shin2016open,
  > 	title={Open access dataset for EEG+NIRS single-trial classification},
  > 	author={Shin, Jaeyoung and von L{\"u}hmann, Alexander and Blankertz, Benjamin and Kim, Do-Won and Jeong, Jichai and Hwang, Han-Jeong and M{\"u}ller, Klaus-Robert},
  > 	journal={IEEE Transactions on Neural Systems and Rehabilitation Engineering},
  > 	volume={25},
  > 	number={10},
  > 	pages={1735--1745},
  > 	year={2016},
  > 	publisher={IEEE}
  > }
  > ```
  >
  > [*Bak et al. 2019*](https://doi.org/10.3390/electronics8121486)
  > ```
  > @article{bak2019open,
  > 	title={Open-Access fNIRS Dataset for Classification of Unilateral Finger-and Foot-Tapping},
  > 	author={Bak, SuJin and Park, Jinwoo and Shin, Jaeyoung and Jeong, Jichai},
  > 	journal={Electronics},
  > 	volume={8},
  > 	number={12},
  > 	pages={1486},
  > 	year={2019},
  > 	publisher={Multidisciplinary Digital Publishing Institute}
  > }
  > ```


pkgId: 1aa03d8185af674d1624319b6e07f0495e1cc3ed9ad72ea22d96ece3dc64ae59
name: python-benchpots
arch: src
version: 0.3
epoch: 0
release: 1
summary: A Python Toolbox for Benchmarking Machine Learning on Partially-Observed Time Series
url: https://pypots.com
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchpots-0.3-1.src.rpm
checksum_type: sha256
description:
  <a href="https://github.com/WenjieDu/BenchPOTS">
      <img src="https://pypots.com/figs/pypots_logos/BenchPOTS/logo_FFBG.svg" width="200" align="right">
  </a>

  <h3 align="center">Welcome to BenchPOTS</h3>

  <p align="center"><i>a Python toolbox for benchmarking ML on POTS (Partially-Observed Time Series)</i></p>

  <p align="center">
      <a href="https://docs.pypots.com/en/latest/install.html#reasons-of-version-limitations-on-dependencies">
         <img alt="Python version" src="https://img.shields.io/badge/Python-v3.8+-E97040?logo=python&logoColor=white">
      </a>
      <a href="https://github.com/WenjieDu/BenchPOTS/releases">
          <img alt="the latest release version" src="https://img.shields.io/github/v/release/wenjiedu/benchpots?color=EE781F&include_prereleases&label=Release&logo=github&logoColor=white">
      </a>
      <a href="https://github.com/WenjieDu/BenchPOTS/blob/main/LICENSE">
          <img alt="BSD-3 license" src="https://img.shields.io/badge/License-BSD--3-E9BB41?logo=opensourceinitiative&logoColor=white">
      </a>
      <a href="https://github.com/WenjieDu/PyPOTS#-community">
          <img alt="Community" src="https://img.shields.io/badge/join_us-community!-C8A062">
      </a>
      <a href="https://github.com/WenjieDu/BenchPOTS/graphs/contributors">
          <img alt="GitHub contributors" src="https://img.shields.io/github/contributors/wenjiedu/benchpots?color=D8E699&label=Contributors&logo=GitHub">
      </a>
      <a href="https://star-history.com/#wenjiedu/benchpots">
          <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/wenjiedu/benchpots?logo=None&color=6BB392&label=%E2%98%85%20Stars">
      </a>
      <a href="https://github.com/WenjieDu/BenchPOTS/network/members">
          <img alt="GitHub Repo forks" src="https://img.shields.io/github/forks/wenjiedu/benchpots?logo=forgejo&logoColor=black&label=Forks">
      </a>
      <a href="https://codeclimate.com/github/WenjieDu/BenchPOTS">
          <img alt="Code Climate maintainability" src="https://img.shields.io/codeclimate/maintainability-percentage/WenjieDu/BenchPOTS?color=3C7699&label=Maintainability&logo=codeclimate">
      </a>
      <a href="https://coveralls.io/github/WenjieDu/BenchPOTS">
          <img alt="Coveralls coverage" src="https://img.shields.io/coverallsCoverage/github/WenjieDu/BenchPOTS?branch=main&logo=coveralls&color=75C1C4&label=Coverage">
      </a>
      <a href="https://github.com/WenjieDu/BenchPOTS/actions/workflows/testing_ci.yml">
          <img alt="GitHub Testing" src="https://img.shields.io/github/actions/workflow/status/wenjiedu/benchpots/testing_ci.yml?logo=circleci&color=C8D8E1&label=CI">
      </a>
      <a href="https://docs.pypots.com/en/latest/benchpots.html">
          <img alt="Docs building" src="https://img.shields.io/readthedocs/pypots?logo=readthedocs&label=Docs&logoColor=white&color=395260">
      </a>
      <a href="https://anaconda.org/conda-forge/benchpots">
          <img alt="Conda downloads" src="https://img.shields.io/endpoint?url=https://pypots.com/figs/downloads_badges/conda_benchpots_downloads.json">
      </a>
      <a href="https://pepy.tech/project/benchpots">
          <img alt="PyPI downloads" src="https://img.shields.io/endpoint?url=https://pypots.com/figs/downloads_badges/pypi_benchpots_downloads.json">
      </a>
  </p>

  To evaluate the performance of algorithms on POTS datasets, a benchmarking toolkit is necessary, hence the ecosystem library BenchPOTS is developed.
  BenchPOTS provides the standard and unified preprocessing pipelines of a variety of POTS datasets.
  It supports a variety of evaluation tasks to help users understand the performance of different algorithms.



  > [!IMPORTANT]
  > BenchPOTS is available on both <a alt='PyPI' href='https://pypi.python.org/pypi/benchpots'><img align='center' src='https://img.shields.io/badge/PyPI--lightgreen?style=social&logo=pypi'></a>
  > and <a alt='Anaconda' href='https://anaconda.org/conda-forge/benchpots'><img align='center' src='https://img.shields.io/badge/Anaconda--lightgreen?style=social&logo=anaconda'></a>❗️
  >
  > Install via pip:
  > > pip install benchpots
  >
  > or install from source code:
  > > pip install `https://github.com/WenjieDu/BenchPOTS/archive/main.zip`
  >
  > or install via conda:
  > > conda install benchpots -c conda-forge

  ```python
  import benchpots


  benchpots.datasets.preprocess_physionet2012(subset="all", rate="0.1")

  ```


  The paper introducing PyPOTS is available [on arXiv](https://arxiv.org/abs/2305.18811),
  A short version of it is accepted by the 9th SIGKDD international workshop on Mining and Learning from Time Series ([MiLeTS'23](https://kdd-milets.github.io/milets2023/))).
  **Additionally**, PyPOTS has been included as a [PyTorch Ecosystem](https://pytorch.org/ecosystem/) project.
  We are pursuing to publish it in prestigious academic venues, e.g. JMLR (track for
  [Machine Learning Open Source Software](https://www.jmlr.org/mloss/)). If you use PyPOTS in your work,
  please cite it as below and 🌟star this repository to make others notice this library. 🤗

  There are scientific research projects using PyPOTS and referencing in their papers.
  Here is [an incomplete list of them](https://scholar.google.com/scholar?as_ylo=2022&q=%E2%80%9CPyPOTS%E2%80%9D&hl=en).

  <p align="center">
  <a href="https://github.com/WenjieDu/PyPOTS">
      <img src="https://pypots.com/figs/pypots_logos/Ecosystem/PyPOTS_Ecosystem_Pipeline.png" width="95%"/>
  </a>
  </p>

  ``` bibtex
  @article{du2023pypots,
  title={{PyPOTS: a Python toolbox for data mining on Partially-Observed Time Series}},
  author={Wenjie Du},
  journal={arXiv preprint arXiv:2305.18811},
  year={2023},
  }
  ```
  or
  > Wenjie Du.
  > PyPOTS: a Python toolbox for data mining on Partially-Observed Time Series.
  > arXiv, abs/2305.18811, 2023.



  <details>
  <summary>🏠 Visits</summary>
  <a href="https://github.com/WenjieDu/BenchPOTS">
      <img alt="BenchPOTS visits" align="left" src="https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2FWenjieDu%2FBenchPOTS&count_bg=%23009A0A&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=Visits%20since%20June%202024&edge_flat=false">
  </a>
  </details>
  <br>

rpm_license:
  Copyright (c) 2024-present, Wenjie Du All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: d94f60390552d22fa64633a5c87a8ced4af8f3b5cd8549a9a9bfdc670e8cf418
name: python-benchpress
arch: src
version: 3.0.5.post18
epoch: 0
release: 1
summary: Benchmark suite tool
url: http://benchpress.readthedocs.io
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benchpress-3.0.5.post18-1.src.rpm
checksum_type: sha256
description:
  Fire up your terminal, and::
    
    pip install benchpress --user
    
    export PATH=$PATH:$HOME/.local/bin
  Specify what to benchmark by implementing a Python script that generates commands::
      import benchpress as bp
      from benchpress.suite_util import BP_ROOT
      scripts = [
          ('X-ray',  'xraysim',  ["10*10*1", "20*10*1"]),
          ('Bean',   'galton_bean_machine',  ["10000*10", "20000*10"]),
      ]
      cmd_list = []
      for label, name, sizes in scripts:
          for size in sizes:
              full_label = "%s/%s" % (label, size)
              bash_cmd = "python {root}/benchmarks/{script}/python_numpy/{script}.py {size}" \
                          .format(root=BP_ROOT, script=name, size=size)
              cmd_list.append(bp.command(bash_cmd, full_label))
      
      bp.create_suite(cmd_list)
  And run the script::
      $ python suites/simple_example.py --output my_benchmark.json
      Scheduling 'X-ray/10*10*1': 'python xraysim/python_numpy/xraysim.py --size=10*10*1'
      Scheduling 'X-ray/20*10*1': 'python xraysim/python_numpy/xraysim.py --size=20*10*1'
      Scheduling 'Bean/10000*10': 'python galton_bean_machine/python_numpy/galton_bean_machine.py --size=10000*10'
      Scheduling 'Bean/20000*10': 'python galton_bean_machine/python_numpy/galton_bean_machine.py --size=20000*10'
      Writing suite file: my_benchmark.json
  The result is a JSON file `results.json` that encapsulate the commands that make up the benchmark suite.
  Now, use `bp-run` to run the benchmark suite::
      $bp-run results.json
      Executing 'X-ray/10*10*1'
      Executing 'X-ray/20*10*1'
      Executing 'Bean/10000*10'
      Executing 'Bean/20000*10'
  Finally, let's visualize the results in ASCII::
      $bp-cli results.json
      X-ray/10*10*1: [0.013303, 0.013324, 0.012933] 0.0132 (0.0002)
      X-ray/20*10*1: [0.108884, 0.105319, 0.105392] 0.1065 (0.0017)
      Bean/10000*10: [0.002653, 0.002553, 0.002616] 0.0026 (0.0000)
      Bean/20000*10: [0.005149, 0.005088, 0.005271] 0.0052 (0.0001)
  Or as a bar chart::
      $bp-chart results.json --output results.pdf
      Writing file 'results.pdf' using format 'pdf'.


pkgId: 05b113b16e4abc28ca82dbe081e328c2f61a257852f7fc3def8d851fafe07c2d
name: python-bencode
arch: src
version: 1.0
epoch: 0
release: 1
summary: The BitTorrent bencode module as light-weight, standalone package.
url: http://bittorrent.com/
rpm_license: BitTorrent Open Source License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bencode-1.0-1.src.rpm
checksum_type: sha256
description:
  This package simply re-packages the existing bencoding and bdecoding implemention from the 'official' BitTorrent client as a separate, leight-weight package for re-using them without having the entire BitTorrent software as a dependency.


pkgId: fc06c0cb8a64f8f3122a4e1e772c1e585d100528e5093903ec93c3f7fa47ec35
name: python-bencode-python3
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Python 3 port for the official bencode library
url: https://github.com/amyth/bencode
rpm_license: GPL3 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bencode-python3-1.0.2-1.src.rpm
checksum_type: sha256
description:
  This is the python 3 port for the official bencode (Bitorrent) encoding and decoding library. This project supports both python 2 and python 3.


pkgId: 98ec9be172553f642c38cb1e36e01fbdac865db157775e1dff38864352fa464c
name: python-benderml
arch: src
version: 0.1.19
epoch: 0
release: 1
summary: A Python package that makes ML processes easier, faster and less error prone
url: https://github.com/otovo/bender
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-benderml-0.1.19-1.src.rpm
checksum_type: sha256
description:
  A Python package for faster, safer, and simpler ML processes.



  `pip install benderml`

  **Usage:**

  ```python
  from bender.importers import DataImporters

  pre_processed_data = await DataImporters.csv("file/to/data.csv").process([...]).run()
  ```



  Bender will make your machine learning processes, faster, safer, simpler while at the same time making it easy and flexible. This is done by providing a set base component, around the core processes that will take place in a ML pipeline process. While also helping you with type hints about what your next move could be.



  The whole pipeline is build using generics from Python's typing system. Resulting in an improved developer experience, as the compiler can know if your pipeline's logic makes sense before it has started.



  Bender makes most of the `sklearn` datasets available through the `DataImporters.data_set(...)` importer. Here will you need to pass an enum to define which dataset you want. It is also possible to load the data from sql, append different data sources and cache, and it is as simple as:
  ```python
  from bender.importers import DataImporters


  DataImporters.data_set(DataSets.IRIS)


  DataImporters.sql("url", "SELECT ...")


  DataImporters.sql("url", "SELECT ...")
      .cached("path/to/cache")
      .append(
          
          DataImporters.sql(...)
      )
  ```


  When the data has been loaded is usually the next set to process the data in some way. `bender` will therefore provide different components that transforms features. Therefore making it easier to keep your logic consistent over multiple projects.

  ```python
  from bender.transformations import Transformations

  DataImporters.data_set(DataSets.IRIS)
      .process([
          
          Transformations.exp_shift('petal length (cm)', output='pl exp'),

          
          Transformations.compute('pl exp', lambda df: np.exp(df['petal length (cm)'])),

          
          Transformations.unpack_json("purchases", key="price", output_feature="price", policy=UnpackPolicy.median_number()),

          ...
      ])
  ```



  For view how the data is distribuated, is it also possible to explore the data.

  ```python
  from bender.explorers import Explorers

  await (DataImporters.data_set(DataSets.IRIS)
      .process([...])
      .explore([
          
          Explorers.histogram(target='target'),

          
          Explorers.correlation(input_features),

          
          Explorers.pair_plot('target'),
      ])
  ```


  There are many ways we can train and test, it is therefore easy to choose and switch between how it is done with `bender`.

  ```python
  from bender.split_strategies import SplitStrategies

  await (DataImporters.data_set(DataSets.IRIS)
      .process([...])

      
      .split(SplitStrategies.ratio(0.7))

      
      .split(SplitStrategies.uniform_ratio("target", 0.7))

      
      .split(SplitStrategies.sorted_ratio("target", 0.7))
  ```


  After you have split the data set into train and test, then you can train with the following.

  ```python
  from bender.model_trainers import Trainers

  await (DataImporters.data_set(DataSets.IRIS)
      .split(...)
      .train(
          
          Trainers.kneighbours(),
          input_features=[...],
          target_feature="target"
      )
  ```


  After you have a model will it be smart to test how well it works.

  ```python
  from bender.evaluators import Evaluators

  await (DataImporters.data_set(DataSets.IRIS)
      .split(...)
      .train(...)
      .evaluate([
          
          Evaluators.confusion_matrix(),
          Evaluators.roc_curve(),
          Evaluators.precision_recall(),
      ])
  ```


  At last would you need to store the model. You can therefore select one of manny exporters.
  ```python
  from bender.exporters import Exporters

  await (DataImporters.data_set(DataSets.IRIS)
      .split(...)
      .train(...)
      .export_model(Exporters.aws_s3(...))
  ```


  ```python
  ModelLoaders
      .aws_s3("path/to/model", s3_config)
      .import_data(
          DataImporters.sql(sql_url, sql_query)
      )
      .predict()
  ```


  ```python
  ModelLoaders
      .aws_s3(...)
      .import_data(...)
      .predict()
      .extract(prediction_as="target", metadata=['entry_id'], exporter=DataExporters.disk("predictions.csv"))
  ```


  An example of the IRIS data set which trains a model to perfection

  ```python
  await (DataImporters.data_set(DataSets.IRIS)
      .process([
          Transformations.exp_shift('petal length (cm)', output='pl exp'),
          Transformations.exp_shift('petal width (cm)', output='pw exp'),
      ])
      .explore([
          Explorers.histogram(target='target'),
          Explorers.correlation(input_features),
          Explorers.pair_plot('target'),
      ])
      .split(SplitStrategies.uniform_ratio("target", 0.7))
      .train(Trainers.kneighbours(), input_features=input_features, target_feature="target")
      .evaluate([
          Evaluators.confusion_matrix()
      ])
      .metric(Metrics.log_loss())
      .run())
  ```


  Below is a simple example for training a XGBoosted tree
  ```python
  DataImporters.sql(sql_url, sql_query)

      .process([ # Preproces the data
          
          Transformations.unpack_json("purchases", key="price", output_feature="price", policy=UnpackPolicy.median_number())

          Transformations.log_normal_shift("y_values", "y_log"),

          
          Transformations.date_component("month", "date", output_feature="month_value"),
      ])
      .split(SplitStrategies.ratio(0.7))

      
      .train(
          Trainers.xgboost(),
          input_features=['y_log', 'price', 'month_value', 'country', ...],
          target_feature='did_buy_product_x'
      )
      .evaluate([
          Evaluators.roc_curve(),
          Evaluators.confusion_matrix(),
          Evaluators.precision_recall(
              
              Exporter.disk("precision-recall.png")
          ),
      ])
  ```



  Below will a model be loaded from a AWS S3 bucket, preprocess the data, and predict the output.
  This will also make sure that the features are valid before predicting.

  ```python
  ModelLoaders
      
      .aws_s3("path/to/model", s3_config)

      
      .import_data(
          DataImporters.sql(sql_url, sql_query)
              
              .cached("cache/path")
      )
      
      .process([
          Transformations.unpack_json(...),
          ...
      ])
      
      .predict()
  ```


