# packages

pkgId: 2bba689d9b4db8540c2dcb2b38958e449947d8e6d4fe90d72cf0edfa735ed008
name: python-zenetics-help
arch: noarch
version: 0.0.17
epoch: 0
release: 1
summary: Development documents and examples for zenetics
url: https://github.com/zenetics/zenetics-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zenetics-0.0.17-1.src.rpm
location_href: Packages/python-zenetics-help-0.0.17-1.noarch.rpm
checksum_type: sha256
description:
  Zenetics SDK is a Python library that provides a simple interface to interact with Zenetics API.



  ```commandline
  pip install zenetics
  ```



  Define the following environment variables: `OPENAI_API_KEY`, `ZENETICS_API_KEY`, `ZENETICS_APP_ID`.

  ```python
  from zenetics import openai

  openai.chat.completions.create(
      messages=[
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Knock knock."},
          {"role": "assistant", "content": "Who's there?"},
          {"role": "user", "content": "Orange."},
      ],
      model="gpt-3.5-turbo",
  )
  ```


pkgId: f47afb2a84fa37993f2dacb1ad302a39aab531946d8551b38bbf558352ceba62
name: python-zenithdb-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for zenithdb
url: https://github.com/jolovicdev/zenithdb
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zenithdb-1.0.0-1.src.rpm
location_href: Packages/python-zenithdb-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  SQLite-powered document database with MongoDB-like syntax, full-text search, and advanced querying capabilities.
  For complete examples of all features, PLEASE check out [usage.py](usage.py).



  - **Document Storage & Validation**: Store and validate JSON-like documents with nested structures
  - **Advanced Querying**: Full-text search, nested field queries, array operations
  - **Multiple Query Styles**: Support for both MongoDB-style dict queries and fluent Query builder
  - **Indexing**: Single and compound indexes for optimized performance
  - **Aggregations**: Group and aggregate data with functions like COUNT, AVG, SUM
  - **Bulk Operations**: Efficient batch processing with transaction support
  - **Connection Pooling**: Built-in connection pool for concurrent operations
  - **Migration Support**: Versioned database migrations with up/down functions



  ```bash
  pip install zenithdb
  ```



  ```python
  from zenithdb import Database


  db = Database("myapp.db")
  users = db.collection("users")


  def age_validator(doc):
      return isinstance(doc.get('age'), int) and doc['age'] >= 0
  users.set_validator(age_validator)


  users.insert({
      "name": "John Doe",
      "age": 30,
      "tags": ["premium"],
      "profile": {"city": "New York"}
  })


  users.find({
      "age": {"$gt": 25},
      "tags": {"$contains": "premium"}
  })


  users.find({"*": {"$contains": "John"}})


  users.update(
      {"name": "John Doe"},
      {"$set": {
          "profile.city": "Brooklyn",
          "tags.0": "vip"
      }}
  )


  users.aggregate([{
      "group": {
          "field": "profile.city",
          "function": "COUNT",
          "alias": "count"
      }
  }])
  ```



  ```python

  db.list_collections()
  db.count_collections()


  db.drop_collection("users")
  db.drop_all_collections()


  users.print_collection()
  users.count()
  ```




  ```python

  db.create_index("users", ["email"])
  db.create_index("users", ["profile.city", "age"])


  db.list_indexes("users")
  ```


  ```python
  bulk_ops = users.bulk_operations()
  with bulk_ops.transaction():
      bulk_ops.bulk_insert("users", [
          {"name": "User1", "age": 31},
          {"name": "User2", "age": 32}
      ])
  ```


  ```python
  from zenithdb.migrations import MigrationManager

  manager = MigrationManager(db)
  migration = {
      'version': '001',
      'name': 'add_users',
      'up': lambda: db.collection('users').insert({'admin': True}),
      'down': lambda: db.collection('users').delete({})
  }
  manager.apply_migration(migration)
  ```



  ```bash

  pip install -e ".[dev]"


  pytest tests/
  pytest tests/test_migrations.py
  pytest --cov=zenithdb tests/
  ```

  For complete examples of all features, check out [usage.py](usage.py).
  I would not recommend using this as a production database, but it's a fun project to play around with.


pkgId: f08e82962dc2081e916bbe1c2bb980bba9875323d3650189d6344c70d6e013e3
name: python-zenml-nightly-help
arch: noarch
version: 0.71.0.dev20241214
epoch: 0
release: 1
summary: Development documents and examples for zenml-nightly
url: https://zenml.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zenml-nightly-0.71.0.dev20241214-1.src.rpm
location_href: Packages/python-zenml-nightly-help-0.71.0.dev20241214-1.noarch.rpm
checksum_type: sha256
description:
  If you find ZenML helpful or interesting, please consider giving us a star on GitHub. Your support helps promote the project and lets others know that it's worth checking out.
  Thank you for your support! 🌟
  [![Star this project](https://img.shields.io/github/stars/zenml-io/zenml?style=social)](https://github.com/zenml-io/zenml/stargazers)

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/zenml-io/zenml/blob/main/examples/quickstart/quickstart.ipynb)
  [Install ZenML](https://docs.zenml.io/getting-started/installation) via [PyPI](https://pypi.org/project/zenml/). Python 3.9 - 3.12 is required:
  ```bash
  pip install "zenml[server]" notebook
  ```
  Take a tour with the guided quickstart by running:
  ```bash
  zenml go
  ```


  ZenML is a MLOps framework intended for data scientists or ML engineers looking to standardize machine learning practices. Just add `@step` and `@pipeline` to your existing Python functions to get going. Here is a toy example:
  ```python
  from zenml import pipeline, step
  @step  # Just add this decorator
  def load_data() -> dict:
      training_data = [[1, 2], [3, 4], [5, 6]]
      labels = [0, 1, 0]
      return {'features': training_data, 'labels': labels}
  @step
  def train_model(data: dict) -> None:
      total_features = sum(map(sum, data['features']))
      total_labels = sum(data['labels'])
      print(f"Trained model using {len(data['features'])} data points. "
            f"Feature sum is {total_features}, label sum is {total_labels}")
  @pipeline  # This function combines steps together
  def simple_ml_pipeline():
      dataset = load_data()
      train_model(dataset)
  if __name__ == "__main__":
      run = simple_ml_pipeline()  # call this to run the pipeline
  ```
  ![Running a ZenML pipeline](/docs/book/.gitbook/assets/readme_basic_pipeline.gif)

  The framework is a gentle entry point for practitioners to build complex ML pipelines with little knowledge required of the underlying infrastructure complexity. ZenML pipelines can be run on AWS, GCP, Azure, Airflow, Kubeflow and even on Kubernetes without having to change any code or know underlying internals.
  ZenML provides different features to aid people to get started quickly on a remote setting as well. If you want to deploy a remote stack from scratch on your selected cloud provider, you can use the 1-click deployment feature either through the dashboard:
  ![Running a ZenML pipeline](/docs/book/.gitbook/assets/one-click-deployment.gif)
  Or, through our CLI command:
  ```bash
  zenml stack deploy --provider aws
  ```
  Alternatively, if the necessary pieces of infrastructure are already deployed, you can register a cloud stack seamlessly through the stack wizard:
  ```bash
  zenml stack register <STACK_NAME> --provider aws
  ```
  Read more about [ZenML stacks](https://docs.zenml.io/user-guide/production-guide/understand-stacks).

  Once you have your MLOps stack configured, you can easily run workloads on it:
  ```bash
  zenml stack set <STACK_NAME>
  python run.py
  ```
  ```python
  from zenml.config import ResourceSettings, DockerSettings
  @step(
    settings={
      "resources": ResourceSettings(memory="16GB", gpu_count="1", cpu_count="8"),
      "docker": DockerSettings(parent_image="pytorch/pytorch:1.12.1-cuda11.3-cudnn8-runtime")
    }
  )
  def training(...):
  ```
  ![Workloads with ZenML](/docs/book/.gitbook/assets/readme_compute.gif)

  Create a complete lineage of who, where, and what data and models are produced.
  You’ll be able to find out who produced which model, at what time, with which data, and on which version of the code. This guarantees full reproducibility and auditability.
  ```python
  from zenml import Model
  @step(model=Model(name="classification"))
  def trainer(training_df: pd.DataFrame) -> Annotated["model", torch.nn.Module]:
  ```
  ![Exploring ZenML Models](/docs/book/.gitbook/assets/readme_mcp.gif)

  While ZenML brings a lot of value out of the box, it also integrates into your existing tooling and infrastructure without you having to be locked in.
  ```python
  from bentoml._internal.bento import bento
  @step(on_failure=alert_slack, experiment_tracker="mlflow")
  def train_and_deploy(training_df: pd.DataFrame) -> bento.Bento
  	mlflow.autolog()
  	return bento
  ```
  ![Exploring ZenML Integrations](/docs/book/.gitbook/assets/readme_integrations.gif)

  The best way to learn about ZenML is the [docs](https://docs.zenml.io/). We recommend beginning with the [Starter Guide](https://docs.zenml.io/user-guide/starter-guide) to get up and running quickly.
  If you are a visual learner, this 11-minute video tutorial is also a great start:
  [![Introductory Youtube Video](docs/book/.gitbook/assets/readme_youtube_thumbnail.png)](https://www.youtube.com/watch?v=wEVwIkDvUPs)
  And finally, here are some other examples and use cases for inspiration:
  1. [E2E Batch Inference](examples/e2e/): Feature engineering, training, and inference pipelines for tabular machine learning.
  2. [Basic NLP with BERT](examples/e2e_nlp/): Feature engineering, training, and inference focused on NLP.
  3. [LLM RAG Pipeline with Langchain and OpenAI](https://github.com/zenml-io/zenml-projects/tree/main/llm-agents): Using Langchain to create a simple RAG pipeline.
  4. [Huggingface Model to Sagemaker Endpoint](https://github.com/zenml-io/zenml-projects/tree/main/huggingface-sagemaker): Automated MLOps on Amazon Sagemaker and HuggingFace
  5. [LLMops](https://github.com/zenml-io/zenml-projects/tree/main/llm-complete-guide): Complete guide to do LLM with ZenML

  <div align="center">
    <a href="https://www.amazon.com/LLM-Engineers-Handbook-engineering-production/dp/1836200072">
      <img src="docs/book/.gitbook/assets/llm_engineering_handbook_cover.jpg" alt="LLM Engineer's Handbook Cover" width="200"/></img>
    </a>&nbsp;&nbsp;&nbsp;&nbsp;
    <a href="https://www.amazon.com/-/en/Andrew-McMahon/dp/1837631964">
      <img src="docs/book/.gitbook/assets/ml_engineering_with_python.jpg" alt="Machine Learning Engineering with Python Cover" width="200"/></img>
    </a>
    </br></br>
  </div>
  ZenML is featured in these comprehensive guides to modern MLOps and LLM engineering. Learn how to build production-ready machine learning systems with real-world examples and best practices.

  For full functionality ZenML should be deployed on the cloud to
  enable collaborative features as the central MLOps interface for teams.
  Read more about various deployment options [here](https://docs.zenml.io/getting-started/deploying-zenml).
  Or, sign up for [ZenML Pro to get a fully managed server on a free trial](https://cloud.zenml.io/?utm_source=readme&utm_medium=referral_link&utm_campaign=cloud_promotion&utm_content=signup_link).

  ZenML has a [VS Code extension](https://marketplace.visualstudio.com/items?itemName=ZenML.zenml-vscode) that allows you to inspect your stacks and pipeline runs directly from your editor. The extension also allows you to switch your stacks without needing to type any CLI commands.
  <details>
    <summary>🖥️ VS Code Extension in Action!</summary>
    <div align="center">
    <img width="60%" src="/docs/book/.gitbook/assets/zenml-extension-shortened.gif" alt="ZenML Extension">
  </div>
  </details>

  ZenML is being built in public. The [roadmap](https://zenml.io/roadmap) is a regularly updated source of truth for the ZenML community to understand where the product is going in the short, medium, and long term.
  ZenML is managed by a [core team](https://zenml.io/company) of developers that are responsible for making key decisions and incorporating feedback from the community. The team oversees feedback via various channels,
  and you can directly influence the roadmap as follows:
  - Vote on your most wanted feature on our [Discussion
  board](https://zenml.io/discussion).
  - Start a thread in our [Slack channel](https://zenml.io/slack).
  - [Create an issue](https://github.com/zenml-io/zenml/issues/new/choose) on our GitHub repo.

  We would love to develop ZenML together with our community! The best way to get
  started is to select any issue from the `[good-first-issue`
  label](https://github.com/issues?q=is%3Aopen+is%3Aissue+archived%3Afalse+user%3Azenml-io+label%3A%22good+first+issue%22)
  and open up a Pull Request!
  If you
  would like to contribute, please review our [Contributing
  Guide](CONTRIBUTING.md) for all relevant details.

  The first point of call should
  be [our Slack group](https://zenml.io/slack-invite/).
  Ask your questions about bugs or specific use cases, and someone from
  the [core team](https://zenml.io/company) will respond.
  Or, if you
  prefer, [open an issue](https://github.com/zenml-io/zenml/issues/new/choose) on
  our GitHub repo.

  If you find ZenML helpful or interesting, please consider giving us a star on GitHub. Your support helps promote the project and lets others know that it's worth checking out.
  Thank you for your support! 🌟
  [![Star this project](https://img.shields.io/github/stars/zenml-io/zenml?style=social)](https://github.com/zenml-io/zenml/stargazers)

  ZenML is distributed under the terms of the Apache License Version 2.0.
  A complete version of the license is available in the [LICENSE](LICENSE) file in
  this repository. Any contribution made to this project will be licensed under
  the Apache License Version 2.0.
  <div>
  <p align="left">
      <div align="left">
        Join our <a href="https://zenml.io/slack" target="_blank">
        <img width="18" src="https://cdn3.iconfinder.com/data/icons/logos-and-brands-adobe/512/306_Slack-512.png" alt="Slack"/>
      <b>Slack Community</b> </a> and be part of the ZenML family.
      </div>
      <br />
      <a href="https://zenml.io/features">Features</a>
      ·
      <a href="https://zenml.io/roadmap">Roadmap</a>
      ·
      <a href="https://github.com/zenml-io/zenml/issues">Report Bug</a>
      ·
      <a href="https://zenml.io/pro">Sign up for ZenML Pro</a>
      ·
      <a href="https://www.zenml.io/blog">Read Blog</a>
      ·
      <a href="https://github.com/issues?q=is%3Aopen+is%3Aissue+archived%3Afalse+user%3Azenml-io+label%3A%22good+first+issue%22">Contribute to Open Source</a>
      ·
      <a href="https://github.com/zenml-io/zenml-projects">Projects Showcase</a>
      <br />
      <br />
      🎉 Version 0.71.0 is out. Check out the release notes
      <a href="https://github.com/zenml-io/zenml/releases">here</a>.
      <br />
      🖥️ Download our VS Code Extension <a href="https://marketplace.visualstudio.com/items?itemName=ZenML.zenml-vscode">here</a>.
      <br />
    </p>
  </div>


pkgId: a35068d16fdf9eb54288566a559a90525331e5c6619ca0ecf5f9b5ad27e944bd
name: python-zennewpy-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for zennewpy
url: https://github.com/yourusername/zennewpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zennewpy-0.2.0-1.src.rpm
location_href: Packages/python-zennewpy-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ZennewPy is a Python package for interacting with the Zenodo API, allowing users to manage depositions, metadata, and files on Zenodo.



  - Retrieve all depositions with full metadata
  - Find community identifiers
  - Set and unset depositions
  - Create, delete, and manage depositions
  - Upload and update files
  - Publish depositions
  - Create new versions of existing depositions
  - Modify metadata for both published and unpublished depositions



  ```bash
  pip install zennewpy
  ```



  1. **Create a Zenodo access token** by first logging into your account and clicking on your username in the top right corner. Navigate to "Applications" and then "+new token" under "Personal access tokens".  Keep this window open while you proceed to step 2 because **the token is only displayed once**. Note that Sandbox.zenodo is used for testing and zenodo for production. If you want to use both, create for each a token as desribed above.
  2. **Store the token** in `~/.zenodo_token` using the following command.

  ```sh

   { echo 'ACCESS_TOKEN: your_access_token_here' } > ~/.zenodo_token


   { echo 'ACCESS_TOKEN-sandbox: your_access_token_here' } > ~/.zenodo_token
  ```


  ```python
  import zennewpy


  client = zennewpy.Client(sandbox=True)






  deposition_id = client.create_new_deposition()


  client.set_deposition(deposition_id)


  metadata = {
      "title": "My Research Data",
      "description": "This dataset contains...",
      "upload_type": "dataset"
  }
  client.create_metadata(metadata)


  client.upload_file("path/to/your/file.csv")


  client.publish_deposition()
  ```





  The main class for interacting with Zenodo.

  - `__init__(self, title=None, bucket=None, deposition_id=None, sandbox=None, token=None)`
  - `get_all_depositions()`
  - `set_deposition(id_value)`
  - `create_new_deposition()`
  - `delete_deposition(deposition_id=None)`
  - `create_metadata(metadata, **kwargs)`
  - `upload_file(file_path, remote_filename=None, file_id=None)`
  - `publish_deposition()`
  - `create_new_version()`
  - `modify_metadata(metadata_updates, **kwargs)`



  ZennewPy uses a token-based authentication system. Store your Zenodo API token in a `~/.zenodo_token` file.



  Contributions to ZennewPy are welcome. Please ensure you follow the coding style and add unit tests for any new features.



  ZennewPy is a fork of zenodopy, an original project by L. Gloege. This
  package builds upon the foundational work of the original zenodopy
  library, extending and modifying its functionality while maintaining
  the core API interaction principles.



  ZennewPy is distributed under the MIT License, which allows for free use, modification, and distribution of the software, in line with the original zenodopy project's licensing.
  Key Acknowledgment: This project respectfully derives from and credits
  the original zenodopy library, preserving its open-source spirit and
  collaborative approach.



  If you use ZennewPy in your research, please cite it using the information provided in our CITATION.cff file. You can find this file in the root directory of our GitHub repository.


pkgId: a80c8fa9698d48c9b0713c8d1382133dd7986bc6d8618254b7fc240efd8f7f47
name: python-zetascale-help
arch: noarch
version: 2.7.7
epoch: 0
release: 1
summary: Development documents and examples for zetascale
url: https://github.com/kyegomez/zeta
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zetascale-2.7.7-1.src.rpm
location_href: Packages/python-zetascale-help-2.7.7-1.noarch.rpm
checksum_type: sha256
description:
  `RelativePositionBias` quantizes the distance between two positions into a certain number of buckets and then uses an embedding to get the relative position bias. This mechanism aids in the attention mechanism by providing biases based on relative positions between the query and key, rather than relying solely on their absolute positions.
  ```python
  import torch
  from torch import nn
  from zeta.nn import RelativePositionBias

  rel_pos_bias = RelativePositionBias()

  bias_matrix = rel_pos_bias(1, 10, 10)


  class MockAttention(nn.Module):
      def __init__(self):
          super().__init__()
          self.rel_pos_bias = RelativePositionBias()
      def forward(self, queries, keys):
          bias = self.rel_pos_bias(queries.size(0), queries.size(1), keys.size(1))
          
          return None  # Placeholder

  custom_rel_pos_bias = RelativePositionBias(
      bidirectional=False, num_buckets=64, max_distance=256, num_heads=8
  )
  ```

  The FeedForward module performs a feedforward operation on the input tensor x. It consists of a multi-layer perceptron (MLP) with an optional activation function and LayerNorm.
  Used in most language, multi-modal, and modern neural networks.
  ```python
  import torch
  from zeta.nn import FeedForward
  model = FeedForward(256, 512, glu=True, post_act_ln=True, dropout=0.2)
  x = torch.randn(1, 256)
  output = model(x)
  print(output.shape)
  ```

  - The BitLinear module performs linear transformation on the input data, followed by quantization and dequantization. The quantization process is performed using the absmax_quantize function, which quantizes the input tensor based on the absolute maximum value, [from the paper](https://arxiv.org/abs/2310.11453)
  ```python
  import torch
  from torch import nn
  import zeta.quant as qt
  class MyModel(nn.Module):
      def __init__(self):
          super().__init__()
          self.linear = qt.BitLinear(10, 20)
      def forward(self, x):
          return self.linear(x)

  model = MyModel()

  input = torch.randn(128, 10)

  output = model(input)

  print(output.size())  # torch.Size([128, 20])
  ```

  This is an implementation of the multi-modal Palm-E model using a decoder llm as the backbone with an VIT image encoder to process vision, it's very similiar to GPT4, Kosmos, RTX2, and many other multi-modality model architectures
  ```python
  import torch
  from zeta.structs import (
      AutoRegressiveWrapper,
      Decoder,
      Encoder,
      Transformer,
      ViTransformerWrapper,
  )
  class PalmE(torch.nn.Module):
      """
          PalmE is a transformer architecture that uses a ViT encoder and a transformer decoder.
          Args:
              image_size (int): Size of the image.
              patch_size (int): Size of the patch.
              encoder_dim (int): Dimension of the encoder.
              encoder_depth (int): Depth of the encoder.
              encoder_heads (int): Number of heads in the encoder.
              num_tokens (int): Number of tokens.
              max_seq_len (int): Maximum sequence length.
              decoder_dim (int): Dimension of the decoder.
              decoder_depth (int): Depth of the decoder.
              decoder_heads (int): Number of heads in the decoder.
              alibi_num_heads (int): Number of heads in the alibi attention.
              attn_kv_heads (int): Number of heads in the attention key-value projection.
              use_abs_pos_emb (bool): Whether to use absolute positional embeddings.
              cross_attend (bool): Whether to cross attend in the decoder.
              alibi_pos_bias (bool): Whether to use positional bias in the alibi attention.
              rotary_xpos (bool): Whether to use rotary positional embeddings.
              attn_flash (bool): Whether to use attention flash.
              qk_norm (bool): Whether to normalize the query and key in the attention layer.
          Returns:
                  torch.Tensor: The output of the model.
          Usage:
      img = torch.randn(1, 3, 256, 256)
      text = torch.randint(0, 20000, (1, 1024))
      model = PalmE()
      output = model(img, text)
      print(output)
      """
      def __init__(
          self,
          image_size=256,
          patch_size=32,
          encoder_dim=512,
          encoder_depth=6,
          encoder_heads=8,
          num_tokens=20000,
          max_seq_len=1024,
          decoder_dim=512,
          decoder_depth=6,
          decoder_heads=8,
          alibi_num_heads=4,
          attn_kv_heads=2,
          use_abs_pos_emb=False,
          cross_attend=True,
          alibi_pos_bias=True,
          rotary_xpos=True,
          attn_flash=True,
          qk_norm=True,
      ):
          super().__init__()
          
          self.encoder = ViTransformerWrapper(
              image_size=image_size,
              patch_size=patch_size,
              attn_layers=Encoder(
                  dim=encoder_dim, depth=encoder_depth, heads=encoder_heads
              ),
          )
          
          self.decoder = Transformer(
              num_tokens=num_tokens,
              max_seq_len=max_seq_len,
              use_abs_pos_emb=use_abs_pos_emb,
              attn_layers=Decoder(
                  dim=decoder_dim,
                  depth=decoder_depth,
                  heads=decoder_heads,
                  cross_attend=cross_attend,
                  alibi_pos_bias=alibi_pos_bias,
                  alibi_num_heads=alibi_num_heads,
                  rotary_xpos=rotary_xpos,
                  attn_kv_heads=attn_kv_heads,
                  attn_flash=attn_flash,
                  qk_norm=qk_norm,
              ),
          )
          
          self.decoder = AutoRegressiveWrapper(self.decoder)
      def forward(self, img: torch.Tensor, text: torch.Tensor):
          """Forward pass of the model."""
          try:
              encoded = self.encoder(img, return_embeddings=True)
              return self.decoder(text, context=encoded)
          except Exception as error:
              print(f"Failed in forward method: {error}")
              raise

  img = torch.randn(1, 3, 256, 256)
  text = torch.randint(0, 20000, (1, 1024))

  model = PalmE()
  output = model(img, text)
  print(output)
  ```

  Unet is a famous convolutional neural network architecture originally used for biomedical image segmentation but soon became the backbone of the generative AI Mega-revolution. The architecture comprises two primary pathways: downsampling and upsampling, followed by an output convolution. Due to its U-shape, the architecture is named U-Net. Its symmetric architecture ensures that the context (from downsampling) and the localization (from upsampling) are captured effectively.
  ```python
  import torch
  from zeta.nn import Unet

  model = Unet(n_channels=1, n_classes=2)

  x = torch.randn(1, 1, 572, 572)

  y = model(x)

  print(f"Input shape: {x.shape}")
  print(f"Output shape: {y.shape}")
  ```

  The VisionEmbedding class is designed for converting images into patch embeddings, making them suitable for processing by transformer-based models. This class plays a crucial role in various computer vision tasks and enables the integration of vision data into transformer architectures!
  ```python
  import torch
  from zeta.nn import VisionEmbedding

  vision_embedding = VisionEmbedding(
      img_size=224,
      patch_size=16,
      in_chans=3,
      embed_dim=768,
      contain_mask_token=True,
      prepend_cls_token=True,
  )

  input_image = torch.rand(1, 3, 224, 224)

  output = vision_embedding(input_image)

  ```

  Niva focuses on weights of certain layers (specified by quantize_layers). Ideal for models where runtime activation is variable. 👁️ Example Layers: nn.Embedding, nn.LSTM.
  ```python
  import torch
  from zeta import niva

  model = YourModelClass()

  niva(
      model=model,
      model_path="path_to_pretrainedim_weights.pt",
      output_path="quantizedim.pt",
      quant_type="dynamic",
      quantize_layers=[nn.Linear, nn.Conv2d],
      dtype=torch.qint8,
  )
  ```

  Increase model speed by 2x with this module that fuses together 2 hyper-optimized dense ops from bits and bytes and a gelu together!
  ```python
  import torch
  from zeta.nn import FusedDenseGELUDense
  x = torch.randn(1, 512)
  model = FusedDenseGELUDense(512, 1024)
  out = model(x)
  out.shape
  ```

  FusedDropoutLayerNorm is a fused kernel of dropout and layernorm to speed up FFNs or MLPS by 2X
  ```python
  import torch
  from torch import nn
  from zeta.nn import FusedDropoutLayerNorm

  model = FusedDropoutLayerNorm(dim=512)

  x = torch.randn(1, 512)

  output = model(x)

  print(output.shape)  # Expected: torch.Size([1, 512])
  ```

  Pytorch implementation of the new SSM model architecture Mamba
  ```python
  import torch
  from zeta.nn import MambaBlock

  block = MambaBlock(dim=64, depth=1)

  x = torch.randn(1, 10, 64)

  y = block(x)
  print(y.shape)

  ```

  ```python
  import torch
  from zeta.nn import Film

  film_layer = Film(dim=128, hidden_dim=64, expanse_ratio=4)

  conditions = torch.randn(10, 128)  # Batch size is 10, feature size is 128
  hiddens = torch.randn(
      10, 1, 128
  )  # Batch size is 10, sequence length is 1, feature size is 128

  modulated_features = film_layer(conditions, hiddens)

  print(modulated_features.shape)  # Should be [10, 1, 128]
  ```

  A single wrapper for torch.fx, torch.script, torch.compile, dynamic quantization, mixed precision through torch.amp, with execution time metrics all in once place!
  ```python
  import torch
  from zeta.nn import hyper_optimize
  @hyper_optimize(
      torch_fx=False,
      torch_script=False,
      torch_compile=True,
      quantize=True,
      mixed_precision=True,
      enable_metrics=True,
  )
  def model(x):
      return x @ x
  out = model(torch.randn(1, 3, 32, 32))
  print(out)
  ```

  Direct Policy Optimization employed for many RLHF applications for LLMs.
  ```python
  import torch
  from torch import nn
  from zeta.rl import DPO

  class PolicyModel(nn.Module):
      def __init__(self, dim, output_dim):
          super().__init__()
          self.fc = nn.Linear(dim, output_dim)
      def forward(self, x):
          return self.fc(x)
  dim = 10
  output_dim = 5
  policy_model = PolicyModel(dim, output_dim)

  dpo_model = DPO(model=policy_model, beta=0.1)

  preferred_seq = torch.randint(0, output_dim, (3, dim))
  unpreferred_seq = torch.randint(0, output_dim, (3, dim))

  loss = dpo_model(preferred_seq, unpreferred_seq)
  print(loss)
  ```

  A decorator that logs the execution of the pytorch model, including parameters, gradients, and memory usage.
  ```python
  from zeta.utils import verbose_execution
  import torch
  from torch import nn
  from zeta.utils.verbose_execution import verbose_execution

  @verbose_execution(log_params=True, log_gradients=True, log_memory=True)
  class YourPyTorchModel(nn.Module):
      def __init__(self):
          super().__init__()
          self.conv1 = nn.Conv2d(3, 64, 3)
          self.relu = nn.ReLU()
          self.flatten = nn.Flatten()
          self.fc = nn.Linear(64 * 222 * 222, 10)  # Adjusted input size
      def forward(self, x):
          x = self.conv1(x)
          x = self.relu(x)
          x = self.flatten(x)
          x = self.fc(x)
          return x

  model = YourPyTorchModel()
  input_tensor = torch.randn(1, 3, 224, 224)
  output = model(input_tensor)

  loss = output.sum()
  loss.backward()
  ```

  Attention 18% faster with sigmoid instead of attention. replace traditional softmax in attention with a sigmoid and a constant (not learned) scalar bias based on the sequence length.
  ```python
  import torch
  from zeta import SigmoidAttention
  from loguru import logger
  batch_size = 32
  seq_len = 128
  dim = 512
  heads = 8
  x = torch.rand(batch_size, seq_len, dim)
  mask = torch.ones(batch_size, seq_len, seq_len)  # Example mask
  sigmoid_attn = SigmoidAttention(dim, heads, seq_len)
  output = sigmoid_attn(x, mask)
  print(output.shape)
  ```

  All classes must have documentation if you see a class or function without documentation then please report it to me at kye@apac.ai,


pkgId: 40c70e3e2127ca6bccd64d93ab970e1eac54ce662e8711616c7aed812ae10209
name: python-zfs-autobackup-help
arch: noarch
version: 3.3
epoch: 0
release: 1
summary: Development documents and examples for zfs-autobackup
url: https://github.com/psy0rz/zfs_autobackup
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zfs-autobackup-3.3-1.src.rpm
location_href: Packages/python-zfs-autobackup-help-3.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/psy0rz/zfs_autobackup/workflows/Regression%20tests/badge.svg)](https://github.com/psy0rz/zfs_autobackup/actions?query=workflow%3A%22Regression+tests%22) [![Coverage Status](https://coveralls.io/repos/github/psy0rz/zfs_autobackup/badge.svg)](https://coveralls.io/github/psy0rz/zfs_autobackup)  [![Python Package](https://github.com/psy0rz/zfs_autobackup/workflows/Upload%20Python%20Package/badge.svg)](https://pypi.org/project/zfs-autobackup/)
  [![CodeQL](https://github.com/psy0rz/zfs_autobackup/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/psy0rz/zfs_autobackup/actions/workflows/codeql-analysis.yml)



  ZFS-autobackup tries to be the most reliable and easiest to use tool, while having all the features.

  You can either use it as a **backup** tool, **replication** tool or **snapshot** tool.

  You can select what to backup by setting a custom `ZFS property`. This makes it easy to add/remove specific datasets, or just backup your whole pool.

  Other settings are just specified on the commandline: Simply setup and test your zfs-autobackup command and  fix all the issues you might encounter. When you're done you can just copy/paste your command to a cron or script.

  Since it's using ZFS commands, you can see what it's actually doing by specifying `--debug`. This also helps a lot if you run into some strange problem or errors. You can just copy-paste the command that fails and play around with it on the commandline. (something I missed in other tools)

  An important feature that's missing from other tools is a reliable `--test` option: This allows you to see what zfs-autobackup will do and tune your parameters. It will do everything, except make changes to your system.



  * Works across operating systems: Tested with **Linux**, **FreeBSD/FreeNAS** and **SmartOS**.
  * Low learning curve: no complex daemons or services, no additional software or networking needed.
  * Plays nicely with existing replication systems. (Like Proxmox HA)
  * Automatically selects filesystems to backup by looking at a simple ZFS property.
  * Creates consistent snapshots. (takes all snapshots at once, atomicly.)
  * Multiple backups modes:
    * Backup local data on the same server.
    * "push" local data to a backup-server via SSH.
    * "pull" remote data from a server via SSH and backup it locally.
    * "pull+push": Zero trust between source and target.
  * Can be scheduled via simple cronjob or run directly from commandline.
  * Also supports complex backup geometries.
  * ZFS encryption support: Can decrypt / encrypt or even re-encrypt datasets during transfer.
  * Supports sending with compression. (Using pigz, zstd etc)
  * IO buffering to speed up transfer.
  * Bandwidth rate limiting.
  * Multiple backups from and to the same datasets are no problem.
  * Resillient to errors.
  * Ability to manually 'finish' failed backups to see whats going on.
  * Easy to debug and has a test-mode. Actual unix commands are printed.
  * Uses progressive thinning for older snapshots.
  * Uses zfs-holds on important snapshots to prevent accidental deletion.
  * Automatic resuming of failed transfers.
  * Easy migration from other zfs backup systems to zfs-autobackup.
  * Gracefully handles datasets that no longer exist on source.
  * Complete and clean logging.
  * All code is regression tested against actual ZFS environments.
  * Easy installation:
    * Just install zfs-autobackup via pip.
    * Only needs to be installed on one side.
    * Written in python and uses zfs-commands, no special 3rd party dependency's or compiled libraries needed.
    * No annoying config files or properties.



  Please look at our wiki to [Get started](https://github.com/psy0rz/zfs_autobackup/wiki).

  Or read the [Full manual](https://github.com/psy0rz/zfs_autobackup/wiki/Manual)



  This project was sponsored by:

  * JetBrains
  * https://rsync.net
  * [DatuX](https://www.datux.nl)


pkgId: c3c6f23e77beb7069e9afc71403e9fe41f7bd54edfcb1f61ecb774da27ad51ce
name: python-zhinst-qcodes-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for zhinst-qcodes
url: https://github.com/zhinst/zhinst-qcodes
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zhinst-qcodes-0.6.0-1.src.rpm
location_href: Packages/python-zhinst-qcodes-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  The Zurich Instruments drivers for QCoDeS (zhinst-qcodes) is a package of
  instrument drivers for devices produced by [Zurich Instruments](https://www.zhinst.com)
  for QCoDeS. [QCoDeS](http://microsoft.github.io/Qcodes) is a Python-based data
  acquisition framework developed to serve the needs of nanoelectronic device
  experiments, but not limited to that. It is intended to be used within QCoDeS
  and not as standalone package. The QCoDeS instrument drivers are based on the
  [Zurich Instruments Toolkit](https://github.com/zhinst/zhinst-toolkit). So if
  you are looking for a framework independent high level python API, zhinst-toolkit
  it the right place for you.


  The zhinst-qcodes is well tested and considered stable enough for general usage.
  The interfaces may have some incompatible changes between releases. Please check
  the changelog when updating.


  Version 0.3 is a more or less complete new driver and breaks the API compared
  to the previous version in many ways. If you upgrade from an older version take
  a look at the dedicated
  [documentation page](https://docs.zhinst.com/zhinst-qcodes/en/latest/refactoring/index.html)
  for more information.



  Install the package with pip:

  ```
  pip install zhinst-qcodes
  ```


  See the documentation page [here](https://docs.zhinst.com/zhinst-qcodes/en/latest).
  Since zhinst-qcodes is based on zhinst-toolkit and has exactly the same interface
  and functions, the [documentation](https://docs.zhinst.com/zhinst-toolkit/en/latest)
  for zhinst-toolkit can be applied nearly one to one and has much more examples.


  We welcome contributions by the community, either as bug reports, fixes and new
  code. Please use the GitHub issue tracker to report bugs or submit patches.
  Before developing something new, please get in contact with us.


  This software is licensed under the terms of the MIT license.
  See [LICENSE](LICENSE) for more detail.


pkgId: 1e46e33ec370ad21f112a314e70420727652fdb60380bcda3cd451a4efdba747
name: python-zip-me-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for zip-me
url: https://pypi.org/project/zip-me/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zip-me-1.0.0-1.src.rpm
location_href: Packages/python-zip-me-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Simple Compression**: Quickly zip files or entire directories with a single command.
  - **Custom Exclusions**: Exclude specific files or folders using patterns.
  - **Recursive Directory Support**: Automatically include subdirectories and their contents.
  - **Lightweight**: Minimal dependencies, runs fast and efficiently.


pkgId: 085c684145308793c6d958b48b1134df61d1ea2f646efa35e07ae9913560fc21
name: python-zipcode-coordinates-tz-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for zipcode-coordinates-tz
url: https://pypi.org/project/zipcode-coordinates-tz/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zipcode-coordinates-tz-0.1.3-1.src.rpm
location_href: Packages/python-zipcode-coordinates-tz-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![CI Build](https://github.com/rcolfin/zipcode-coordinates-tz/actions/workflows/ci.yml/badge.svg)](https://github.com/rcolfin/zipcode-coordinates-tz/actions/workflows/ci.yml)
  [![PyPI Version](https://img.shields.io/pypi/v/zipcode-coordinates-tz)](https://pypi.python.org/pypi/zipcode-coordinates-tz)
  [![versions](https://img.shields.io/pypi/pyversions/zipcode-coordinates-tz.svg)](ttps://github.com/rcolfin/zipcode-coordinates-tz)

  A Python package that enables converting a US Zip Code into a timezone.  This is done through the querying of the USPS API, then joining it with the zipcode-coordinates-tz data from the US Census, and finally taking the coordinates and using `timezonefinder` to determine the timezone.


  - [Geocoding Services Web Application Programming Interface (API)](https://geocoding.geo.census.gov/geocoder/Geocoding_Services_API.pdf)
  - [ZIP Codes by Area and District codes](https://postalpro.usps.com/ZIP_Locale_Detail)
  - [timezonefinder](https://timezonefinder.readthedocs.io/en/stable/)





  Run [scripts/console.sh](../scripts/console.sh) poetry install



  Run [scripts/lock.sh](../scripts/lock.sh)



  Run [scripts/console.sh](../scripts/console.sh) poetry run jupyter notebook




  ```python
  from zipcode_coordinates_tz import census, postal, timezone

  df_postal_locales = await postal.get_locales()
  df_postal_locales = df_postal_locales.loc[df_postal_locales.State == "NJ"]
  df_postal_locales = await census.get_coordinates(df_postal_locales)
  df_postal_locales = timezone.fill_timezones(df_postal_locales, fill_missing=True)
  print(df_postal_locales)
  ```

  As a CLI

  ```sh
  python -m zipcode_coordinates_tz save NJ.json --state NJ --timezones --fill
  ```



  To install zipcode-coordinates-tz from PyPI, use the following command:

      $ pip install zipcode-coordinates-tz

  You can also clone the repo and run the following command in the project root to install the source code as editable:

      $ pip install -e .


  The documentation for `zipcode-coordinates-tz` can be found [here](https://rcolfin.github.io/zipcode-coordinates-tz/) or in the project's docstrings.


pkgId: 6fb14aa4ba25a8cd3db00d80cfb03efd2e86d3796b68052097a651c931afdc88
name: python-zmc-help
arch: noarch
version: 0.1.2b2
epoch: 0
release: 1
summary: Development documents and examples for zmc
url: https://pypi.org/project/zmc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zmc-0.1.2b2-1.src.rpm
location_href: Packages/python-zmc-help-0.1.2b2-1.noarch.rpm
checksum_type: sha256
description:
  Simple library that helps connect to Zeta Technologies Mission Control app.



  To make a connection use `zmc.connect()` as either a context manager or a
  decorator:

  As a context manager:

  ```
  import zmc

  with zmc.connect():
      do_something()  # will execute while connection is established.
  ```

  As a decorator:

  ```
  import zmc

  @zmc.connect()
  def do_something():
      ...  # user implementation

  do_something()  # will execute while connection is established.
  ```

  Any code run within the context manager or decorator will only start running
  once a connection is established. (see below on how to run code to ensure a
  connection is made)



  The library enables easily sending and receiving data from the app via
  "components" found in `zmc.components`.



  Sending data is accomplished by calling specific functions on the components:

  ```
  import zmc

  graph = zmc.components.Graph("graphId")

  with zmc.connect():
      
      graph.plot(x=[0, 1, 2], y=[5, 6, 7])
  ```



  To receive values that are set from the GUI, you can access the corresponding
  component attributes as you would any other attribute or variable. When a change
  is made on the GUI, the value will automatically be changed.

  ```
  import zmc

  slider = zmc.components.Slider("sliderId")

  with zmc.connect():
      while True:
          if slider.value > 5:
              break  # Break once slider is changed above 5 on the GUI.
  ```



  A python script using the `zmc` library should not be run directly from the
  terminal. Instead, it should be run through the app (so that the app can
  establish its own side of the connection). If you do run it directly, you will
  get a timeout stating that the connection could not be established

  To run for debugging purposes, use `zmc.connect(debug=True)` which will mock out
  the connection and allow you to run the rest of your code as normal. Add `verbose=True` for more logging.


pkgId: f1503b60c8f2afc1da7d7ffdb91d08a119885832cb2729ea8be5bb2ab778687e
name: python-zndraw-help
arch: noarch
version: 0.5.7
epoch: 0
release: 1
summary: Development documents and examples for zndraw
url: https://pypi.org/project/zndraw/
rpm_license: License :: OSI Approved :: Eclipse Public License 2.0 (EPL-2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zndraw-0.5.7-1.src.rpm
location_href: Packages/python-zndraw-help-0.5.7-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Logo](https://raw.githubusercontent.com/zincware/ZnDraw/refs/heads/main/docs/source/_static/zndraw-light.svg#gh-light-mode-only)
  ![Logo](https://raw.githubusercontent.com/zincware/ZnDraw/refs/heads/main/docs/source/_static/zndraw-dark.svg#gh-dark-mode-only)

  [![zincware](https://img.shields.io/badge/Powered%20by-zincware-darkcyan)](https://github.com/zincware)
  [![PyPI version](https://badge.fury.io/py/zndraw.svg)](https://badge.fury.io/py/zndraw)
  [![DOI](https://img.shields.io/badge/arXiv-2402.08708-red)](https://arxiv.org/abs/2402.08708)
  [![codecov](https://codecov.io/gh/zincware/ZnDraw/graph/badge.svg?token=3GPCKH1BBX)](https://codecov.io/gh/zincware/ZnDraw)
  [![Discord](https://img.shields.io/discord/1034511611802689557)](https://discord.gg/7ncfwhsnm4)
  [![Documentation Status](https://readthedocs.org/projects/zndraw/badge/?version=latest)](https://zndraw.readthedocs.io/en/latest/?badge=latest)
  !['Threejs](https://img.shields.io/badge/threejs-black?style=for-the-badge&logo=three.js&logoColor=white)

  </div>


  Welcome to ZnDraw, a powerful tool for visualizing and interacting with your trajectories.



  You can install ZnDraw directly from PyPi via:

  ```bash
  pip install zndraw
  ```



  Visualize your trajectories with a single command:

  ```bash
  zndraw <file>
  ```

  > [!NOTE]
  > ZnDraw's webapp-based approach allows you to use port forwarding to work with trajectories on remote systems.

  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/darkmode/overview.png#gh-dark-mode-only "ZnDraw UI")
  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/lightmode/overview.png#gh-light-mode-only "ZnDraw UI")



  ZnDraw supports multiple users and clients. Connect one or more Python clients to your ZnDraw instance:

  1. Click on `Python access` in the ZnDraw UI.
  2. Connect using the following code:

  ```python
  from zndraw import ZnDraw

  vis = ZnDraw(url="http://localhost:1234", token="<your-token>")
  ```

  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/darkmode/python.png#gh-dark-mode-only "ZnDraw Python Client")
  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/lightmode/python.png#gh-light-mode-only "ZnDraw Python Client")

  The `vis` object provides direct access to your visualized scene. It inherits from `abc.MutableSequence`, so any changes you make are reflected for all connected clients.

  ```python
  from ase.collections import s22
  vis.extend(list(s22))
  ```



  You can modify various aspects of the visualization:

  - `vis.camera`
  - `vis.points`
  - `vis.selection`
  - `vis.step`
  - `vis.figures`
  - `vis.bookmarks`
  - `vis.geometries`

  For example, to add a geometry:

  ```python
  from zndraw import Box

  vis.geometries = [Box(position=[0, 1, 2])]
  ```

  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/darkmode/box.png#gh-dark-mode-only "ZnDraw Geometries")
  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/lightmode/box.png#gh-light-mode-only "ZnDraw Geometries")



  ZnDraw enables you to analyze your data and generate plots using [Plotly](https://plotly.com/). It automatically detects available properties and offers a convenient drop-down menu for selection.

  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/darkmode/analysis.png#gh-dark-mode-only "ZnDraw Analysis")
  ![ZnDraw UI](https://raw.githubusercontent.com/zincware/ZnDraw/main/misc/lightmode/analysis.png#gh-light-mode-only "ZnDraw Analysis")

  ZnDraw will look for the `step` and `atom` index in the [customdata](https://plotly.com/python/reference/scatter/#scatter-customdata)`[0]` and `[1]` respectively to highlight the steps and atoms.



  Make your tools accessible via the ZnDraw UI by writing an extension:

  ```python
  from zndraw import Extension

  class AddMolecule(Extension):
      name: str

      def run(self, vis, **kwargs) -> None:
          structures = kwargs["structures"]
          vis.append(structures[self.name])
          vis.step = len(vis) - 1

  vis.register(AddMolecule, run_kwargs={"structures": s22}, public=True)
  vis.socket.wait()  # This can be ignored when using Jupyter
  ```

  The `AddMolecule` extension will appear for all `tokens` and can be used by any client.



  A hosted version of ZnDraw is available at https://zndraw.icp.uni-stuttgart.de . To upload data, use:

  ```bash
  zndraw <file> --url https://zndraw.icp.uni-stuttgart.de
  ```



  To host your own version of ZnDraw, use the following `docker-compose.yaml` setup:

  ```yaml
  version: "3.9"

  services:
    zndraw:
      image: pythonf/zndraw:latest
      command: --no-standalone /src/file.xyz
      volumes:
        - /path/to/files:/src
      restart: unless-stopped
      ports:
        - 5003:5003
      depends_on:
        - redis
        - worker
      environment:
        - FLASK_STORAGE=redis://redis:6379/0
        - FLASK_AUTH_TOKEN=super-secret-token

    worker:
      image: pythonf/zndraw:latest
      entrypoint: celery -A zndraw_app.make_celery worker --loglevel=info -P eventlet
      volumes:
        - /path/to/files:/src
      restart: unless-stopped
      depends_on:
        - redis
      environment:
        - FLASK_STORAGE=redis://redis:6379/0
        - FLASK_SERVER_URL="http://zndraw:5003"
        - FLASK_AUTH_TOKEN=super-secret-token

    redis:
      image: redis:latest
      restart: always
      environment:
        - REDIS_PORT=6379
  ```

  If you want to host zndraw as subdirectory `domain.com/zndraw` you need to adjust the environmental variables as well as update `base: "/",` in the `app/vite.config.ts` before building the ap..



  If you use ZnDraw in your research and find it helpful please cite us.

  ```bibtex
  @misc{elijosiusZeroShotMolecular2024,
    title = {Zero {{Shot Molecular Generation}} via {{Similarity Kernels}}},
    author = {Elijo{\v s}ius, Rokas and Zills, Fabian and Batatia, Ilyes and Norwood, Sam Walton and Kov{\'a}cs, D{\'a}vid P{\'e}ter and Holm, Christian and Cs{\'a}nyi, G{\'a}bor},
    year = {2024},
    eprint = {2402.08708},
    archiveprefix = {arxiv},
  }
  ```



  The creation of ZnDraw was supported by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) in the framework of the priority program SPP 2363, “Utilization and Development of Machine Learning for Molecular Applications - Molecular Machine Learning” Project No. 497249646. Further funding though the DFG under Germany's Excellence Strategy - EXC 2075 - 390740016 and the Stuttgart Center for Simulation Science (SimTech) was provided.


pkgId: bac12b852bc16784a3f9718e047252f12d2b19823d91e53a526713cee0c93b84
name: python-zndraw-utils-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for zndraw-utils
url: https://pypi.org/project/zndraw-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zndraw-utils-0.1.0-1.src.rpm
location_href: Packages/python-zndraw-utils-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  The `pip install zndraw-utils` package provides additional extensions for ZnDraw.

  You can register any of the provided extensions using a CLI:

  ```console
  (.venv) $ zndraw-register md --url http://localhost:5003
  ```


pkgId: a4a16be5044e28201379cfeb5790ad0502bc4e6f62530ea0c31d514da38e0a64
name: python-znflow-help
arch: noarch
version: 0.2.4
epoch: 0
release: 1
summary: Development documents and examples for znflow
url: https://pypi.org/project/znflow/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-znflow-0.2.4-1.src.rpm
location_href: Packages/python-znflow-help-0.2.4-1.noarch.rpm
checksum_type: sha256
description:
  [![zincware](https://img.shields.io/badge/Powered%20by-zincware-darkcyan)](https://github.com/zincware)
  [![Coverage Status](https://coveralls.io/repos/github/zincware/ZnFlow/badge.svg?branch=main)](https://coveralls.io/github/zincware/ZnFlow?branch=main)
  [![PyPI version](https://badge.fury.io/py/znflow.svg)](https://badge.fury.io/py/znflow)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/zincware/ZnFlow/HEAD)
  [![Discord](https://img.shields.io/discord/1034511611802689557)](https://discord.gg/7ncfwhsnm4)



  The `ZnFlow` package provides a basic structure for building computational
  graphs based on functions or classes. It is designed as a lightweight
  abstraction layer to

  - learn graph computing.
  - build your own packages on top of it.



  ```shell
  pip install znflow
  ```





  With ZnFlow you can connect functions to each other by using the `@nodify`
  decorator. Inside the `znflow.DiGraph` the decorator will return a
  `FunctionFuture` object that can be used to connect the function to other nodes.
  The `FunctionFuture` object will also be used to retrieve the result of the
  function. Outside the `znflow.DiGraph` the function behaves as a normal
  function.

  ```python
  import znflow

  @znflow.nodify
  def compute_mean(x, y):
      return (x + y) / 2

  print(compute_mean(2, 8))


  with znflow.DiGraph() as graph:
      mean = compute_mean(2, 8)

  graph.run()
  print(mean.result)


  with znflow.DiGraph() as graph:
      n1 = compute_mean(2, 8)
      n2 = compute_mean(13, 7)
      n3 = compute_mean(n1, n2)

  graph.run()
  print(n3.result)

  ```



  It is also possible to connect classes. They can be connected either directly or
  via class attributes. This is possible by returning `znflow.Connections` inside
  the `znflow.DiGraph` context manager. Outside the `znflow.DiGraph` the class
  behaves as a normal class.

  In the following example we use a dataclass, but it works with all Python
  classes that inherit from `znflow.Node`.

  ```python
  import znflow
  import dataclasses

  @znflow.nodify
  def compute_mean(x, y):
      return (x + y) / 2

  @dataclasses.dataclass
  class ComputeMean(znflow.Node):
      x: float
      y: float

      results: float = None

      def run(self):
          self.results = (self.x + self.y) / 2

  with znflow.DiGraph() as graph:
      n1 = ComputeMean(2, 8)
      n2 = compute_mean(13, 7)
      
      n3 = ComputeMean(n1.results, n2)

  graph.run()
  print(n3.results)

  ```



  ZnFlow comes with support for [Dask](https://www.dask.org/) to run your graph:

  - in parallel.
  - through e.g. SLURM (see https://jobqueue.dask.org/en/latest/api.html).
  - with a nice GUI to track progress.

  All you need to do is install ZnFlow with Dask `pip install znflow[dask]`. We
  can then extend the example from above. This will run `n1` and `n2` in parallel.
  You can investigate the graph on the Dask dashboard (typically
  http://127.0.0.1:8787/graph or via the client object in Jupyter.)

  ```python
  import znflow
  import dataclasses
  from dask.distributed import Client

  @znflow.nodify
  def compute_mean(x, y):
      return (x + y) / 2

  @dataclasses.dataclass
  class ComputeMean(znflow.Node):
      x: float
      y: float

      results: float = None

      def run(self):
          self.results = (self.x + self.y) / 2


  client = Client()
  deployment = znflow.deployment.DaskDeployment(client=client)


  with znflow.DiGraph(deployment=deployment) as graph:
      n1 = ComputeMean(2, 8)
      n2 = compute_mean(13, 7)
      
      n3 = ComputeMean(n1.results, n2)

  graph.run()

  print(n3)

  ```



  ZnFlow supports some special features for working with lists. In the following
  example we want to `combine` two lists.

  ```python
  import znflow

  @znflow.nodify
  def arange(size: int) -> list:
      return list(range(size))

  print(arange(2) + arange(3))
  >>> [0, 1, 0, 1, 2]

  with znflow.DiGraph() as graph:
      lst = arange(2) + arange(3)

  graph.run()
  print(lst.result)
  >>> [0, 1, 0, 1, 2]
  ```

  This functionality is restricted to lists. There are some further features that
  allow combining `data: list[list]` by either using
  `data: list = znflow.combine(data)` which has an optional `attribute=None`
  argument to be used in the case of classes or you can simply use
  `data: list = sum(data, [])`.



  Inside the `with znflow.DiGraph()` context manager, accessing class attributes
  yields `znflow.Connector` objects. Sometimes, it may be required to obtain the
  actual attribute value instead of a `znflow.Connector` object. It is not
  recommended to run class methods inside the `with znflow.DiGraph()` context
  manager since it should be exclusively used for building the graph and not for
  actual computation.

  In the case of properties or other descriptor-based attributes, it might be
  necessary to access the actual attribute value. This can be achieved using the
  `znflow.get_attribute` method, which supports all features from `getattr` and
  can be imported as such:

  ```python
  from znflow import get_attribute as getattr
  ```

  Here's an example of how to use `znflow.get_attribute`:

  ```python
  import znflow

  class POW2(znflow.Node):
      """Compute the square of x."""
      x_factor: float = 0.5
      results: float = None
      _x: float = None

      @property
      def x(self):
          return self._x

      @x.setter
      def x(self, value):
          
          
          
          self._x = value * znflow.get_attribute(self, "x_factor")

      def run(self):
          self.results = self.x**2

  with znflow.DiGraph() as graph:
      n1 = POW2()
      n1.x = 4.0

  graph.run()
  assert n1.results == 4.0

  ```

  Instead, you can also use the `znflow.disable_graph` decorator / context manager
  to disable the graph for a specific block of code or the `znflow.Property` as a
  drop-in replacement for `property`.



  It is possible to create groups of `znflow.nodify` or `znflow.Nodes` independent
  from the graph structure. To create a group you can use
  `with graph.group(<name>)`. To access the group members, use
  `graph.get_group(<name>) -> znflow.Group`.

  ```python
  import znflow

  @znflow.nodify
  def compute_mean(x, y):
      return (x + y) / 2

  graph = znflow.DiGraph()

  with graph.group("grp1"):
      n1 = compute_mean(2, 4)

  assert n1.uuid in graph.get_group("grp1")
  ```



  ZnFlow includes tests to ensure compatibility with:

  - "Plain classes"
  - `dataclasses`
  - `ZnInit`
  - `attrs`
  - `pydantic` (experimental)


pkgId: ad4680a93e80e852c2fd7910fc40cffb3567a7a99e9b1eba400b54283e679205
name: python-zoidberg-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for zoidberg
url: https://pypi.org/project/zoidberg/
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zoidberg-0.2.1-1.src.rpm
location_href: Packages/python-zoidberg-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Zoidberg is a tool for generating grids for BOUT++ when using the
  Flux-Coordinate Independent (FCI) method of evaluating derivative
  parallel to a magnetic field.


pkgId: e7d573863c0620b945d9ffd3e8c4df448773f75594c8619ef9a5f1aa04f86b63
name: python-zoozl-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for zoozl
url: https://github.com/Kolumbs/zoozl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zoozl-0.1.5-1.src.rpm
location_href: Packages/python-zoozl-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  Server for chatbot services



  For basic example a chatbot plugin is provided in `zoozl.plugins` package. It is a simple chatbot that allows to play bulls & cows game. It is also a plugin that is loaded in case no configuration file is provided.



  ```bash
  python -m zoozl --conf chatbot.toml
  ```
  where `chatbot.toml` is configuration file.



  zoozl package contains modules that handle various input interfaces like websocket or http POST and a chatbot interface that must be extended by plugins. Without plugin zoozl is not able to respond to any input. Plugin can be considered as a single chat assistant to handle a specific task. Plugin can be huge and complex or simple and small. It is up to the developer to decide how to structure plugins.
  ![zoozl_package](docs/images/zoozl_package.svg)






  1. Create new toml configuration file (e.g. myconfig.toml)
  ```
  extensions = ['my_plugin_module']
  ```
  2. Make sure `my_plugin_module` is importable from within python that will run zoozl server
  3. Create file `my_plugin_module.py`
  ```
  from zoozl.chatbot import Interface

  class MyPlugin(Interface):

      aliases = ("call myplugin",)

      def consume(self, context: , package: Package):
          package.callback("Hello this is my plugin response")
  ```
  4. Start zoozl server with your configuration file and asking to bot `call myplugin` it will respond `Hello this is my plugin response`
  ```bash
  python -m zoozl --conf myconfig.toml
  ```



  Plugin must implement `consume` method that takes two arguments `context` and `package`. `context` is a InterfaceRoot object that contains information about the current chatbot state and `package` is a `Package` object that contains input message and callback method to send response back to the user.

  Plugin may define `aliases` attribute that is a tuple of strings that are used to call the plugin. If `aliases` is not defined, plugin will not be called. Aliases are like commands that user can call to interact with the plugin, however those commands are constructed as embeddings and then compared with input message embeddings to find the best match.

  Special aliases are help, cancel and greet. Help alias is used when there is no matching aliases found in plugins, cancel alias is used to cancel current conversation and release it from current plugin handling, greet alias is called immediately before any user message is handled.

  If there is only one plugin expected, then aliases most likely should contain all three special aliases, thus plugin will be as soon as connection is made and everytime user asks anything.



  Configuration file must conform to TOML format. Example of configuration:
  ```
  extensions = ["chatbot_fifa_extension", "zoozl.plugins.greeter"]
  websocket_port = 80  # if not provided, server will not listen to websocket requests
  author = "my_chatbot_name"  # defaults to empty string
  slack_port = 8080  # if not provided, server will not listen to slack requests
  slack_app_token = "xoxb-12333" # Mandatory if slack_port is provided, oAuth token for slack app to send requests to slack
  slack_signing_secret = "abc123" # Mandatory if slack_port is provided, secret key to verify requests from slack

  [chatbot_fifa_extension]  # would be considered as specific configuration for plugin
  database_path = "tests/tmp"
  administrator = "admin"
  ```

  Root objects like author, extensions are configuration options for chatbot system wide setup, you can pass unlimited objects in configuration, however suggested is to add a component for each plugin and separate those within components.


  * TODO: Describe plugin interface and creation
  * TODO: Add authentication and authorization interaction between chatbot and plugin


pkgId: 0f0af292f96e92998e2585737a665be957150a4025c8a134a8212a8e8d61e8cf
name: python-zosnel-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for zosnel
url: https://github.com/Zosnel/Zosnel
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zosnel-0.0.2-1.src.rpm
location_href: Packages/python-zosnel-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [Zosnel] is a project helping Python developers write code in HTML, CSS, JS all while using Python. Currently the project is in development and not ready for full public use.

  Zosnel (Zo - Snel) is a open source project made for easy creation of websites using only python.


pkgId: 2c5ae9200c244b3687b4b277351e661ac7b71e31436ab6e554664faea61aa8ba
name: python-zou-help
arch: noarch
version: 0.19.72
epoch: 0
release: 1
summary: Development documents and examples for zou
url: https://zou.cg-wire.com
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zou-0.19.72-1.src.rpm
location_href: Packages/python-zou-help-0.19.72-1.noarch.rpm
checksum_type: sha256
description:
  The Kitsu API allows to store and manage the data of your animation/VFX
  production. Through it, you can link all the tools of your pipeline and make
  sure they are all synchronized.
  A dedicated Python client, `Gazu <https://gazu.cg-wire.com>`_, allows users to
  integrate Zou into the tools. 
  |CI badge| |Downloads badge| |Discord badge|
  Features
  ~~~~~~~~
  Zou can:
  -  Store production data, such as projects, shots, assets, tasks, and file metadata.
  -  Track the progress of your artists
  -  Store preview files and version them
  -  Provide folder and file paths for any task
  -  Import and Export data to CSV files
  -  Publish an event stream of changes
  Installation and Documentation
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Installation of Zou requires the setup of third-party tools such as a database
  instance, so it is recommended to follow the documentation:
  `https://zou.cg-wire.com/ <https://zou.cg-wire.com>`__
  Specification:
  - `https://api-docs.kitsu.cloud/ <https://api-docs.kitsu.cloud>`__


pkgId: 6db261e9d90a29c1519007ebe6790bf671bd6e34a20a7d83ac1f7be072d98e80
name: python-zptess-help
arch: noarch
version: 5.4.19
epoch: 0
release: 1
summary: Development documents and examples for zptess
url: https://github.com/STARS4ALL/zptess
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zptess-5.4.19-1.src.rpm
location_href: Packages/python-zptess-help-5.4.19-1.noarch.rpm
checksum_type: sha256
description:
  Calibration tool for the [TESS-W photometer](https://tess.stars4all.eu/) and derivates.
  Works both in command line and GUI mode using Tkinter.




  1. type `zptess` to launch gui

  ![Main Panel](doc/image/main.png)
  ![About](doc/image/about.png)





  1. `zpbegin` to open a calibration batch
  2. one or several of `zptessw`, `zptas`, `zptessp` commands for calibration
  3. `zpend` to close the calibration batch
  4. `zpexport` to export the results and email




  ```bash
  zpbegin
  2021-11-06 17:36:37,397 [INFO] ============== zptool 0+unknown ==============
  2021-11-06 17:36:37,397 [INFO] Opened database file zptess.db
  2021-11-06 17:36:37,470 [INFO] A new batch has been opened
  ```



  1.a Check the test photometer identity
  ```bash
  zptessw -a {author} -o {offset} -d
  ````

  1.b Alternatively, run a full calibration run without updating neither the database nor photometer ZP
  ```bash
  zptessw -a {author} -o {offset} -t
  ````

  2.a Calibrate and update the Zero Point
  ```bash
  zptessw -a {author} -o {offset} -u
  ```

  2.a Alternatively, run a full calibration run without updating photometer ZP
  ```bash
  zptessw -a {author} -o {offset}
  ```


  ```bash
  zpend
  2021-11-06 17:37:40,678 [INFO] ============== zptool 0+unknown ==============
  2021-11-06 17:37:40,678 [INFO] Opened database file zptess.db
  2021-11-06 17:37:40,739 [INFO] Current open batch has been closed
  ```

  ```bash
  zpexport
  ```


pkgId: 804f42d99afc745e4d909f5e746a39d07c04b6dc5c9db07d797dd7d2bee0d1db
name: python-zpz-help
arch: noarch
version: 0.5.3
epoch: 0
release: 1
summary: Development documents and examples for zpz
url: https://pypi.org/project/zpz/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zpz-0.5.3-1.src.rpm
location_href: Packages/python-zpz-help-0.5.3-1.noarch.rpm
checksum_type: sha256
description:
  This repo collects some small Python utilities that I have created (or collected) in practice,
  and organizes them as a package named `zpz`.
  These utilities are not "one-off" experiments; they are really useful code.
  However, they do not form a coherent set of utilities for a particular application domain.
  It's reasonable to consider it to be mainly for the author's personal conveniences.
  However, I also refrain from making arbitrary, unnecessary breaking changes.
  New releases are made on an as-needed basis.
  To install, do
  ```
  pip install zpz
  ```
  There are some optional dependencies for specific modules.


pkgId: 34bc09de8d0cc46e649aa87b8e348fb0f758b1882df5a22a88ff9b764cb22bbc
name: python-zrjzrj-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for zrjzrj
url: https://pypi.org/project/zrjzrj/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zrjzrj-1.0.0-1.src.rpm
location_href: Packages/python-zrjzrj-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a simple example package. You can use
  [GitHub-flavored Markdown]
  to write your content.

  zrj
  2024-12-12


pkgId: 8b3a9f29c1907223e0f54522f902f467a4ba0b7a568dcbddded422731ba3baba
name: python-zse-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for zse
url: https://pypi.org/project/zse/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zse-1.2.0-1.src.rpm
location_href: Packages/python-zse-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <span style="color: lightblue;">1511 c_check bad_pun.c</span>
  <span style="color: lightblue;">dcc -Werror -o bad_pun bad_pun.c</span>


pkgId: 77e05fc47221a0ad834a29b36ae9606564f77fd1b115b2b7a49f6a9475a83245
name: python-zut
arch: noarch
version: 1.1.5
epoch: 0
release: 1
summary: Reusable Python utilities.
url: https://gitlab.com/ipamo/zut
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zut-1.1.5-1.src.rpm
location_href: Packages/python-zut-1.1.5-1.noarch.rpm
checksum_type: sha256
description:
  Reusable Python utilities.

  Zut package is published [on PyPI](https://pypi.org/project/zut/). Install with default, minimal dependencies:
  ```sh
  pip install zut[default]
  ```
  Other possible dependency specifications:
  - `pip install zut` : no dependency installed
  - `pip install zut[excel]` : dependencies to manage Excel files (including [openpyxl](https://pypi.org/project/openpyxl))
  - `pip install zut[smb]` : dependencies to access files on Samba shares from Linux, or on Windows with non-standard security context (including [smbprotocol](https://pypi.org/project/smbprotocol)) - Not required to access Samba shares from Windows using default credentials
  - `pip install zut[sqlite]` : dependencies to connect with a SQLite database ([sqlparse](https://pypi.org/project/sqlparse))
  - `pip install zut[postgresql]` (or `[pg]`) : dependencies to connect with a PostgreSQL database ([psycopg](https://pypi.org/project/psycopg) and [sqlparse](https://pypi.org/project/sqlparse))
  - `pip install zut[mariadb]` (or `[mysql]`) : dependencies to connect with a MariaDB or MySQL database ([mysqlclient](https://pypi.org/project/mysqlclient) and [sqlparse](https://pypi.org/project/sqlparse))
  - `pip install zut[sqlserver]` : dependencies to connect with a Microsoft SQL Server database (including [pyodbc](https://pypi.org/project/pyodbc) and [sqlparse](https://pypi.org/project/sqlparse))

  See also [full documentation](https://ipamo.net/zut) (including [API reference](https://ipamo.net/zut/latest/api-reference.html)).

  ```py
  from zut import configure_logging
  configure_logging()
  ```

  Write tabular data to a flexible, easily configurable output: CSV or Excel file, or tabulated stdout/stderr.
  The output file may be on the local file system or on a Windows/Samba share (including when the library is used on Linux).
  Export tabular data to stdout or to a file:
  ```py
  import sys
  from zut import tabular_dumper
  with tabular_dumper(filename or sys.stdout, headers=["Id", "Word"]) as t:
      t.append([1, "Hello"])
      t.append([2, "World"])
  ```
  Tabular data can also be exported using dictionnaries (in this case, headers will be detected automatically by the library):
  ```py
  import sys
  from zut import tabular_dumper
  with tabular_dumper(filename or sys.stdout) as t:
      t.append({'id': 1, 'name': "Hello"})
      t.append({'id': 2, 'col3': True})
  ```
  If `filename` has extension with `.xlsx`, output will be in Excel 2010 format.
  Otherwise it will be in CSV format.
  If `filename` starts with `\\`, output will be done on the corresponding Windows/Samba share.
  To indicate Samba credentials, call `configure_smb_credentials` before using function `tabular_dumper`.
  Example:
  ```py
  from zut import tabular_dumper, configure_smb_credentials
  configure_smb_credentials(user=..., password=...)
  with tabular_dumper(r"\\server\share\path\to\file") as o:
  ```

  This project is licensed under the terms of the [MIT license](https://gitlab.com/ipamo/zut/-/raw/main/LICENSE.txt).


pkgId: b49cb4ebb1e29d2f86cc9d2d55b244deb6ab3a5a75e12d08665b2bd9f2826f46
name: python-zynamon-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for zynamon
url: https://github.com/zynt3c/zynamon
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zynamon-0.0.3-1.src.rpm
location_href: Packages/python-zynamon-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Generalized & powerful time-series class and related functions.



  This library defines a powerful time-series representation based on the well-known ```pandas``` DataFrames. However, it adds meta-data as well as conveniently built-in filtering & alignment routines for both value and time dimension. Moreover, the central time-series objects can be constructed from *nearly any 1D data* such that handling of various sources in a standardised way is made possible (e.g. regularly-sampled sensor data, event logs as well as audio streams).

  As of now, this package is structured into the following modules:

  **tscore**: main file, defining classes ```TimeSeries``` and special ```TimeSpec``` as well as some helpers

  **tsutils**: routines for the automatic import of time-series data from CSV files and operators on two objects (involving a routine to make the objects "coherent" in time)

  **tsvis**: classes related to a well-defined "mass visualisation" of TimeSeries objects in automated scripts

  **batchimport**: helpers for the mass import, conversion & aggregation of data from (many!) CSV-files (e.g. proper extraction of all individual time-series hidden in event logs)

  **xutils**: special conversion utilities for CSV-files containing DFT spectra as generated by the software "CMS X-Tools" (Siemens AG).

  *Note: Structuring & naming above will be s.t. refactoring and thus change in future versions. That is, backward compatibility IS LIKELY to break soon!*

  [ Dr. Marcus Zeller | dsp4444@gmail.com | Erlangen, Germany | 2022-2024 ]

rpm_license:
  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 (GPL v3, or 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 <http://www.gnu.org/licenses/>.


pkgId: 329d2dc12cc17cc5949b552165d31fbfde9b7eebd953dfaea03594c5a2a16f85
name: python-zyxxy2-help
arch: noarch
version: 0.131
epoch: 0
release: 1
summary: Development documents and examples for zyxxy2
url: https://pypi.org/project/zyxxy2/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zyxxy2-0.131-1.src.rpm
location_href: Packages/python-zyxxy2-help-0.131-1.noarch.rpm
checksum_type: sha256
description:
   Example Package

  This is a simple scraps and clouds package. You can use
  [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
  to write your content.


pkgId: 3addc78043f0aa5cb05f35c70e8f8f3cbbe6cbb1557e22f516d01c0fd9638ac6
name: python-zzupy-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for zzupy
url: https://github.com/Illustar0/ZZU.Py
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-zzupy-0.2.0-1.src.rpm
location_href: Packages/python-zzupy-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <font color=gray size=3>郑州大学移动校园的 Python API 包装</font>



  ```shell
  pip install zzupy --upgrade
  ```


  - [x] Supwisdom
    - [x] 获取课表
  - [x] Network
    - [x] 校园网认证
  - [x] eCard
    - [x] 充值电费
    - [x] 获取校园卡余额
    - [x] 获取剩余电费

  前往 [ZZU.Py Completion Plan](https://github.com/users/Illustar0/projects/1) 查看 To Do



  [文档](https://illustar0.github.io/ZZU.Py/)仍在 In Progress ，建议使用 PyCharm 来获得最佳的开发中文档体验




  ```Py
  from zzupy import ZZUPy

  me = ZZUPy("usercode","password")
  info = me.login()
  print(f"{info[0]} {info[1]} 登录成功")
  print("校园卡余额：", str(me.eCard.get_balance()))
  print("剩余电费：", str(me.eCard.get_remaining_power("roomid")))
  print("课表JSON：", me.Supwisdom.get_courses_json("2024-12-09"))
  ```



  License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)


pkgId: 541ffd699d43e0b34a999f7a10b7779764a522c19cbf9713da5d82336c298661
name: python3-CytoDataFrame
arch: noarch
version: 0.0.15
epoch: 0
release: 1
url: https://pypi.org/project/CytoDataFrame/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-CytoDataFrame-0.0.15-1.src.rpm
location_href: Packages/python3-CytoDataFrame-0.0.15-1.noarch.rpm
checksum_type: sha256
summary:
  An in-memory data analysis format for single-cell profiles alongside their corresponding images and segmentation masks.

description:
  [![PyPI - Version](https://img.shields.io/pypi/v/cytodataframe)](https://pypi.org/project/CytoDataFrame/)
  [![Build Status](https://github.com/WayScience/CytoDataFrame/actions/workflows/run-tests.yml/badge.svg?branch=main)](https://github.com/WayScience/CytoDataFrame/actions/workflows/run-tests.yml?query=branch%3Amain)
  ![Coverage Status](https://raw.githubusercontent.com/WayScience/CytoDataFrame/main/media/coverage-badge.svg)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)

  ![](https://raw.githubusercontent.com/WayScience/coSMicQC/refs/heads/main/docs/presentations/2024-09-18-SBI2-Conference/images/cosmicqc-example-cytodataframe.png)
  _CytoDataFrame extends Pandas functionality to help display single-cell profile data alongside related images._

  CytoDataFrame is an advanced in-memory data analysis format designed for single-cell profiling, integrating not only the data profiles but also their corresponding microscopy images and segmentation masks.
  Traditional single-cell profiling often excludes the associated images from analysis, limiting the scope of research.
  CytoDataFrame bridges this gap, offering a purpose-built solution for comprehensive analysis that incorporates both the data and images, empowering more detailed and visual insights in single-cell research.

  CytoDataFrame development began within [coSMicQC](https://github.com/WayScience/coSMicQC) - a single-cell profile quality control package.



  Install CytoDataFrame from source using the following:

  ```shell

  pip install cytodataframe


  pip install git+https://github.com/WayScience/CytoDataFrame.git
  ```



  Please see our [contributing](https://WayScience.github.io/CytoDataFrame/main/contributing) documentation for more details on contributions, development, and testing.



  - [coSMicQC](https://github.com/WayScience/coSMicQC)
  - [pycytominer](https://github.com/cytomining/pycytominer)
  - [CellProfiler](https://github.com/CellProfiler/CellProfiler)
  - [CytoTable](https://github.com/cytomining/CytoTable)


pkgId: 88eddb7cf752adf233234f906158a011a3b48fd3aaeda2b6b836275b207cb926
name: python3-GibbsTS
arch: noarch
version: 1.0.2
epoch: 0
release: 1
url: https://pypi.org/project/GibbsTS/
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-GibbsTS-1.0.2-1.src.rpm
location_href: Packages/python3-GibbsTS-1.0.2-1.noarch.rpm
checksum_type: sha256
summary:
  GTS: An automated toolkit for building Gibbs thermodynamic surface with application to obtain high-pressure melting data.

description:
  - **Automated surface generation**: Builds thermodynamic surfaces for solid and liquid phases.
  - **Melting data**: Obtaining melting data for solid and liquid phases based on user-defined pressure conditions. With the *ab initio* molecular dynamics (AIMD) simulation data in the NVT (N, number of atoms; V, volume; T, temperature) ensemble and the reference point, GTS is able to rapidly present melting data, including volume, pressure, temperature, and thermodynamic potentials


pkgId: 86ef87993f4aaf5139438141c8524aa8673126dc8c033dc85406e3e74385bdbc
name: python3-MixtureMetrics
arch: noarch
version: 1.0.3
epoch: 0
release: 1
url: https://github.com/bakhras/MixtureDescriptors-I
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-MixtureMetrics-1.0.3-1.src.rpm
location_href: Packages/python3-MixtureMetrics-1.0.3-1.noarch.rpm
checksum_type: sha256
summary:
  MixtureMetrics: A Comprehensive Package to Develop Additive Numerical Features to Describe Complex Materials for Machine Learning Modeling

description:
  This Python project calculates an additive scheme for mixture descriptors of multi-component materials. The algorithm processes input from two `.csv` files and computes various mixture descriptors.



  The algorithm requires two input files:

  1. Descriptors File: Contains individual descriptors for each component.
  2. Mole Fraction File: Contains mole fraction values for each component in each mixture.
  The main function, mixture_descriptors_to_csv, processes these inputs and generates 12 CSV files, each corresponding to a different mixture descriptor metric.






  Ensure you have Python 3.x installed. You will also need `pip` to install the package.


  You can install the package in two different ways depending on whether you want to install from the local directory or directly from PyPI:

  Option 1: Install from Local Directory
     1. **Download the Package:**
        - Clone the repository or download the ZIP file from GitHub.
        - Extract the contents of the ZIP file.

     2. **Install the Package:**
        - Open a command-line interface (CLI).
        - Navigate to the directory containing the extracted package files.
        - Run the following command to install the package:

        ```bash
        pip install .
        ```
  Option 2: Install from PyPI

  If you prefer to install the package directly from PyPI, you can use the following command.

     ```bash
     pip install MixtureMetrics
     ```



  After installing the package, you can use it in your Python code. Hereâ€™s a basic example of how to use the main function:


  ```python
  from MixtureMetrics import mixture_descriptors_to_csv


  descriptors_file_path = 'path/to/descriptors.csv'
  mole_fraction_file_path = 'path/to/mole_fraction.csv'
  output_directory = 'path/to/output_directory'  # if output path string is empty or None and not provided,it defaults to use the current working directory and if the provided folder is not existed it creates a folder in the given path or in 1.1.5 working directory


  mixture_descriptors_to_csv(descriptors_file_path, mole_fraction_file_path, output_directory)
  ```


  - **descriptors_file_path**: Path to the `.csv` file containing individual descriptors for each component.

  - **mole_fraction_file_path**: Path to the `.csv` file containing mole fraction values for each component in each mixture.

  - **output_directory**: Directory where the 12 output `.csv` files will be saved.



  The code computes and saves 12 different mixture descriptors, each in its own `.csv` file within the specified output directory.



  Contributions are welcome! Please open an issue or submit a pull request if you have suggestions or improvements.


  This project is licensed under the GNU General Public License - see the LICENSE file for details.


pkgId: c573181f86bc6f387d0a7edb279ed3eae299071d6827bbb0b600dab4106567c0
name: python3-OddEven-SP
arch: noarch
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/Aarav2709/OddEven-SP
rpm_license: Apache License v2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-OddEven-SP-1.0.1-1.src.rpm
location_href: Packages/python3-OddEven-SP-1.0.1-1.noarch.rpm
checksum_type: sha256
summary:
  So, welcome to my first ever Python Project! That is a game based on Odd Even, but with a twist of Cricket!


pkgId: eaf388de1f7f162a1d2a187e3cc428866c82cb5e88166d975bb10eee85167b1f
name: python3-PySILLS
arch: noarch
version: 1.0.46
epoch: 0
release: 1
url: https://github.com/MABeeskow/PySILLS
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PySILLS-1.0.46-1.src.rpm
location_href: Packages/python3-PySILLS-1.0.46-1.noarch.rpm
checksum_type: sha256
summary:
  PySILLS is a Python-based, open source data reduction tool for the major, minor and trace element analysis of minerals as well as of fluid and melt inclusions.

description:
  I am aware of the fact that there are still some bugs and some of them can also cause a crash of the program. But, those
  bugs are the reason why I have decided to publish this pre-release version, because, as a developer, I see everywhere
  construction sites in the code, but I would like to know which ones are the most important. So, it is possible that
  different users have different ideas how a mineral or fluid inclusion analysis project should be done. I have developed
  PySILLS with my workflow in my mind. Now, the goal is to make it also applicable for your workflow.
  Let's catch the bugs and smash them! ð

  It was necessary to apply some changes concerning the saving/loading algorithm of a project. It is possible that an
  imported project does not contain any information about the acquisition time of the single measurement files. It is
  necessary to add them manually, to save the project again and to restart it finally again. If the user does not restart
  the project, it is possible that further bugs occur.

  A detailed manual about the installation of PySILLS can be found [here](https://docs.google.com/document/d/18nw22PvVRpJvcUNXSThIvXpVhTG6ePhRhZph0nDWVaY/edit?usp=sharing).
  PySILLS can be easily installed via the following command:
  <code>pip install PySILLS</code>
  Alternatively, it is possible to run PySILLS by a manual installation of Python and - if not already installed - the
  following packages:
  * numpy
  * scipy
  * pandas
  * matplotlib
  * sympy
  * (tkinter)
  In some cases, it will be necessary to install tkinter manually although it should be actually already part of your
  python version.
  ![Python](https://img.shields.io/badge/python-3670A0?style=for-the-badge&logo=python&logoColor=ffdd54) &nbsp;
  ![NumPy](https://img.shields.io/badge/numpy-%23013243.svg?style=for-the-badge&logo=numpy&logoColor=white) &nbsp;
  ![SciPy](https://img.shields.io/badge/SciPy-%230C55A5.svg?style=for-the-badge&logo=scipy&logoColor=%white) &nbsp;
  ![Pandas](https://img.shields.io/badge/pandas-%23150458.svg?style=for-the-badge&logo=pandas&logoColor=white) &nbsp;
  ![Matplotlib](https://img.shields.io/badge/Matplotlib-%23ffffff.svg?style=for-the-badge&logo=Matplotlib&logoColor=black)
  ![Sympy](https://img.shields.io/badge/SymPy-3B5526.svg?style=for-the-badge&logo=SymPy&logoColor=white) &nbsp;
  ![Windows](https://img.shields.io/badge/Windows-0078D6?style=for-the-badge&logo=windows&logoColor=white) &nbsp;
  ![macOS](https://img.shields.io/badge/mac%20os-000000?style=for-the-badge&logo=macos&logoColor=F0F0F0) &nbsp;
  ![Linux](https://img.shields.io/badge/Linux-FCC624?style=for-the-badge&logo=linux&logoColor=black)

  PySILLS can be started by running the command <code> python pysills_app.py </code>. If possible, use the newest version
  of PySILLS.

  There is unfortunately a bug concerning the GUI library tkinter and default Python version that is installed on a Mac.
  You will notice this bug for example when you click on a button and for some cases, it will work directly, and for other
  cases, you have to click several times on the button or after moving the window a little bit.
  In order to avoid this bug, there is the following workaround until Apple will fix this one day:
  1) Install the newest version of PySILLS (it will work with Python 3.12). There are several ways to do this but I would
  recommend to install it via Homebrew which is a package manager for Mac OS.
  2) Install all needed packages explicitly for this newly installed Python version, for example via pip. Example command
  for the installation of numpy for Python 3.12: <code> python3.12 -m pip install numpy </code>.
  3) If you run PySILLS now by the command <code> python3.12 pysills_app.py </code>, the previously described bug should
  not appear anymore!

  [PySILLS manual (installation)](https://docs.google.com/document/d/18nw22PvVRpJvcUNXSThIvXpVhTG6ePhRhZph0nDWVaY/)\
  [PySILLS manual (mineral analysis)](https://docs.google.com/document/d/1u5CkBJiXBnhqsdh7ooiEncuexeBWgP6WDg5X2Am6bOA/)\
  [PySILLS manual (fluid inclusion analysis)](https://docs.google.com/document/d/1GeK4aQaiP3D1Na_-7ZUZiBLfzr0wK2mq2888VtTlZIY/)\
  [PySILLS manual (melt inclusion analysis)](https://docs.google.com/document/d/15PcfBwTK-dGnMUEiuOhYsKcNpWurOAWnUiKUSeNjtN8/)
  [PySILLS on ReadTheDocs](https://pysills.readthedocs.io/en/latest/)\
  [PySILLS on Blogger](https://pysills.blogspot.com/)\
  [PySILLS on YouTube](https://www.youtube.com/@PySILLS)\
  [PySILLS on PyPi](https://pypi.org/project/PySILLS/)
  ![Blogger](https://img.shields.io/badge/Blogger-FF5722?style=for-the-badge&logo=blogger&logoColor=white) &nbsp;
  ![YouTube](https://img.shields.io/badge/YouTube-%23FF0000.svg?style=for-the-badge&logo=YouTube&logoColor=white)

  Coming soon ...


pkgId: b649a6144f242030a1e1c931001eca2380020ce693a0d331f5e71893712e54fe
name: python3-PyThermoDB
arch: noarch
version: 1.7.0
epoch: 0
release: 1
url: https://pypi.org/project/PyThermoDB/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-PyThermoDB-1.7.0-1.src.rpm
location_href: Packages/python3-PyThermoDB-1.7.0-1.noarch.rpm
checksum_type: sha256
summary:
  PyThermoDB is a lightweight and user-friendly Python package designed to provide quick access to essential thermodynamic data.

description:
  ![PyThermoDB](https://drive.google.com/uc?export=view&id=1-yWNEkK4tL1qvi8FE_4OwcLYuTF2AkPP)

  ![Downloads](https://img.shields.io/pypi/dm/PyThermoDB) ![PyPI](https://img.shields.io/pypi/v/PyThermoDB) ![Python Version](https://img.shields.io/pypi/pyversions/PyThermoDB.svg) ![License](https://img.shields.io/pypi/l/PyThermoDB) ![Read the Docs](https://img.shields.io/readthedocs/pythermodb)

  Python Thermodynamics Databook

  PyThermoDB is a lightweight and user-friendly Python package designed to provide quick access to essential thermodynamic data. Whether you're a student, researcher, or engineer, this package serves as a valuable resource for retrieving thermodynamic properties, equations, and constants from your `custom thermodynamic database` (csv files).

  Key Features:

  - **Handbook Data**: The package sources its data from well-established thermodynamics handbooks, ensuring accuracy and reliability (*updated regularly*).
  - **Custom Thermodynamic Database**: It is possible to builtin your own thermodynamic databook for your project.
  - **Minimal Dependencies**: Built with simplicity in mind, the package has minimal external dependencies, making it easy to integrate into your projects.
  - **Open Source**: Feel free to explore, contribute, and customize the package according to your needs.



  You can check the thermoDB files in the following link:

  - [⏩thermodb-demo](https://pythermodb-demo.streamlit.app/)



  You can use the following code to run `PyThermoDB` in Google Colab:

  | Version | Scripts |
  |---------|---------|
  | 1.6.0 | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1vj84afCy0qKfHZzQdvLiJRiVstiCX0so?usp=sharing) |
  | 1.5.0 | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1jWkaSJ280AZFn9t8X7_bqz_pYtY2QKbr?usp=sharing) |

  **Examples on Google Colab**

  | Example | Scripts |
  |---------|---------|
  | CO₂ Thermodynamic Data | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1mzu70kACdvoB_jO6gTGVegGtK_ssOOHq?usp=sharing) |
  | Check Component Availability | [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1HdGHS_uypEf_yzsq7fZyLZH3dWnjYVSg?usp=sharing) |



  Install PyThermoDB with pip

  ```python
  import pyThermoDB as ptdb

  print(ptdb.__version__)
  ```



  * databook reference initialization:

  ```python

  tdb = ptdb.init()
  ```

  * DATABOOK LIST:

  ```python

  db_list = tdb.list_databooks()
  print(db_list)
  ```

  * TABLE LIST:

  ```python

  tb_lists = tdb.list_tables(1)
  print(tb_lists)
  ```

  * TABLE INFO:

  ```python

  tb_info = tdb.table_info(1, 2)
  print(tb_info)
  ```

  * LOAD TABLES (before building):

  ```python

  vapor_pressure_tb = tdb.equation_load(1, 4)
  pp(vapor_pressure_tb.eq_structure(1))

  data_table = tdb.data_load(1, 2)
  pp(data_table.data_structure())
  ```

  * CHECK COMPONENT AVAILABILITY IN A TABLE:

  ```python

  comp1 = "carbon Dioxide"





  ```

  * BUILD DATA OBJECT:

  ```python

  CO2_data = tdb.build_data(comp1, 1, 2)
  pp(CO2_data.data_structure())
  pp(CO2_data.get_property(4))
  ```

  * BUILD EQUATION OBJECT:

  ```python

  eq = tdb.build_equation(comp1, 1, 4)
  pp(eq.args)
  res = eq.cal(T=298.15)
  pp(res*1e-5)
  ```



  DataTable & EquationTable saved as an object in `Carbon Dioxide.pkl`

  * BUILD THERMODB:

  ```python

  thermo_db = ptdb.build_thermodb()
  pp(type(thermo_db))


  thermo_db.add_data('general', comp1_data)

  thermo_db.add_data('heat-capacity', comp1_eq)
  thermo_db.add_data('vapor-pressure', vapor_pressure_eq)





  thermo_db.save(
      f'{comp1}', file_path='E:\\Python Projects\\pyThermoDB\\tests')
  ```

  * CHECK THERMODB:

  ```python

  pp(thermo_db.check_properties())
  pp(thermo_db.check_functions())
  ```



  `Carbon Dioxide.pkl` can be loaded as:

  * LOAD THERMODB

  ```python

  thermodb_file = 'Carbon Dioxide.pkl'
  thermodb_path = os.path.join(os.getcwd(), thermodb_file)
  pp(thermodb_path)
  ```

  * LOAD THERMODB

  ```python

  CO2_thermodb = ptdb.load_thermodb(thermodb_path)
  pp(type(CO2_thermodb))
  ```

  * CHECK THERMODB

  ```python

  pp(CO2_thermodb.check())
  ```



  * Step 1:

  Modify `yml file` by adding `CUSTOM-INTEGRAL`.

  * Step 2:

  Add a name for the new integral body.

  * Step 3:

  Add a list containing the integral body.

  ```yml
  CUSTOM-INTEGRAL:
      Cp/R:
          - A1 = parms['a0']*args['T1']
          - B1 = (parms['a1']/2)*(args['T1']**2)
          - C1 = (parms['a2']/3)*(args['T1']**3)
          - D1 = (parms['a3']/4)*(args['T1']**4)
          - E1 = (parms['a4']/5)*(args['T1']**5)
          - res1 =  A1 + B1 + C1 + D1 + E1
          - A2 = parms['a0']*args['T2']
          - B2 = (parms['a1']/2)*(args['T2']**2)
          - C2 = (parms['a2']/3)*(args['T2']**3)
          - D2 = (parms['a3']/4)*(args['T2']**4)
          - E2 = (parms['a4']/5)*(args['T2']**5)
          - res2 =  A2 + B2 + C2 + D2 + E2
          - res = res2 - res1
  ```

  * CHECK AS:

  ```python

  pp(comp1_eq.custom_integral)

  pp(comp1_eq.check_custom_integral_equation_body('Cp/R'))


  Cp_cal_custom_integral_Cp__R = comp1_eq.cal_custom_integral(
      'Cp/R', T1=298.15, T2=320)
  pp(Cp_cal_custom_integral_Cp__R)
  ```



  For any question, contact me on [LinkedIn](https://www.linkedin.com/in/sina-gilassi/)




  - [@sinagilassi](https://www.github.com/sinagilassi)


pkgId: ffdb5f03697e719a28c10d5ff608b336ae628024c678d4e3bd3a79f50a6efcc1
name: python3-SerraWatchLogger
arch: noarch
version: 0.0.10
epoch: 0
release: 1
url: https://github.com/IOTSerraWatch/SerraWatchLogger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SerraWatchLogger-0.0.10-1.src.rpm
location_href: Packages/python3-SerraWatchLogger-0.0.10-1.noarch.rpm
checksum_type: sha256
summary:
  This project was created as part of the Internet of Things (IoT) course in the Master's program in Computer Architecture at the Haute École de la Province de Liège (HEPL).


pkgId: 7244391942e99f44b4e3b2a770f13ecd4e9bcfebb99bf023a6913d2e892c32fe
name: python3-TMC-2209-Raspberry-Pi
arch: noarch
version: 0.5.6
epoch: 0
release: 1
url: https://github.com/Chr157i4n/TMC2209_Raspberry_Pi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TMC-2209-Raspberry-Pi-0.5.6-1.src.rpm
location_href: Packages/python3-TMC-2209-Raspberry-Pi-0.5.6-1.noarch.rpm
checksum_type: sha256
summary:
  this is a Python libary to drive a stepper motor with a Trinamic TMC2209 stepper driver and a Raspberry Pi

description:
  RPi.GPIO    | RASPBERRY_PI              | Pi4, Pi3 etc.
  gpiozero    | RASPBERRY_PI5             | Pi5
  Jetson.GPIO | NVIDIA_JETSON             | Nvidia Jetson
  pheriphery  | LUCKFOX_PICO              | Luckfox Pico
  pheriphery  | LUCKFOX_PICO              | Luckfox Pico
  OPi.GPIO    | ORANGE_PI                 | Orange Pi
  Those libraries are needed for this library to work. You can either install the correct library yourself.
  You can also install the needed GPIO library by specifing the Installation Parameter while installing this library:
  ```shell
  pip3 install TMC-2209-Raspberry-Pi[RASPBERRY_PI]
  ```

  Pin TMC2209 | connect to | Function
  -- | -- | --
  TX or PDN_UART with 1kOhm | TX of Raspberry Pi | send data to TMC via UART
  RX or PDN_UART directly | RX of Raspberry Pi | receive data from TMC via UART
  VDD | 3,3V of Raspberry Pi | optional, for more stable logic voltage
  GND | GND of Raspberry Pi | GND for VDD and Signals
  VM | 12V or 24V of power supply | power for the motor
  GND | GND of power supply | power for the motor
  EN | GPIO21 of Raspberry Pi | enable the motor output
  STEP | GPIO16 of Raspberry Pi | moves the motor one step per pulse
  DIR | GPIO20 of Raspberry Pi | set the direction of the motor
  DIAG | GPIO26 of Raspberry Pi | optional, for StallGuard
  ![wiring diagram](docs/images/wiring_diagram.png)
  The GPIO pins can be specific when initiating the class.
  If you test this on a breadboard, make sure to cut off the bottomside of the pins (Vref and DIAG) next to the EN pin, so that they are not shorted trough the breadboard.

  You can run the demo scripts files from the main directory with
  ```shell
  python3 -m demo.demo_script_01_uart_connection
  ```

  This only communicates with the TMC driver over UART. It should set some settings in the driver and then outputs the settings.
  When it outputs ```TMC2209: UART Communication Error```, you need to check the UART-connection.

  This script enables the raspberry GPIO output for the dir, en and step pin and then checks the TMC driver register,
  whether the driver sees them as HIGH or LOW. Because the enabled pin is activated for a short time, the motor current ouput
  will be also activated in this script for a short time.
  This script should output:
  Pin DIR:        OK
  Pin STEP:       OK
  Pin EN:         OK
  if not, check the connection of the pin.

  This script should move the motor 6 times, one revolution back and forth.

  In this script the stallguard feature of the TMC2209 is beeing setup.
  A funtion will be called, if the driver detects a stall. The function stops the current movement.
  The motor will be moved 10 revolutions. If the movement is finished unhindered, the script outputs ```Movement finished successfully```.
  If you block the motor with pliers or something similar, the the motor will stop and the script outputs ```StallGuard!``` and ```Movement was not completed```

  VACTUAL allows moving the motor by UART control. It gives the motor velocity in +-(2^23)-1 [μsteps / t]

  Multiple drivers can be addressed via UART by setting different addresses with the MS1 and MS2 pins.
  Simultaneous movement of multiple motors can be done with threaded movement.

  In this script, the movement of a stepper with threads is shown. This can be used to do other task while moving a motor, or to move several motors simultaneous.

  This script shows how you can alter the formatting of the TMC2209 log messages and redirect the log output to a file called `tmc2209_log_file.log` that will be created in the current directory.
  \
  \
  For me these baudrates worked fine: 19200, 38400, 57600, 115200, 230400, 460800, 576000.
  If the TMC2209 driver is connected to the Vmotor, the internal voltage regulator will create the Vio for the chip.
  So you don't need to connect anything to the Vio pin of the driver.

  ```python
  from TMC_2209.TMC_2209_StepperDriver import *
  tmc = TMC_2209(21, 16, 20)
  tmc.set_direction_reg(False)
  tmc.set_current(300)
  tmc.set_interpolation(True)
  tmc.set_spreadcycle(False)
  tmc.set_microstepping_resolution(2)
  tmc.set_internal_rsense(False)
  tmc.set_acceleration(2000)
  tmc.set_max_speed(500)
  tmc.set_motor_enabled(True)
  tmc.run_to_position_steps(400)
  tmc.run_to_position_steps(0)
  tmc.set_motor_enabled(False)
  ```

  If you have questions please check out the [Wiki](https://github.com/Chr157i4n/TMC2209_Raspberry_Pi/wiki) and the other issues.
  If you encounter any problems, feel free to open an issue (ENG/GER).
  Please don't send any E-Mails to me. Pls use Github, so that i don't need to answer the same question multiple times.
  I reserve the right not to answer E-Mails.
  Problem | Solution
  -- | --
  FileNotFoundError: [Errno 2] No such file or directory: '/dev/serial0' | depending on your Raspberry Pi version, you need to enable the Serial Port <br /> run `sudo raspi-config` in your terminal. <br /> there go to '3 Interface Options' -> 'P3 Serial Port' <br /> Would you like a login shell to be accessible over serial? No <br /> Would you like the serial port hardware to be enabled? Yes <br /> Finish and then reboot
  PermissionError: [Errno 13] <br /> Permission denied: '/dev/serial0' | you need to give the permission to acces the Serial Port to your current user <br /> You may need to add your user (pi) to the dialout group with `sudo usermod -a -G dialout pi` and then relog. <br /> If that does not work, make sure that your user has read/write permissions on the dev file `/dev/serial0` by calling `sudo chmod 660 /dev/serial0`.
  "TMC2209: UART Communication Error" | You can use the 'debug_script_01_uart_connection' script to get a better reading on the received bytes and troubleshoot your problem
  "TMC2209: UART Communication Error: 0 data bytes \| 4 total bytes" | only 4 total bytes received indicates, that the Raspberry Pi receives its own data, but nothing from the TMC driver. This happens if RX and TX are connected properly, but the TMC driver has no power
  "TMC2209: UART Communication Error: 0 data bytes \| 0 total bytes" | 0 total bytes received indicates, a problem with your wiring or your Raspberry Pi. This happens if TX is not connected
  "TMC2209: UART Communication Error: 4 data bytes \| 12 total bytes" | this indicates, the Raspberry Pi received only zeroes. This happens if only RX is connected and TX not
  "the Raspberry Pi received only the sended bits" or<br /> inconsistent received bits | Make sure the UART ist properly connected to the TMC driver and the driver is powered and working. <br /> Make sure login shell (console) over serial is disabled.
  ![wiring photo](docs/images/wiring_photo.jpg)

  The code to run the stepper motor is based on the code of the [AccelStepper Library from Mike McCauley](http://www.airspayce.com/mikem/arduino/AccelStepper).
  The code for the UART communication is based on this [code from troxel](https://github.com/troxel/TMC_UART).
  My goal is to make a library, that can run a stepper motor with a TMC2209 stepper driver and can write the setting in the register of the TMC2209, entirely in Python.
  The main focus for this are Test setups, as Python is not fast enough for high motor speeds.

  If you encounter any problem, feel free to open an issue on the Github [issue page](https://github.com/Chr157i4n/TMC2209_Raspberry_Pi/issues).
  Feedback will keep this project growing and I encourage all suggestions.
  Feel free to submit a pull request on the dev branch.


pkgId: 7a9cb8faeae90b7f9181c35082aa25682a64417dd34741a16d251461960eb850
name: python3-TMDBTraktSyncer
arch: noarch
version: 1.7.3
epoch: 0
release: 1
url: https://github.com/RileyXX/TMDB-Trakt-Syncer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TMDBTraktSyncer-1.7.3-1.src.rpm
location_href: Packages/python3-TMDBTraktSyncer-1.7.3-1.noarch.rpm
checksum_type: sha256
summary:
  A python script that syncs user watchlist and ratings for Movies, TV Shows and Episodes both ways between Trakt and TMDB.

description:
  This Python script syncs user watchlist and ratings for Movies, TV Shows, and Episodes both ways between [Trakt](https://trakt.tv/) and [TMDB](https://www.themoviedb.org/). Data already set will not be overwritten. Ratings and watchlist sync are both optional. The user will be prompted to enter their settings and api keys on first run.

  The script is compatible on any operating system that supports Python v3.6 or later, including Windows, Linux, Mac, and ChromeOS. If you're interested in syncing ratings between Trakt, Plex, IMDB, and TMDB, I recommend the following projects: [PlexTraktSync](https://github.com/Taxel/PlexTraktSync), [IMDB-Trakt-Syncer](https://github.com/RileyXX/IMDB-Trakt-Syncer), and [TMDB-Trakt-Syncer](https://github.com/RileyXX/TMDB-Trakt-Syncer). See below for my other [recommended projects](https://github.com/RileyXX/TMDB-Trakt-Syncer?tab=readme-ov-file#other-recommended-projects).


  1. Install [Python](https://www.python.org/downloads/) (v3.6 or later). During installation, tick the box for adding Python to your PATH variable.
  2. Install the script by running `python -m pip install TMDBTraktSyncer` in command line.
  3. Login to [Trakt](https://trakt.tv/oauth/applications) and create a new API application named `TMDbTraktSyncer`. In the "Redirect uri" field, enter `urn:ietf:wg:oauth:2.0:oob`, then save the application.
  4. Login to [TMDB](https://www.themoviedb.org/settings/api/) and create a new API application. Choose "Developer" and accept the terms. Fill out the application form as follows:
     - Type of use: `Personal`
     - Application name: `TMDB-Trakt-Sync`
     - Application URL: `https://github.com/RileyXX/TMDB-Trakt-Syncer`
     - Application summary: `Use TMDB API and Trakt API to sync user watchlists and ratings between platforms.`
     - Fill in the rest of the fields as desired and submit the form. Your API keys will be generated instantly.
  5. Run the script by running `TMDBTraktSyncer` in the command line.
  6. Follow the prompts during the first run. You will need to enter your Trakt `client ID` and `client secret` from step 3, as well as your `tmdb_v4_token` from step 4. Please note that these details are saved insecurely as `credentials.txt` in the same folder as the script.
  7. Setup is complete. The script will continue running and syncing your ratings. You can monitor its progress in the command line. See below for [setting up automation](https://github.com/RileyXX/TMDB-Trakt-Syncer?tab=readme-ov-file#for-setting-up-automation-see-the-following-wiki-pages).


  ```
  python -m pip install TMDBTraktSyncer
  ```
  _Run in your operating system's native command line._

  ```
  TMDBTraktSyncer
  ```
  _Run in your operating system's native command line._

  ```
  python -m pip install TMDBTraktSyncer --upgrade
  ```
  _Run in your operating system's native command line._

  ```
  python -m pip uninstall TMDBTraktSyncer
  ```
  _Run in your operating system's native command line._


  ```
  python -m pip install TMDBTraktSyncer==VERSION_NUMBER
  ```
  _Replace `VERSION_NUMBER` with your [desired version](https://github.com/RileyXX/TMDB-Trakt-Syncer/releases) (e.g. 1.0.1) and run in your operating system's native command line._


  1. Install [Python](https://www.python.org/downloads/) (v3.6 or later). During installation, tick the box for adding Python to your PATH variable.
  2. Download the latest .zip from the [releases page](https://github.com/RileyXX/TMDB-Trakt-Syncer/releases) and extract it to the desired directory.
  3. Login to [Trakt](https://trakt.tv/oauth/applications) and create a new API application named `TMDBTraktSyncer`. In the "Redirect uri" field, enter `urn:ietf:wg:oauth:2.0:oob`, then save the application.
  4. Login to [TMDB](https://www.themoviedb.org/settings/api/) and create a new API application. Choose "Developer" and accept the terms. Fill out the application form as follows:
     - Type of use: `Personal`
     - Application name: `TMDB-Trakt-Sync`
     - Application URL: `https://github.com/RileyXX/TMDB-Trakt-Syncer`
     - Application summary: `Use TMDB API and Trakt API to sync user watchlists and ratings between platforms.`
     - Fill in the rest of the fields as desired and submit the form. Your API keys will be generated instantly.
  5. Run `TMDBTraktSyncer.py` or open the terminal and navigate to the folder where `TMDBTraktSyncer.py` is located, then run `TMDBTraktSyncer.py` in the terminal.
  6. Follow the prompts during the first run. You will need to enter your Trakt `client ID` and `client secret` from step 3, as well as your `tmdb_v4_token` from step 4. Please note that these details are saved insecurely as `credentials.txt` in the same folder as the script.
  7. Setup is complete. The script will continue running and syncing your ratings. You can monitor its progress in the command line. See below for [setting up automation](https://github.com/RileyXX/TMDB-Trakt-Syncer#for-setting-up-automation-see-the-following-wiki-pages).


  - Setup Automation for:
     - [Windows](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-Windows)
     - [Linux](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-Linux)
     - [macOS](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-macOS)
  - Python Script to Update all Packages with Pip (Windows, Linux, Mac, ChromeOS, etc.) [Link #1](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Python-Script-to-Update-all-Packages-with-Pip-\(Windows,-Linux,-Mac,-ChromeOS,-etc\))


  * If any of your details change (passwords, logins, API keys, etc.), simply open `credentials.txt`, modify your details, save it and then run the script again. Alternatively, delete `credentials.txt` to reset the script and it will prompt you to enter your new details on the next run.
  * Add support for review/comment sync [Issue #1](https://github.com/RileyXX/TMDB-Trakt-Syncer/issues/1)


  ![Demo](https://i.imgur.com/5LI04O2.png)


  If you find my scripts helpful, you can become a [sponsor](https://github.com/sponsors/RileyXX) and support my projects! If you need help with a project, open an issue, and I'll do my best to assist you. For other inquiries and custom projects, you can contact me on [Twitter](https://twitter.com/RileyxBell).


  - Cashapp: [$rileyxx](https://cash.app/$rileyxx/)
  - Venmo: [@rileyxx](https://account.venmo.com/u/rileyxx)
  - Bitcoin: `bc1qrjevwqv49z8y77len3azqfghxrjmrjvhy5zqau`


  * [PyPi](https://pypi.org/project/TMDBTraktSyncer/)
  * [Reddit](https://www.reddit.com/r/trakt/comments/13jlu4r/tmdb_trakt_rating_syncer_tool_2_way_sync/)

  <br>

  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  | Project Name | Description |
  |--------------|-------------|
  | [PlexTraktSync](https://github.com/Taxel/PlexTraktSync) | A script that syncs user watch history and ratings between Trakt and Plex (without needing a PlexPass or Trakt VIP subscription). |
  | [IMDB-Trakt-Syncer](https://github.com/RileyXX/IMDB-Trakt-Syncer) | A script that syncs user watchlist, ratings, and reviews both ways between Trakt and IMDB. |
  | [TMDB-Trakt-Syncer](https://github.com/RileyXX/TMDB-Trakt-Syncer) | A script that syncs user watchlist and ratings both ways between Trakt and TMDB. |
  | [PlexPreferNonForcedSubs](https://github.com/RileyXX/PlexPreferNonForcedSubs) | A script that sets all movies and shows in your local Plex library to English non-forced subtitles by default. |
  | [Casvt / AudioSubChanger](https://github.com/Casvt/Plex-scripts/blob/main/media_management/audio_sub_changer.py) | A script with advanced options for changing audio & subtitle tracks in Plex. |
  | [Casvt / PlexAutoDelete](https://github.com/Casvt/Plex-scripts/blob/main/media_management/plex_auto_delete.py) | A script for automatically deleting watched content from Plex. |
  | [universal-trakt-scrobbler](https://github.com/trakt-tools/universal-trakt-scrobbler) | An extension that automatically scrobbles TV shows and Movies from several streaming services to Trakt. |
  | [Netflix-to-Trakt-Import](https://github.com/jensb89/Netflix-to-Trakt-Import) | A tool to import your Netflix viewing history into Trakt. |
  | [trakt-tv-backup](https://darekkay.com/blog/trakt-tv-backup/) | A command-line tool for backing up your Trakt.tv data. |
  | [blacktwin / JBOPS](https://github.com/blacktwin/JBOPS) | A collection of scripts and tools for enhancing and automating tasks in Plex. |
  | [Casvt / Plex-scripts](https://github.com/Casvt/Plex-scripts) | A collection of useful scripts for Plex automation and management. |
  | [trakt---letterboxd-import](https://github.com/jensb89/trakt---letterboxd-import) | A tool to import your Letterboxd ratings and watchlist into Trakt. |
  | [TraktRater](https://github.com/damienhaynes/TraktRater/) | A tool to help users transfer user episode, show, and movie user ratings and watchlists from multiple media database sites around the web. |
  | [TvTimeToTrakt](https://github.com/lukearran/TvTimeToTrakt) | A tool to sync your TV Time watch history with Trakt.tv. |
  | [Plex Media Server](https://www.plex.tv/media-server-downloads/#plex-app) | A media server software to organize and stream your personal media collection. |
  | [Radarr](https://github.com/Radarr/Radarr) | A movie collection manager and downloader for various platforms. |
  | [Sonarr](https://github.com/Sonarr/Sonarr) | A TV show collection manager and downloader for various platforms. |
  | [Jackett](https://github.com/Jackett/Jackett) | A proxy server that provides API support for various torrent trackers commonly used with Radarr and Sonarr. |
  | [qBittorrent](https://github.com/qbittorrent/qBittorrent) | A free and open-source BitTorrent client. |
  | [AirVPN](https://airvpn.org/) | A VPN client with port forwarding support. Great VPN for torrents. |
  | [Overseerr](https://github.com/sct/overseerr) | A request management and media discovery tool for your home media server. |
  | [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) | A reverse proxy solution to bypass Cloudflare protection and access websites commonly used with Jackett. |
  | [yt-dlp](https://github.com/yt-dlp/yt-dlp) | A command-line program to download videos from YouTube and other sites. |


pkgId: 86c2605f9138a30d5e80f9900b0f034b55031326edcc512578b04a35329134cf
name: python3-Utils-RAG
arch: noarch
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/Fangzhou-Code/Utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Utils-RAG-0.1.0-1.src.rpm
location_href: Packages/python3-Utils-RAG-0.1.0-1.noarch.rpm
checksum_type: sha256
summary:
  Here is an enhanced version of the LocalEmbeddings class that provides similar functionality to the OpenAI embedding model and includes more features and detailed comments in English and Chinese

description:
  Mimic langchain to customize some tools for working with local models





  Here is an enhanced version of the LocalEmbeddings class that provides similar functionality to the OpenAI embedding model and includes more features and detailed comments in English and Chinese: | 以下是增强版的 LocalEmbeddings 类，它提供了与 OpenAI 嵌入模型类似的功能，并且包括更多特性和详细的中英文注释：

  * **Initializing the Local Model | 初始化本地嵌入模型**

  ```python



  local_embeddings = EnhancedLocalEmbeddings(model_path="sentence-transformers/all-MiniLM-L6-v2")



  local_embeddings_hf = EnhancedLocalEmbeddings(
      model_path="bert-base-uncased",
      tokenizer_path="bert-base-uncased"
  )
  ```

  * **Embedding Single Text | 嵌入单个文本**

  ```python
  embedding = local_embeddings.embed_text("The quick brown fox jumps over the lazy dog.")
  print("单文本嵌入结果 | Single text embedding:", embedding[:10])  # 打印前 10 个维度
  ```

  * **Embedding Multiple Texts | 嵌入多个文本**

  ```python
  texts = ["Text 1", "Text 2"]
  embeddings = local_embeddings.embed_documents(texts)
  print("多文本嵌入结果 | Multiple text embeddings:", [embedding[:10] for embedding in embeddings])
  ```

  * **Embedding Single Texts Tsynchronously | 异步嵌入单个文本**

  ```python
  import asyncio
  async def async_example():
      embedding = await local_embeddings.aembed_text("Async embedding example.")
      print("异步单文本嵌入结果 | Async single text embedding:", embedding[:10])

  asyncio.run(async_example())

  ```

  * **Embedding Multipes Texts Tsynchronously | 异步嵌入单个文本**

  ```python
  import asyncio


  async def async_example():
      texts = ["Text 1 for async.", "Text 2 for async."]
      embeddings = await local_embeddings.aembed_documents(texts)
      print("异步多文本嵌入结果 | Async multiple text embeddings:", [embedding[:10] for embedding in embeddings])

  asyncio.run(async_example())

  ```

  * **Embedded Query Text | 嵌入查询文本**

  ```python
  query = "What is the meaning of life?"
  query_embedding = local_embeddings.embed_query(query)
  print("查询嵌入结果 | Query embedding:", query_embedding[:10])
  ```

  * **Batch Embedding of Multiple Text | 批量嵌入多个文本**

  ```python
  large_texts = ["Sample text " + str(i) for i in range(100)]
  batch_embeddings = local_embeddings.embed_batch(large_texts, batch_size=16)
  print("批量嵌入结果 | Batch embeddings:", [embedding[:10] for embedding in batch_embeddings[:3]])
  ```

  * **Direct Call Example | 直接调用实例**

  ```python
  texts = ["Direct call example 1.", "Direct call example 2."]
  embeddings = local_embeddings(texts)
  print("直接调用嵌入结果 | Direct call embeddings:", [embedding[:10] for embedding in embeddings])
  ```


pkgId: 154c9c0107dba3cfd829a88c88a90275eca00c3697ddb8de04d30a7df98f0421
name: python3-acceldata-airflow-sdk
arch: noarch
version: 3.16.0
epoch: 0
release: 1
url: https://pypi.org/project/acceldata-airflow-sdk/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-acceldata-airflow-sdk-3.16.0-1.src.rpm
location_href: Packages/python3-acceldata-airflow-sdk-3.16.0-1.noarch.rpm
checksum_type: sha256
summary:
  ADOC is a complete solution to observe the quality of the data present in your data lake and warehouse. Using ADOC, you can ensure that high-quality data backs your business decisions.


pkgId: 68c09b868a996ffef236216f0e6cb8927900e419e5b25b2640ab0453832b1228
name: python3-actinia-module-plugin
arch: noarch
version: 2.7.0
epoch: 0
release: 1
url: https://github.com/mundialis/actinia-module-plugin
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-actinia-module-plugin-2.7.0-1.src.rpm
location_href: Packages/python3-actinia-module-plugin-2.7.0-1.noarch.rpm
checksum_type: sha256
summary:
  A (RESTFUL) Flask application which adds module self-description and process-chain-template management to actinia-core

description:
  You can run actinia-module-plugin as actinia-core plugin.


  For installation or DEV setup, see docker/README.md.


  see actinia-module.md





  __insprired by [this](https://hynek.me/articles/sharing-your-labor-of-love-pypi-quick-and-dirty/)__

  to create a shippable wheel, run
  ```bash
  pip3 install --upgrade pip pep517
  python3 -m pep517.build .
  ```



  [(MAJOR.MINOR.PATCH)](https://semver.org/)


  in any module, import `from actinia_module_plugin.resources.logging import log` and call logger with `log.info("my info i want to log")`



  You can run the tests in the actinia-modules-plugin-test docker. For that you can comment the execution of the test in the docker/actinia-modules-plugin-test/Dockerfile `RUN ./tests_with_redis.sh` and run the following commands:
  ```bash
  docker build -f docker/actinia-module-plugin-test/Dockerfile -t actinia-module-plugin-test .


  docker run -it actinia-module-plugin-test -i

  cd /src/actinia-module-plugin/


  ./tests_with_redis.sh
  ```


pkgId: 7e6dd4a86e356e86ef6c3a8356bcdbb2ad2175773beef7c28186b718965447f8
name: python3-adaptive-shots
arch: noarch
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/gokhanmeteerturk/adaptive-shots
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-adaptive-shots-0.1.0-1.src.rpm
location_href: Packages/python3-adaptive-shots-0.1.0-1.noarch.rpm
checksum_type: sha256
summary:
  A Python package for a simple adaptive few-shots prompting engine using a contextual combinatorial bandits algorithm.

description:
  ![build status](https://github.com/gokhanmeteerturk/adaptive-shots/actions/workflows/test.yml/badge.svg?branch=main)
  ![Python](https://img.shields.io/pypi/pyversions/adaptive-shots.svg)
  [![codecov](https://codecov.io/github/gokhanmeteerturk/adaptive-shots/branch/main/graph/badge.svg?token=375FXNSAFH)](https://codecov.io/github/gokhanmeteerturk/adaptive-shots) ![PyPI](https://img.shields.io/pypi/v/adaptive-shots) ![License](https://img.shields.io/pypi/l/adaptive-shots) ![Downloads](https://img.shields.io/pypi/dm/adaptive-shots)

  <p align="center">  gokhanmeteerturk/adaptive-shots </p>
  <p align="center">  <a href="https://github.com/gokhanmeteerturk/adaptive-shots">Github Repo</a> | Documentation (in progress) </p>



  Adaptive Shots is a Python package that turns your prompts into <ins>few-shots prompts</ins> on the fly.

  It automatically selects the most relevant prompt&answer pairs from the database based on what worked well before. Adaptive-shots package uses [reinforcement learning](https://en.wikipedia.org/wiki/Reinforcement_learning) algorithm [UCB1-Tuned](https://homes.di.unimi.it/~cesabian/Pubblicazioni/ml-02.pdf) and learns from user feedback to improve its selections over time by using the numerical feedback as a reward.

  This package implements UCB1-Tuned, but with a contextual cosine similarity of prompts to dynamically select and rank the most relevant and well performing old prompts for a given prompt text.

  Initially designed for my Intelligent Tutoring System (ITS) project, the package is generalizable for any scenario requiring adaptive, reinforcement-learning-based prompt management.



  - **Sentence transformers** for generating vector representations.
    Defaults to `all-MiniLM-L6-v2` (384 dimensional dense vector space) but can be configured easily.
  - **SQLite Vector Search** with [sqlite-vec](https://github.com/asg017/sqlite-vec). (Cosine distance is used)
  - **Exploration vs Exploitation**.


  <p align="center">
  <img src="https://github.com/user-attachments/assets/20688df7-b89f-471a-8562-35fa29b10db5"/>
  </p>


  ```bash
  pip install adaptive-shots
  ```



  Core feature, few-shots prompt generation, looks like this:
  ```python
  shot_list = db.get_best_shots(
    prompt='Who is the author of Twelfth Night?',
    domain='geography',limit=2
  )
  ```
  You can then use the returned list for message generation:
  ```python
  shot_list.to_messages()
  ```
  ```js
  // Output:
  [
    {"role": "user", "content": "Who wrote Hamlet?"},
    {"role": "assistant", "content": "William Shakespeare"},
    {"role": "user", "content": "Who wrote Oedipus Rex?"},
    {"role": "assistant", "content": "Sophocles"}
  ]
  ```



  ```python
  from adaptive_shots import initialize_adaptive_shot_db
  from openai import OpenAI


  db = initialize_adaptive_shot_db('./shots.db')
  client = OpenAI()


  db.register_prompt(
      prompt='What is the capital of France?',
      answer='Paris',
      rating=9.5,
      domain='geography'
  )


  user_query = 'What is the capital of Germany?'
  few_shots_prompt, shot_list = db.create_few_shots_prompt(
      prompt=user_query,
      domain='geography',
      limit=1
  )

  print(few_shots_prompt)

  """
  Prompt: What is the capital of France?
  Answer: Paris

  Prompt: What is the capital of Germany?
  Answer:
  """


  response = client.chat.completions.create(
      model='gpt-4',
      messages=[
        *shot_list.to_messages(),
        {"role": "user", "content": user_query},
      ]
  )
  answer = response.choices[0].message.content


  db.register_prompt(
      prompt=user_query,
      answer=answer,
      rating=9.0, # ideally you should receive this from the user
      domain='geography',
      used_shots=shot_list
  )
  ```






  Registers a new prompt-answer pair and updates the ratings of used shots.


  Generates a few-shot prompt using the best-performing relevant examples.


  Generates a one-shot prompt using the single best-matching example.


  Retrieves the optimal set of shots using the UCB algorithm.



  This work is licensed under the GNU 3 - see the LICENSE file for details.



  If you use this package in your research, please cite:

  ```bibtex
  @software{erturk2024adaptive,
    author       = {Ertürk, Gökhan Mete},
    title        = {Adaptive-Shots: A Contextual Combinatorial Bandit Approach to Few-Shot Prompt Selection},
    year         = {2024},
    url          = {https://github.com/gokhanmeteerturk/adaptive-shots}
  }
  ```


pkgId: 877dd269b964f93033ec28cba27a8dbdf5465dac191676033d109d8a025245b6
name: python3-airports
arch: noarch
version: 0.1.1
epoch: 0
release: 1
url: https://github.com/berubejd/airports
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-airports-0.1.1-1.src.rpm
location_href: Packages/python3-airports-0.1.1-1.noarch.rpm
checksum_type: sha256
summary:
  A comprehensive Python library for airport data management and querying heavily influenced by Tim Rogers' Airports gem. This library provides fast, efficient lookups for airport information using IATA codes, ICAO codes, cities, regions, and countries.

description:
  A comprehensive Python library for airport data management and querying heavily influenced by [Tim Rogers' Airports gem](https://github.com/timrogers/airports). This library provides fast, efficient lookups for airport information using IATA codes, ICAO codes, cities, regions, and countries.



  - Efficient lookup of airports by:
    - IATA code (e.g., "LAX")
    - ICAO code (e.g., "KLAX")
    - City name (e.g., "Los Angeles")
    - City code (e.g., "LAX")
    - Region/State (e.g., "California")
    - Region code (e.g., "US-CA")
    - Country (e.g., "United States")
    - Country code (e.g., "US")
  - Fuzzy matching for city names
  - Distance calculation between airports using the Haversine formula
  - Lazy loading of data for optimal memory usage
  - Type hints for better IDE support
  - Comprehensive error handling



  ```bash
  pip install airports
  ```



  ```python
  from airports import Airports


  airports = Airports()


  lax = airports.find_by_iata_code("LAX")
  print(f"Found {lax['name']} in {lax['city']}, {lax['country']}")


  nyc_airports = airports.find_all_by_city_code("NYC")
  for airport in nyc_airports:
      print(f"{airport['name']} ({airport['iata']})")


  distance = airports.distance_between("JFK", "LAX")
  print(f"Distance: {distance:.1f} km")
  ```







  - `find_by_iata_code(iata_code: str) -> Optional[Dict]`
    - Find airport by 3-letter IATA code
    - Returns None if not found

  - `find_by_icao_code(icao_code: str) -> Optional[Dict]`
    - Find airport by 4-letter ICAO code
    - Returns None if not found



  - `find_all_by_city(city_name: str) -> List[Dict]`
    - Find all airports in a given city
    - Case-insensitive search

  - `find_all_by_city_code(city_code: str) -> List[Dict]`
    - Find all airports with a specific 3-letter city code
    - Returns empty list if none found

  - `fuzzy_find_city(city_name: str, cutoff: float = 0.6) -> List[Dict]`
    - Find airports in cities with names similar to input
    - Adjustable similarity threshold (cutoff)



  - `find_all_by_region(region_name: str) -> List[Dict]`
    - Find all airports in a given region/state
    - Case-insensitive search

  - `find_all_by_region_code(region_code: str) -> List[Dict]`
    - Find all airports by region code (e.g., "US-NY")
    - Returns empty list if none found

  - `find_all_by_country(country_name: str) -> List[Dict]`
    - Find all airports in a given country
    - Case-insensitive search

  - `find_all_by_country_code(country_code: str) -> List[Dict]`
    - Find all airports by 2-letter country code
    - Returns empty list if none found



  - `distance_between(airport1: Union[str, Dict], airport2: Union[str, Dict]) -> Optional[float]`
    - Calculate distance between two airports in kilometers
    - Accept either IATA codes or airport dictionaries
    - Returns None if either airport not found or missing coordinates



  - `iata_codes: List[str]` - Get all IATA codes in dataset
  - `icao_codes: List[str]` - Get all ICAO codes in dataset
  - `city_codes: List[str]` - Get all city codes in dataset



  Each airport is represented as a dictionary with the following fields:

  ```python
  {
      
      "name": str,             # Full airport name
      "city": str,             # City name
      "city_code": str,        # IATA city code
      "country": str,          # Country name
      "iso_country_code": str, # ISO 3166-1 country code
      "region": str,           # Region/state name
      "iso_region_code": str,  # ISO 3166-2 region code

      
      "iata": str,             # IATA airport code
      "icao": str,             # ICAO airport code

      
      "latitude": float,       # Latitude in decimal degrees
      "longitude": float,      # Longitude in decimal degrees
      "altitude": int,         # Altitude in feet

      
      "tz_name": str,          # Timezone
      "utc_offset": float,     # UTC offset
      "dst": str,              # Daylight savings region type

      
      "type": str,             # Airport type
  }
  ```



  The library implements robust error handling:

  - Invalid IATA codes (not 3 letters) raise ValueError
  - Invalid ICAO codes (not 4 letters) raise ValueError
  - Invalid city codes (not 3 letters) raise ValueError
  - Invalid region codes (not 4-6 characters) raise ValueError
  - Invalid country codes (not 2 letters) raise ValueError





  ```
  .
  ├── LICENSE.txt
  ├── README.md
  ├── airports
  │   ├── __init__.py
  │   ├── airports.py
  │   ├── data
  │   │   ├── airports.json
  │   │   └── incoming
  │   └── merge.py
  ├── pyproject.toml
  ├── requirements-dev.txt
  └── tests
      └── test_airports.py
  ```



  1. Clone the repository:
  ```bash
  git clone https://github.com/yourusername/airports.git
  cd airports
  ```

  2. Install development dependencies:
  ```bash
  pip install -r requirements-dev.txt
  ```

  3. Run tests:
  ```bash
  pytest tests/
  ```



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  - Data sourced from multiple airport project databases
    - [airports - Tim Rogers](https://github.com/timrogers/airports)
    - [airports-py - Aashish Vivekanand](https://github.com/aashishvanand/airports-py)

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


pkgId: 9484d1c4c17b178365a4e905a11e047878929541feef38a1943382e9d24e3ad1
name: python3-ajc27-freemocap-blender-addon
arch: noarch
version: 2024.12.1033
epoch: 0
release: 1
url: https://freemocap.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ajc27-freemocap-blender-addon-2024.12.1033-1.src.rpm
location_href: Packages/python3-ajc27-freemocap-blender-addon-2024.12.1033-1.noarch.rpm
checksum_type: sha256
summary:
  A Blender add-on for loading and visualizing motion capture data recorded with the FreeMoCap software (https://freemocap.org)

description:
  <p align="center">
      <img src="https://github.com/freemocap/freemocap/assets/15314521/da1af7fe-f808-43dc-8f59-c579715d6593" height="240" alt="Project Logo">
  </p>


  <h3 align="center">FreeMoCap Blender Addon</h3>



  <p align="center">

  <a href="https://doi.org/10.5281/zenodo.7233714">
      <img src="https://zenodo.org/badge/DOI/10.5281/zenodo.7233714.svg" alt=DOI-via-Zenodo.org>
    </a>

  <a href="https://github.com/psf/black">
      <img alt="https://img.shields.io/badge/code%20style-black-000000.svg" src="https://img.shields.io/badge/code%20style-black-000000.svg">
    </a>

  <a href="https://github.com/freemocap/freemocap_blender_addon/releases/latest">
          <img src="https://img.shields.io/github/release/freemocap/freemocap_blender_addon.svg" alt="Latest Release">
      </a>

  <a href="https://github.com/freemocap/freemocap/blob/main/LICENSE">
          <img src="https://img.shields.io/badge/license-AGPL-blue.svg" alt="AGPLv3">
      </a>

  <a href="https://github.com/freemocap/freemocap/issues">
          <img src="https://img.shields.io/badge/contributions-welcome-ff69b4.svg" alt="Contributions Welcome">
      </a>

  <a href="https://github.com/psf/black">
      <img alt="https://img.shields.io/badge/code%20style-black-000000.svg" src="https://img.shields.io/badge/code%20style-black-000000.svg">
    </a>

  <a href="https://discord.gg/SgdnzbHDTG">
      <img alt="Discord Community Server" src="https://dcbadge.vercel.app/api/server/SgdnzbHDTG?style=flat">
    </a>


  </p>

  This is a Blender add-on for loading and visualizing the output of the [freemocap](https://freemocap.org) software.

  The core functionality is run automatically at the end of a standard freemocap recording session, but this add-on allows for manual loading and visualization of the pre-processed `freemocap` recording data in Blender.

  ![image](https://github.com/freemocap/freemocap_blender_addon/assets/15314521/94d482c1-9fa7-4c66-8354-34cf5707af9f)


  1. Download the `freemocap_blender_addon.zip` ([from the latest release](https://github.com/freemocap/freemocap_blender_addon/releases/latest))
  1. Open [Blender]()
  1. `Edit` > `Preferences` > `Add-ons` > `Install...`
  1. Select the `freemocap_blender_addon.zip` (likely from your `Downloads/` folder)
  1. Verify installation by searching `freemocap` in the addon tab and ensuring the box next to `freemocap_blender_addon` is checked


  > NOTE - *We strongly recommend activating your System Console before running this addon, as it will show oodles of valuable information about the underlying process. On Windows, you can toggle this console on from the `Window` menu in a running instance of Blender. On Mac/Linux, you must **launch** blender from a Terminal by typing `blender` into a terminal after install.*


  You must have should have a fully processed [freemocap](https://freemocap.org) recording folder on your computer somewhere.

  If you are processing a recording from the `freemocap` software, it will probably in in `[path_to_your_home_directory]/freemocap_data/recording_sessions/[recording_name]`

  If you have downloaded and processed the `test` data from the `Data` dropdown in the menu bar of the `freemoap` software, the addon should detect that automatically and set that path as the default.

  You may download a pre-processed `freemocap_test_data` recording on the [`freemocap==1.3.0` release notes](https://github.com/freemocap/freemocap/releases/download/v1.3.0/):
  > https://github.com/freemocap/freemocap/releases/download/v1.3.0/freemocap_test_data_processed_with_freemocap_v1.3.0.zip



  1. In the `3D viewport` window, press `n` to show the sidebar
  2. Select the `💀FreeMoCap` tab
  3. Set the path to the FreeMoCap recording you want to load (path should point to the directory that contains the `output_data/` and `annotated_videos/` folders)
  4. Press the `RUN_ALL` (keep an eye on the terminal window for useful output)


  If all went well, there should now be a friendly spooky skeleton in your scene along with the annotated images-as-planes, and a new `.blend` file saved to the specified recording folder named `[recording_folder_name].blend` (i.e. the same way it comes out of a standard `freemocap` recording session)


  ___


  - The rig has a TPose as rest pose for easier retargeting.
  - For best results, your recording should include a few seconds where the particapant is standing still with their feet clearly visible flat on the ground.
  - If the data comes out rotated relative to gravity, it can be globally manipulated using the parent `empty`
   object (usually named `[recording_name]_parent_empty`) in the scene.
  - This is a Work-In-Progress with significant refactors/overhauls planned for the near future. You will always be able to re-process old freemocap recordings using new versions of software, but things like naming conventions, armature configuration, etc may change without notice! Save your work often and back up your data often :D


   Special thanks to @ajc27-git for the original work developing this addon and supporting the `freemocap` community! Check out their work at:  https://www.youtube.com/@fluxrenders


  Click this link to join the our community Discord server - https://discord.gg/XpRQJnqZxf


pkgId: 594e9bd3f4288c85c6d13fb11e348f754256d0fd400ec104ceeac95ab18dbbc9
name: python3-album-solution-api
arch: noarch
version: 0.7.0
epoch: 0
release: 1
description: Package installed in any Album solution environment. Provides the API for the solution script.
url: https://gitlab.com/album-app/album-solution-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-album-solution-api-0.7.0-1.src.rpm
location_href: Packages/python3-album-solution-api-0.7.0-1.noarch.rpm
checksum_type: sha256
summary:
  Album is a framework for unifying computational tools across frameworks, languages, and environments.


pkgId: 82c4cb734b8c35ce65c9ef57b79a4ab900c751e5f7e4839224c479de392c92ee
name: python3-antares-craft
arch: noarch
version: 0.1.2
epoch: 0
release: 1
url: https://pypi.org/project/antares-craft/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-antares-craft-0.1.2-1.src.rpm
location_href: Packages/python3-antares-craft-0.1.2-1.noarch.rpm
checksum_type: sha256
summary:
  Antares Craft python library under construction. It will allow to create, update and read antares studies.

description:
  [![github ci](https://github.com/AntaresSimulatorTeam/antares_craft/actions/workflows/ci.yml/badge.svg)](https://github.com/AntaresSimulatorTeam/antares_craft/actions/workflows/ci.yml)



  Antares Craft python library is currently under construction. When completed it will allow to create, update and read
  antares studies.

  This project only supports antares studies with a version v8.8 or higher.

  **Table of Contents**

  - [usage](docs/usage.md)
  - [development](docs/developer.md)
  - [Changelog](docs/CHANGELOG.md)

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


pkgId: b5ddbc90780bb2b1e81e12ac4631781fa441877b7aef984dadac5c4f6326a6b5
name: python3-apsbss
arch: noarch
version: 1.5.6
epoch: 0
release: 1
url: https://BCDA-APS.github.io/apsbss
rpm_license: (c) 2017-2022, UChicago Argonne, LLC (see LICENSE.txt file for details)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-apsbss-1.5.6-1.src.rpm
location_href: Packages/python3-apsbss-1.5.6-1.noarch.rpm
checksum_type: sha256
summary:
  Read-only interface to information from APS Proposal and ESAF (experiment safety approval form) databases.

description:
  Read-only interface to information from APS Proposal and ESAF (experiment safety
  approval form) databases.

  home: https://bcda-aps.github.io/apsbss/

  [![Release](https://img.shields.io/github/release/BCDA-APS/apsbss.svg)](https://github.com/BCDA-APS/apsbss/releases)
  [![Tag](https://img.shields.io/github/tag/BCDA-APS/apsbss.svg)](https://github.com/BCDA-APS/apsbss/tags)
  [![Build Status](https://img.shields.io/github/workflow/status/BCDA-APS/apsbss/Unit%20Tests)](https://github.com/BCDA-APS/apsbss/actions?query=workflow%3A%22Unit+Tests%22+branch%3Amain)
  [![License](https://anaconda.org/aps-anl-tag/apsbss/badges/license.svg)](https://anaconda.org/aps-anl-tag/apsbss)

  [![PyPI](https://img.shields.io/pypi/v/apsbss.svg)](https://pypi.python.org/pypi/apsbss)
  [![Conda package](https://anaconda.org/aps-anl-tag/apsbss/badges/installer/conda.svg)](https://conda.anaconda.org/prjemian)
  [![Conda package version](https://anaconda.org/aps-anl-tag/apsbss/badges/version.svg)](https://anaconda.org/aps-anl-tag/apsbss)
  [![Conda package platform(s)](https://anaconda.org/aps-anl-tag/apsbss/badges/platforms.svg)](https://anaconda.org/aps-anl-tag/apsbss)
  [![Conda package release date](https://anaconda.org/aps-anl-tag/apsbss/badges/latest_release_date.svg)](https://anaconda.org/aps-anl-tag/apsbss)


pkgId: 51d71ceb527a8dd73720975cf310c7dbe13904042c3ddef61cbf080efe5a7ce2
name: python3-at-common-workflow
arch: noarch
version: 1.2.0
epoch: 0
release: 1
url: https://github.com/apex-trader/at-common-workflow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-at-common-workflow-1.2.0-1.src.rpm
location_href: Packages/python3-at-common-workflow-1.2.0-1.noarch.rpm
checksum_type: sha256
summary:
  A robust Python package for building and executing asynchronous workflow tasks in a directed acyclic graph (DAG) pattern. This package provides a type-safe, thread-safe framework for defining, organizing, and running dependent tasks with comprehensive validation and error handling.


pkgId: 532d9663501ad11b0ffc2ce72ea6cd79704383504aed28a8d2c0fdc9794068a4
name: python3-avro-dbo
arch: noarch
version: 0.1.1
epoch: 0
release: 1
url: https://pypi.org/project/avro-dbo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-avro-dbo-0.1.1-1.src.rpm
location_href: Packages/python3-avro-dbo-0.1.1-1.noarch.rpm
checksum_type: sha256
summary:
  Python classes from Avro schemas with custom serializers and deserializers, supporting all logical types.

description:
  [![PyPI version](https://badge.fury.io/py/avro-dbo.svg)](https://badge.fury.io/py/avro-dbo)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Python Versions](https://img.shields.io/pypi/pyversions/avro-dbo.svg)](https://pypi.org/project/avro-dbo/)

  A powerful Python library for working with Apache Avro schemas, providing seamless integration with data serialization and schema management. Perfect for data engineering pipelines and stream processing applications.



  - 🏗️ **Schema-First Development** - Generate Python classes directly from Avro schemas
  - 🔄 **Full Type Support** - Complete support for all Avro logical types
  - 🛠️ **Custom Serialization** - Flexible serializers and deserializers
  - 🌐 **Schema Registry Integration** - Native support for Confluent Schema Registry
  - 🔒 **Type Safety** - Full static type checking support
  - ⚡ **High Performance** - Optimized for production workloads





  ```bash
  pip install avro-dbo
  ```



  **UV is required to build and publish the package.**



  ```bash
  curl -LsSf https://astral.sh/uv/install.sh | sh
  ```



  ```bash
  uv sync --upgrade
  uv build
  ```



  For detailed usage instructions, type hints, and examples, please refer to the [documentation](https://avro-dbo.readthedocs.io/en/latest/).



  We welcome contributions! Please see the [CONTRIBUTING.md](CONTRIBUTING.md) file for more information.



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


pkgId: 92d2839dae0836b232f512832ec6c97a91a6baabf4130e792555edcf9c66725d
name: python3-banffprocessor
arch: noarch
version: 0.0.0
epoch: 0
release: 1
url: https://pypi.org/project/banffprocessor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-banffprocessor-0.0.0-1.src.rpm
location_href: Packages/python3-banffprocessor-0.0.0-1.noarch.rpm
checksum_type: sha256
summary:
  Coming soon ... The Banff Processor, a tool for creating imputation strategies developed by Statistics Canada

description:
  The Banff Processor is part of the Banff project. It is a tool that can be installed in addition to the Banff Procedure package. This tool is used to implement an imputation strategy, which is essentially a sequence of processing steps. A processing step can be a standard Banff Procedure, a user-defined process (plugin) or a process block (another sequence of processing steps).

  Imputation strategies are defined using XML files, an Excel template has been provided along with a utility to convert metadata created with the template to the XML files required by the processor. The output of a processor job is the imputed file along with a log and various status and optional diagnostic files.



  The Banff Processor was originally written in SAS 9 using the SAS macro language. In 2023-24, the Banff Processor was redeveloped as a python package and released as version 2. New features were added such as Process Controls and Process Blocks.


pkgId: 29524699cfbc73c5d707f11a73c2713fd8e150042421ae13da33a3f88c8032ea
name: python3-batched
arch: noarch
version: 0.1.3
epoch: 0
release: 1
url: https://pypi.org/project/batched/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-batched-0.1.3-1.src.rpm
location_href: Packages/python3-batched-0.1.3-1.noarch.rpm
checksum_type: sha256
summary:
  Batched is a flexible and efficient batch processing library implemented in Python. It supports asynchronous batch processing with dynamic batching and prioritization.

description:
  The Batched API provides a flexible and efficient way to process multiple requests in a batch, with a primary focus on dynamic batching of inference workloads. It is designed to optimize throughput while maintaining a low-latency experience, especially useful in scenarios where you need to handle a high volume of requests simultaneously. It is designed for both async and sync execution.

  ![Batch Performance](/examples/inference_speed.png)



  - [Installation](#installation)
  - [Usage](#usage)
    - [Basic Example](#basic-example)
    - [Advanced Usage](#advanced-usage)
  - [API Reference](#api-reference)
  - [Contributing](#contributing)
  - [License](#license)



  Dynamic batching is a technique that automatically groups multiple incoming inference requests into a single batch for processing. This is particularly beneficial for inference workloads, where processing multiple inputs together can significantly improve throughput and efficiency.

  In machine learning models, dynamic batching matters because it optimizes hardware utilization, especially for GPUs and specialized AI hardware designed for parallel processing. By batching requests, we can fully leverage this parallel processing, leading to higher throughput. It also reduces overhead by amortizing fixed costs (such as data transfer and model initialization) across multiple requests, improving overall efficiency. Furthermore, dynamic batching enhances real-time performance by adapting to varying request rates, maintaining low latency during quiet periods while maximizing throughput during busy times.

  This makes dynamic batching a crucial technique for deploying ML models in production environments where request patterns can be unpredictable and resource optimization is key.



  To install the Batched, you can use pip:

  ```bash
  pip install batched
  ```





  Below is a basic example of how to use the Batched API to process text data in batches.

  ```diff
     from sentence_transformers import SentenceTransformer
     import numpy as np
  +  import batched

     class SentenceEmbedder:
        def __init__(self, model_name='mixedbread-ai/mxbai-embed-large-v1'):
           self.model = SentenceTransformer(model_name)

  +     @batched.dynamically
        def embed_sentences(self, sentences: list[str]) -> list[np.ndarray]:
           
           return self.model.encode(sentences)

     
     embedder = SentenceEmbedder()

     
     single_sent = "This is a test sentence."
     embedding = embedder.embed_sentences(single_sent)
  +  awaited_embedding = await embedder.embed_sentences.acall(single_sent)

     
     batch_sentences = [f"This is test sentence number {i}." for i in range(1000)]
     batch_embeddings = embedder.embed_sentences(batch_sentences)
  +  awaited_batch_embeddings = await embedder.embed_sentences.acall(batch_sentences)

     
  +  stats = embedder.embed_sentences.stats
  ```



  For more advanced usage, such as customizing batch size and timeout dynamically, the Batched API provides decorators that allow fine-grained control over the batching process.

  - **Batch Size**: You can specify the max. number of requests to group together in a single batch.
  - **Timeout**: The maximum time to wait for more requests before processing the batch.
  - **Small Batch Threshold**: The threshold to give more priority to smaller batches.
  - **Pad Token**: The token to use for padding when batching tensors, only for `@inference.dynamically` and `@aio.inference.dynamically`.

  For example:

  ```python
  @batched.dynamically(batch_size=64, timeout_ms=5.0, small_batch_threshold=2)
  def custom_batch_function(data):
      
      pass
  ```



  The API offers both thread and asyncio implementations for batching general tasks and inference tasks:



  - `@batched.dynamically`: Allows dynamic batching for general tasks (Both sync and async supported).
  - The decorated method should:
    - Take in a list of items (`list[T]`)
    - Return a list of results (`list[U]`) of the same length.

  ```python
  import batched


  @batched.dynamically(batch_size=64)
  def my_function(items: list[int]) -> list[str]:
    
    return [f"{item * 2}" for item in items]


  my_function(2)


  my_function([2, 3, 4])


  await my_function.acall(2)
  await my_function.acall([2, 3, 4])


  print(my_function.stats)
  ```

  - `@batched.inference.dynamically`: Allows dynamic batching for inference tasks, handling numpy arrays and tensors with padding.
  - The decorated method should:
    - Take in a dictionary of tensors or numpy arrays (`dict[str, Feature]`). `Feature` is a batch of item values for a single feature, and the keys are the feature names.
    - Return a tensor or numpy array (`Feature`). Each row is a single inference result.
    - `Feature` can be any of the following types: `np.ndarray`, `torch.Tensor`, `list[np.ndarray]` and `list[torch.Tensor]`.
    - `features[feature_name].shape[0] == outputs.shape[0]`

  ```python
  from batched import inference
  import torch

  @inference.dynamically(pad_token={"input_ids": 0})
  def my_inference_function(features: dict[str, torch.Tensor]) -> torch.Tensor:
    
    
    

    logits = model(**features)
    return logits


  my_inference_function(data)


  await my_inference_function.acall(data)

  print(my_inference_function.stats)
  ```



  - `@batched.aio.dynamically`: Allows dynamic batching for general tasks using `asyncio`.
  - The decorated method should:
    - Take in a list of items (`list[T]`)
    - Return a list of results (`list[U]`) of the same length.

  ```python
  from batched import aio

  @aio.dynamically(batch_size=64, timeout_ms=20.0, small_batch_threshold=10)
  def my_function(items: list[int]) -> list[int]:  # can also be an async function: async def ...
    
    return [item * 2 for item in items]



  await my_function(2)


  await my_function([2, 3, 4])


  print(my_function.stats)
  ```

  - `@batched.aio.inference.dynamically`: Allows dynamic batching for inference tasks, handling numpy arrays and tensors with padding, using `asyncio`.
  - The decorated method should:
    - Take in a dictionary of tensors or numpy arrays (`dict[str, Feature]`). `Feature` is a batch of item values for a single feature, and the keys are the feature names.
    - Return a tensor or numpy array (`Feature`). Each row is a single inference result.
    - `Feature` can be any of the following types: `np.ndarray`, `torch.Tensor`, `list[np.ndarray]` and `list[torch.Tensor]`.
    - `features[feature_name].shape[0] == outputs.shape[0]`

  ```python
  from batched import aio
  import torch

  @aio.inference.dynamically(pad_token={"input_ids": 0})
  async def my_inference_function(features: dict[str, torch.Tensor]) -> list[torch.Tensor]:
    
    
    

    logits1 = await model1(**features)
    logits2 = await model2(**features)
    return [logits1, logits2]


  await my_inference_function(data)

  print(my_inference_function.stats)
  ```



  Contributions are welcome! Please feel free to submit a pull request or report an issue on GitHub.



  This project was inspired by the following projects:

  - [Infinity](https://github.com/michaelfeil/infinity) by Michael Feil



  This project is licensed under the Apache License, Version 2.0.


pkgId: 8ec0ff2863f2a00e8797d70340ba3b4b0ea38a961d3847c5622390cf2537b840
name: python3-beschi
arch: noarch
version: 0.3.1
epoch: 0
release: 1
url: https://github.com/sjml/beschi
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-beschi-0.3.1-1.src.rpm
location_href: Packages/python3-beschi-0.3.1-1.noarch.rpm
checksum_type: sha256
summary:
  bit-packing and unpacking code generator for C, C#, Go, Rust, Swift, TypeScript, AssemblyScript, and Zig

description:
  <!-- Note to future self: using absolute links to documentation here so they work properly on the PyPI page. -->


  [![PyPI](https://img.shields.io/pypi/v/beschi)](https://pypi.org/project/beschi/) [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/sjml/beschi/ci.yml)](https://github.com/sjml/beschi/actions/workflows/ci.yml)

  This is a custom bit-packing and unpacking code generator for C, C#, Go, Rust, Swift, TypeScript, AssemblyScript, and Zig. You feed it a data description and it generates source files for writing/reading buffers of that data, along the lines of [FlatBuffers](https://google.github.io/flatbuffers/) or [Cap'n Proto](https://capnproto.org), but with much less functionality for much simpler use cases. It was initially written for a larger project that was passing data back and forth between a Unity game, a Go server, and a web client, but I extracted it into its own thing. If all you need is a simple way to pack a data structure into a compact, portable binary form, this might be useful for you.

  I go into more explanation for why this exists [in the documentation](https://github.com/sjml/beschi/tree/main/docs/), but I'll be honest, too: it **was** kind of fun to write a code generator. 😝



  * [Introduction](https://github.com/sjml/beschi/tree/main/docs/introduction.md)
  * [Protocols](https://github.com/sjml/beschi/tree/main/docs/protocols.md)

  Language-Specific Documentation:

  | [C](https://github.com/sjml/beschi/tree/main/docs/languages/c.md) | [C#](https://github.com/sjml/beschi/tree/main/docs/languages/csharp.md) | [Go](https://github.com/sjml/beschi/tree/main/docs/languages/go.md) | [Rust](https://github.com/sjml/beschi/tree/main/docs/languages/rust.md) | [Swift](https://github.com/sjml/beschi/tree/main/docs/languages/swift.md) | [TypeScript](https://github.com/sjml/beschi/tree/main/docs/languages/typescript.md) | [AssemblyScript](https://github.com/sjml/beschi/tree/main/docs/languages/assemblyscript.md) | [Zig](https://github.com/sjml/beschi/tree/main/docs/languages/zig.md)
  |-|-|-|-|-|-|-|-|

  * [Dev Notes](https://github.com/sjml/beschi/tree/main/docs/dev)




  If you use [Homebrew](https://brew.sh), you can install it directly and simply:

  ```
  brew install sjml/sjml/beschi
  ```

  Otherwise, you need a Python setup and can then install from [PyPI](https://pypi.org/project/beschi/):

  ```
  pip install beschi
  ```

  It installs an executable that you can run directly, so long as however you invoked `pip` put it on your path. (This will work in an activated virtual environment, for instance.)

  Example:
  ```
  beschi --lang csharp --protocol ./messages.toml
  ```



  By default, it prints to standard output, but you can also write to a file with an output flag like `--output ./Messages.cs`.

  From the input protocol file (detailed below), you get a code file that you can integrate to a project allowing you encode messages as compact and portable binary buffers.




  The protocol files are written in [TOML](https://toml.io). There's [a fuller example in the test suite](https://github.com/sjml/beschi/tree/main/test/_protocols/example.toml) and a [more through explanation in the documentation](https://github.com/sjml/beschi/tree/main/docs/protocols.md), but here's an annotated sample.

  ```toml
  [meta]



  namespace = "AppMessages"





  list_size_type = "uint16"
  string_size_type = "byte"






  [[messages]]
  _name = "Vector3Message"
  x = "float"
  y = "float"
  z = "float"



  [[messages]]
  _name = "NewCharacterMessage"
  id = "uint64"
  characterName = "string"
  job = "CharacterClass" # an enum! (see below)
  strength = "uint16"
  intelligence = "uint16"
  dexterity = "uint16"
  wisdom = "uint16"
  goldInWallet = "uint32"
  nicknames = "[string]" # brackets indicate a list/array




  [[enums]]
  _name = "CharacterClass"
  _values = [
      "Fighter",
      "Wizard",
      "Rogue",
      "Cleric"
  ]



  [[structs]]
  _name = "Color"
  red = "float"
  green = "float"
  blue = "float"
  alpha = "float"


  [[structs]]
  _name = "Spectrum"
  defaultColor = "Color"
  colors = "[Color]"



  [[messages]]
  _name = "CharacterJoinedTeam"
  characterID = "uint64"
  teamName = "string"
  teamColors = "[Color]"
  role = "TeamRole"


  [[enums]]
  _name = "TeamRole"
  _values = [
      
      
      { _name = "Minion",  _value =  256 },
      { _name = "Ally",    _value =  512 },
      { _name = "Leader",  _value = 1024 },
      
      { _name = "Traitor", _value =   -1 }
  ]
  ```

  Note that while [the TOML spec](https://toml.io/en/v1.0.0) does not guarantee the order of table entries, [the Python library which Beschi uses](https://docs.python.org/3/library/tomllib.html) uses order-preserving dictionaries, so if you care about the order of elements in the resulting struct (for memory alignment issues or something), you can re-order them and have that change reflected in the generated code.




  These are the base types from which you can build up whatever structures and messages you need to, along with what they correspond to in the various languages.

  | Protocol Type | C          | C#       | Go        | Rust     | Swift     | TypeScript | AssemblyScript | Zig           |
  |---------------|------------|----------|-----------|----------|-----------|------------|----------------|---------------|
  | **`byte`**    | `uint8_t`  | `byte`   | `byte`    | `u8`     | `UInt8`   | `number`   | `u8`           | `u8`         |
  | **`bool`**    | `bool`     | `bool`   | `bool`    | `bool`   | `Bool`    | `boolean`  | `bool`         | `bool`       |
  | **`int16`**   | `uint16_t` | `short`  | `int16`   | `i16`    | `Int16`   | `number`   | `i16`          | `i16`        |
  | **`uint16`**  | `int16_t`  | `ushort` | `uint16`  | `u16`    | `UInt16`  | `number`   | `u16`          | `u16`        |
  | **`int32`**   | `uint32_t` | `int`    | `int32`   | `i32`    | `Int32`   | `number`   | `i32`          | `i32`        |
  | **`uint32`**  | `int32_t`  | `uint`   | `uint32`  | `u32`    | `UInt32`  | `number`   | `u32`          | `u32`        |
  | **`int64`**   | `uint64_t` | `long`   | `int64`   | `i64`    | `Int64`   | `bigint`   | `i64`          | `i64`        |
  | **`uint64`**  | `int64_t`  | `ulong`  | `uint64`  | `u64`    | `UInt64`  | `bigint`   | `u64`          | `u64`        |
  | **`float`**   | `float`    | `float`  | `float32` | `f32`    | `Float32` | `number`   | `f32`          | `f32`        |
  | **`double`**  | `double`   | `double` | `float64` | `f64`    | `Float64` | `number`   | `f64`          | `f64`        |
  | **`string`**  | `char*`    | `string` | `string`  | `String` | `String`  | `string`   | `string`       | `[]const u8` |

  All the numbers are stored as little-endian in the buffer, if that matters for you.




  Beschi does not generate any code to handle writing or reading from disk, pushing data across a network, or anything like that — it will turn a message into bytes and read that same message back from the bytes, but you are responsible for what you do with them otherwise.

  With the given protocol, though, you could create a message in C# and write it to a file:
  ```csharp
  var msg = new AppMessages.Vector3Message();
  msg.x = 1.0f;
  msg.y = 4096.1234f;
  msg.z = -42.56f;
  var fs = new FileStream("./vec3.msg", FileMode.Create);
  var bw = new BinaryWriter(fs);
  msg.WriteBytes(bw, false);
  ```

  And then read it back in Go:
  ```golang
  dat, _ := os.Open("./vec3.msg")
  defer dat.Close()
  msg := AppMessages.Vector3MessageFromBytes(dat)
  if msg.X == 1.0 && msg.Y == 4096.1234 && msg.Z < 0.0 {
  	print("Ready to go!\n")
  }
  ```

  Or TypeScript:
  ```typescript
  const data = fs.readFileSync("./vec3.msg");
  const dv = new DataView(new Uint8Array(data).buffer);
  const msg = AppMessages.Vector3Message.fromBytes(dv, 0).val;
  if (msg.y == Math.fround(4096.1234)) {
      console.log("Ready to... typescript?");
  }
  ```


  For the most part, Beschi tries to keep behavior and structures consistent across the languages, but there are a few points of difference [outlined on the various language pages](https://github.com/sjml/beschi/tree/main/docs/languages). Notice in the example above, for instance, that in TypeScript you have to make a call to `Math.fround` if you want to do a straight comparison of float values because of how the underlying JavaScript engine treats all numbers as double-width floats. (Doing equality comparisons on floats is usually a bad idea, but in this instance we *want* to check that they are actually bitwise identical.) Similarly, see how the data members are upper-cased in Go to match that language's export conventions, and the byte reading function is part of the namespace because Go doesn't have static functions for data types. The goal is to make working across languages feel seamless, but there are some differences that we adapt to as much as possible.

  There are more extensive examples in [the test harnesses](https://github.com/sjml/beschi/tree/main/test/_harnesses).




  Beschi makes code that I use "in production" on personal projects. It could probably stand to be better optimized, there are probably edge cases and bugs, etc. But for the most part, this is mature enough that I stopped thinking of it as a project in itself and now it's just a tool that I use.

  I will admit that part of me wants to make new writers, but that's not likely to get done until I have a specific project motivating it. If someone loves this system, though, and really wants to see a generator for Haskell or Lua or whatever, go for it. The existing writers should be decent starting points — they aren't terribly clever (no AST or interesting data structures), just iterating over the protocol and writing out serialization/deserialization code.




  [Constanzo Giuseppe Beschi](https://en.wikipedia.org/wiki/Constanzo_Beschi) was an Italian Jesuit who worked in southern India during the early 18th century. He was noted as a talented linguist, able to tie concepts from multiple languages into a single form. At the same time, he was adept at the Jesuit principle of "inculturation," where foreign concepts are adapted for a new culture and the foreigner attempting the adaptation also respectfully adopts habits and ways of proceeding from the host culture.


pkgId: ba7e4e033afe4ed3eebbe9eaae919f36c636e3beb01d440688f89342ade277f4
name: python3-brenthy-tools-beta
arch: noarch
version: 4.0.5
epoch: 0
release: 1
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-brenthy-tools-beta-4.0.5-1.src.rpm
location_href: Packages/python3-brenthy-tools-beta-4.0.5-1.noarch.rpm
checksum_type: sha256
summary:
  A library for interacting with Brenthy (`brenthy_api`) and a collection of tools common to Brenthy Core and `brenthy_api`.

description:
  Here lives the source code for Brenthy, the framework for developing and deploying new kinds of blockchain in the Python programming language.



  Main docs:
  - [Introduction to Brenthy](/Documentation/Brenthy/Meaning/IntroductionToBrenthy.md)
  - [Running from Source](/Documentation/Brenthy/User/RunningFromSource.md)
  - [Installation](/Documentation/Brenthy/User/InstallingBrenthy.md)
  - Create Blockchains for Brenthy: _coming soon..._

  Overview of all docs: [/Documentation/DocsOverview.md](/Documentation/DocsOverview.md)



  Walytis is the novel blockchain Brenthy was originally built for.
  Read the [Introduction to Walytis](/Documentation/Walytis/Meaning/IntroductionToWalytis.md) to learn more.
  The source code for Walytis is located under [./blockchains/Walytis_Beta](./blockchains/Walytis_Beta/ReadMe.md)

url:
  https://ipfs.io/ipns/k2k4r8nismm5mmgrox2fci816xvj4l4cudnuc55gkfoealjuiaexbsup/Sites/BrenthyAndWalytis/


pkgId: 123a415a3fc5ea3305ffb1afc8106fbc52550e5b3152192bfff748fa63f1c60e
name: python3-browser-cookie3
arch: noarch
version: 0.20.1
epoch: 0
release: 1
url: https://github.com/borisbabic/browser_cookie3
rpm_license: lgpl
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-browser-cookie3-0.20.1-1.src.rpm
location_href: Packages/python3-browser-cookie3-0.20.1-1.noarch.rpm
checksum_type: sha256
summary:
  Loads cookies from your browser into a cookiejar object so can download with urllib and other libraries the same content you see in the web browser.


pkgId: 8f3723ab59bec5fd84fade1a8c7f39a8006f64f280458b092ad41ad1ca223b9a
name: python3-canonada
arch: noarch
version: 0.1.2
epoch: 0
release: 1
url: https://github.com/RLado/Canonada
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-canonada-0.1.2-1.src.rpm
location_href: Packages/python3-canonada-0.1.2-1.noarch.rpm
checksum_type: sha256
summary:
  Canonada is a data science framework that helps you build production-ready streaming pipelines for data processing in Python.

description:
  > ⚠️ Canonada is currently under development.

  Canonada is a data science framework that helps you build production-ready streaming pipelines for data processing in Python.

  [![GitHub branch check runs](https://img.shields.io/github/check-runs/rlado/canonada/master)](https://github.com/RLado/Canonada)
  [![PyPI - Version](https://img.shields.io/pypi/v/canonada)](https://pypi.org/project/canonada/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/canonada)](https://pypi.org/project/canonada/)


  - **Standardized**: Canonada provides a standardized way to build your data projects
  - **Modular**: Canonada is modular and allows you to build and visualize data pipelines with ease
  - **Memory Efficient**: Canonada is memory efficient and can handle large datasets by streaming data through the pipeline instead of loading it all at once


  - **Centralized control of data sources**: Manage all your data sources in one place, enabling you to keep your team in sync
  - **Centralized control of the project configuration**: Manage all your project configurations in one place
  - **Easy dataloading**: Load data from various sources like CSV, JSON, Parquet, etc.
  - **Use functions as nodes**: Functions are the building blocks of Canonada. You can use any function as a node in your pipeline
  - **Create streaming data pipelines**: Create parallel and sequential data pipelines with ease
  - **Visualize your data pipeline**: Visualize your data pipelines, nodes and connections


  ```
  canonada.toml
  config/
      catalog.toml
      parameters.toml
      credentials.toml
  data/
      ...
  datahandlers/
      __init__.py
      custom_datahandler_1.py
      custom_datahandler_2.py
      ...
  notebooks/
      ...
  pipelines/
      __init__.py
      pipeline_1.py
      pipeline_2.py
      nodes_1/
          __init__.py
          node_1.py
          node_2.py
          ...
      nodes_2/
          __init__.py
          node_3.py
          node_4.py
          ...
      ...
  systems/
      __init__.py
      system_1.py
      system_2.py
      ...
  tests/
      test_node_group_1.py
      test_node_group_2.py
      ...
  ```


  Available commands:
  ```
  Usage: canonada <command> <args>
  Commands:
      new <project_name> - Create a new project
      catalog [list/params] - List all available datasets or get the project parameters
      registry [pipelines/systems] - List all available pipelines or systems
      run [pipelines/systems] <name(s)> - Run a pipeline or system
      view [pipelines/systems] <name(s)> - View a pipeline or system
      version - Print the version of Canonada
  ```


  Canonada is available on [PyPI](https://pypi.org/project/canonada/) and can be installed using pip:
  ```bash
  pip install canonada
  ```

  > Check out the [Getting Started](https://github.com/RLado/Canonada/wiki/GettingStarted) guide to learn how to create a new project with Canonada.


  Check out the project's documentation [here](https://github.com/RLado/Canonada/wiki)


  Contributions are welcome! If you have any suggestions, examples, datahandlers, bug reports, or feature requests, please open an issue or a discussion thread.


pkgId: 9a681c2ab6ae838caa859646ec97a62141455a1d28cdb22b3757b74b1a4c5e40
name: python3-ccx2paraview
arch: noarch
version: 3.2.0
epoch: 0
release: 1
url: https://github.com/calculix/ccx2paraview
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ccx2paraview-3.2.0-1.src.rpm
location_href: Packages/python3-ccx2paraview-3.2.0-1.noarch.rpm
checksum_type: sha256
summary:
  CalculiX to Paraview converter (frd to vtk/vtu). Makes it possible to view and postprocess CalculiX analysis results in Paraview. Generates Mises and Principal components for stress and strain tensors.

description:
  [Downloads](https://github.com/calculix/ccx2paraview/releases) |
  [How to use](#how-to-use) |
  [Screenshots](#screenshots) |
  [Your help](#your-help) |
  [For developers](#for-developers) |


pkgId: 32d97df3ded09b1cf4e65e3194295427f2ddc37f2218b3642ec09d86e39ab6fe
name: python3-celitech-sdk
arch: noarch
version: 1.3.23
epoch: 0
release: 1
url: https://pypi.org/project/celitech-sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-celitech-sdk-1.3.23-1.src.rpm
location_href: Packages/python3-celitech-sdk-1.3.23-1.noarch.rpm
checksum_type: sha256
summary:
  Welcome to the CELITECH API documentation!  Useful links: [Homepage](https://www.celitech.com) | [Support email](mailto:support@celitech.com) | [Blog](https://www.celitech.com/blog/)

description:
  Welcome to the Celitech SDK documentation. This guide will help you get started with integrating and using the Celitech SDK in your project.

  [![This SDK was generated by liblab](https://public-liblab-readme-assets.s3.us-east-1.amazonaws.com/built-by-liblab-icon.svg)](https://liblab.com/?utm_source=readme)



  - API version: `1.1.0`
  - SDK version: `1.3.23`



  Welcome to the CELITECH API documentation! Useful links: [Homepage](https://www.celitech.com) | [Support email](mailto:support@celitech.com) | [Blog](https://www.celitech.com/blog/)



  - [Setup & Configuration](#setup--configuration)
    - [Supported Language Versions](#supported-language-versions)
    - [Installation](#installation)
  - [Authentication](#authentication)
    - [OAuth Authentication](#oauth-authentication)
    - [Environment Variables](#environment-variables)
  - [Setting a Custom Timeout](#setting-a-custom-timeout)
  - [Sample Usage](#sample-usage)
  - [Services](#services)
  - [Models](#models)
  - [License](#license)





  This SDK is compatible with the following versions: `Python >= 3.7`



  To get started with the SDK, we recommend installing using `pip`:

  ```bash
  pip install celitech-sdk
  ```





  The Celitech API uses OAuth for authentication.

  You need to provide the OAuth parameters when initializing the SDK.

  ```py
  sdk = Celitech(
      client_id="CLIENT_ID",
      client_secret="CLIENT_SECRET"
  )
  ```

  If you need to set or update the OAuth parameters after the SDK initialization, you can use:

  ```py
  sdk.set_client_id("CLIENT_ID")
  sdk.set_client_secret("CLIENT_SECRET")
  ```



  These are the environment variables for the SDK:

  | Name          | Description             |
  | :------------ | :---------------------- |
  | CLIENT_ID     | Client ID parameter     |
  | CLIENT_SECRET | Client Secret parameter |

  Environment variables are a way to configure your application outside the code. You can set these environment variables on the command line or use your project's existing tooling for managing environment variables.

  If you are using a `.env` file, a template with the variable names is provided in the `.env.example` file located in the same directory as this README.



  You can set a custom timeout for the SDK's HTTP requests as follows:

  ```py
  from celitech import Celitech

  sdk = Celitech(timeout=10000)
  ```



  Below is a comprehensive example demonstrating how to authenticate and call a simple endpoint:

  ```py
  from celitech import Celitech

  sdk = Celitech(
      client_id="CLIENT_ID",
      client_secret="CLIENT_SECRET"
  )

  result = sdk.destinations.list_destinations()

  print(result)

  ```



  The SDK provides various services to interact with the API.

  <details>
  <summary>Below is a list of all available services:</summary>

  | Name         |
  | :----------- |
  | o_auth       |
  | destinations |
  | packages     |
  | purchases    |
  | e_sim        |

  </details>



  The SDK includes several models that represent the data structures used in API requests and responses. These models help in organizing and managing the data efficiently.

  <details>
  <summary>Below is a list of all available models:</summary>

  | Name                             | Description |
  | :------------------------------- | :---------- |
  | GetAccessTokenRequest            |             |
  | GetAccessTokenOkResponse         |             |
  | ListDestinationsOkResponse       |             |
  | ListPackagesOkResponse           |             |
  | ListPurchasesOkResponse          |             |
  | CreatePurchaseRequest            |             |
  | CreatePurchaseOkResponse         |             |
  | TopUpEsimRequest                 |             |
  | TopUpEsimOkResponse              |             |
  | EditPurchaseRequest              |             |
  | EditPurchaseOkResponse           |             |
  | GetPurchaseConsumptionOkResponse |             |
  | GetEsimOkResponse                |             |
  | GetEsimDeviceOkResponse          |             |
  | GetEsimHistoryOkResponse         |             |
  | GetEsimMacOkResponse             |             |

  </details>



  This SDK is licensed under the MIT License.

  See the [LICENSE](LICENSE) file for more details.


pkgId: 89bf2522e0066599848343cfa8029e7b4899136161ae9e369fcf2c2cf68b5b06
name: python3-chatsky-ui
arch: noarch
version: 0.4.0
epoch: 0
release: 1
url: https://pypi.org/project/chatsky-ui/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-chatsky-ui-0.4.0-1.src.rpm
location_href: Packages/python3-chatsky-ui-0.4.0-1.noarch.rpm
checksum_type: sha256
summary:
  Chatsky-UI is GUI for Chatsky Framework, that is a free and open-source software stack for creating chatbots, released under the terms of Apache License 2.0.


pkgId: c8765c270b8767d37ee14bee55a34a1570e8aa5d2acd9d261546b0f5690070ff
name: python3-cld4py
arch: noarch
version: 1.1.1
epoch: 0
release: 1
url: https://github.com/timyerg/cld4py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cld4py-1.1.1-1.src.rpm
location_href: Packages/python3-cld4py-1.1.1-1.noarch.rpm
checksum_type: sha256
summary:
  Python 3 function to assign compact letter display letters and for plotting them with matplotlib/seaborn

description:
  Function to apply compact letter display for pairwise contrasts.

  Groups with no significant differences share a letter.

  It also can be used for plotting letters to seaborn/matplotlib figures.




  ```python
  pip install cld4py
  ```



  Cld4py currently includes two functions:
  - assign_letters(): this function will assign CLD letters to the contrasts
  - plot_letters(): this function can add CLD letters to matplotlib/seaborn figures




  ```python
  assign_letters()
      """
      Function to apply compact letter display for pairwise contrasts.
      Groups with no significant differences share a letter.

      Parameters:

        Required:
          df    - dataframe with contrasts (pairwise comparisons).
          G1, G2 - columns in contrasts df with compared groups.
          P      - column in contrasts df with p-value (adjusted, right?).

        Optional:
          alpha  - sigificance level (default 0.05).
          order  - None (default), list or ['ascending', 'descending'].
                   This parameter will define the order of assigned letters.
                   None - alphabetical order will be applied.
                   List - order of groups will be defined by that list.
                   String 'ascending' or 'descending' requires parameters
                   'data', 'values' and 'group' to order groups by the mean.
          data   - dataframe with values that were compared to get contrasts.
          vals   - column in data with compared values.
          group  - column in data with group information.
      """

  plot_letters()
      """
      Function to plot CLD letters for sns boxplot, violinplot, barplot or swarmplot.
      Groups with no significant differences share a letter.

      Parameters:

        Required:
          cld    - dataframe or dictionary with groups and letters. If df then groups
                   should be in the index and letters in the "Letters" column.
          data   - dataframe with values that were plotted.
          vals   - column in data with compared values.
          group  - column in data with group information.
          figax  - matplotlib or sns figure or ax with plot.

        Optional:
          axis   - axis with plotted groups: "x" or "y" (default "x").
          plot   - plot type: "boxplot", "violinplot", "barplot" or "swarmplot"
                   (default "boxplot").
          pos    - letters position: "upper", "lower", "top" or "bottom"
                   (default: "upper"). If axis = "y", "upper" and "top" will be
                   plotted on the right side, "lower" and "bottom" - on the left.
          pad    - distance (% of data range) to the plotted group object (default 1).
          c      - color of letters.
          fs     - fontsize of letters.
          lim    - increase axes limits, expressed in "pad" (see above) values (default 0)
      """
  ```




  ```python
  import cld4py
  import pandas as pd
  import seaborn as sns
  import matplotlib.pyplot as plt
  %matplotlib inline

  cont = pd.read_csv('tests/contrasts.tsv', sep='\t')
  data = pd.read_csv('tests/data.tsv', sep='\t')

  order = sorted(data.Sample.unique().tolist())

  cld = cld4py.assign_letters(cont, 'Group1', 'Group2', 'P-adj', order='descending',
                              data=data, vals='Metric', group='Sample')
  cld
  ```




  <div>

  <table border="1" class="dataframe">
    <thead>
      <tr style="text-align: right;">
        <th></th>
        <th>Letters</th>
      </tr>
      <tr>
        <th>Group</th>
        <th></th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <th>S3</th>
        <td>a</td>
      </tr>
      <tr>
        <th>S1</th>
        <td>a</td>
      </tr>
      <tr>
        <th>S4</th>
        <td>a</td>
      </tr>
      <tr>
        <th>S7</th>
        <td>b</td>
      </tr>
      <tr>
        <th>S6</th>
        <td>b</td>
      </tr>
      <tr>
        <th>S2</th>
        <td>c</td>
      </tr>
      <tr>
        <th>S5</th>
        <td>d</td>
      </tr>
    </tbody>
  </table>
  </div>






  ```python

  fig, ax = plt.subplots(1, 1, )
  sns.boxplot(y='Metric', x='Sample', data=data, ax=ax, order=order, showfliers=False)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='x', plot='boxplot', pos='upper',
              vals='Metric', group='Sample', pad=1, c='black', fs=None, lim=1)
  plt.savefig(f'tests/Figures/Boxplot_x_upper.png')


  fig, ax = plt.subplots(1, 1, )
  sns.boxplot(y='Metric', x='Sample', data=data, ax=ax, order=order, showfliers=False)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='x', plot='boxplot', pos='top',
              vals='Metric', group='Sample', pad=1, c='black', fs=None, lim=2)


  fig, ax = plt.subplots(1, 1, )
  sns.boxplot(x='Metric', y='Sample', data=data, ax=ax, order=order, showfliers=False)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='y', plot='boxplot', pos='lower',
              vals='Metric', group='Sample', pad=1, c='black', fs=None, lim=2)


  fig, ax = plt.subplots(1, 1, )
  sns.boxplot(x='Metric', y='Sample', data=data, ax=ax, order=order, showfliers=False)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='y', plot='boxplot', pos='bottom',
              vals='Metric', group='Sample', pad=1, c='black', fs=None, lim=2)
  plt.savefig(f'tests/Figures/Boxplot_y_bottom.png')
  ```

  ![](tests/figs_readme/output_11_0.png)
  ![](tests/figs_readme/output_11_1.png)
  ![](tests/figs_readme/output_11_2.png)
  ![](tests/figs_readme/output_11_3.png)




  ```python

  fig, ax = plt.subplots(1, 1, )
  sns.violinplot(y='Metric', x='Sample', data=data, ax=ax, order=order,)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='x', plot='violinplot', pos='upper',
              vals='Metric', group='Sample', pad=2, c='black', fs=None, lim=2)
  plt.savefig(f'tests/Figures/Violinplot_x_upper.png')


  fig, ax = plt.subplots(1, 1, )
  sns.violinplot(x='Metric', y='Sample', data=data, ax=ax, order=order,)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='y', plot='violinplot', pos='top',
              vals='Metric', group='Sample', pad=2, c='black', fs=None, lim=2)

  ```

  ![](tests/figs_readme/output_13_0.png)
  ![](tests/figs_readme/output_13_1.png)




  ```python

  fig, ax = plt.subplots(1, 1, )
  sns.barplot(y='Metric', x='Sample', data=data, ax=ax, order=order,)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='x', plot='barplot', pos='upper',
              vals='Metric', group='Sample', pad=1, c='black', fs=None, lim=2)
  plt.savefig(f'tests/Figures/Barplot_x_upper.png')


  fig, ax = plt.subplots(1, 1, )
  sns.barplot(x='Metric', y='Sample', data=data, ax=ax, order=order,)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='y', plot='barplot', pos='top',
              vals='Metric', group='Sample', pad=1, c='black', fs=None, lim=2)
  ```

  ![](tests/figs_readme/output_15_0.png)
  ![](tests/figs_readme/output_15_1.png)


  ```python

  fig, ax = plt.subplots(1, 1, )
  sns.swarmplot(y='Metric', x='Sample', data=data, ax=ax, order=order,)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='x', plot='swarmplot', pos='upper',
              vals='Metric', group='Sample', pad=2, c='black', fs=None, lim=2)


  fig, ax = plt.subplots(1, 1, )
  sns.swarmplot(x='Metric', y='Sample', data=data, ax=ax, order=order,)

  cld4py.plot_letters(cld=cld, data=data, figax=ax, axis='y', plot='swarmplot', pos='bottom',
              vals='Metric', group='Sample', pad=2, c='black', fs=None, lim=2)
  ```

  ![](tests/figs_readme/output_17_0.png)
  ![](tests/figs_readme/output_17_1.png)


  ```python

  ```


pkgId: 740f2e31357e31af5e5595e0c29b35e6da6f5b1be93c23a3a205ad0be9d48639
name: python3-cloudreactor-procwrapper
arch: noarch
version: 5.4.0
epoch: 0
release: 1
url: https://cloudreactor.io
rpm_license: Dual license, MPL 2.0 or commercial
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cloudreactor-procwrapper-5.4.0-1.src.rpm
location_href: Packages/python3-cloudreactor-procwrapper-5.4.0-1.noarch.rpm
checksum_type: sha256
summary:
  Wraps the execution of processes so that a service API endpoint (CloudReactor) can monitor and manage them. Also implements retries, timeouts, and secret injection from AWS into the environment.

description:
  <p align="center">
    <a href="https://github.com/CloudReactor/cloudreactor-procwrapper/actions?query=workflow%3ACI">
      <img src="https://img.shields.io/github/workflow/status/CloudReactor/cloudreactor-procwrapper/CI/main?label=CI&logo=github&style=flat-square" alt="CI Status" >
    </a>
    <a href="https://cloudreactor-procwrapper.readthedocs.io">
      <img src="https://img.shields.io/readthedocs/cloudreactor-procwrapper.svg?logo=read-the-docs&logoColor=fff&style=flat-square" alt="Documentation Status">
    </a>
    <a href="https://codecov.io/gh/CloudReactor/cloudreactor-procwrapper">
      <img src="https://img.shields.io/codecov/c/github/CloudReactor/cloudreactor-procwrapper.svg?logo=codecov&logoColor=fff&style=flat-square" alt="Test coverage percentage">
    </a>
  </p>
  <p align="center">
    <a href="https://python-poetry.org/">
      <img src="https://img.shields.io/badge/packaging-poetry-299bd7?style=flat-square&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA4AAAASCAYAAABrXO8xAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAJJSURBVHgBfZLPa1NBEMe/s7tNXoxW1KJQKaUHkXhQvHgW6UHQQ09CBS/6V3hKc/AP8CqCrUcpmop3Cx48eDB4yEECjVQrlZb80CRN8t6OM/teagVxYZi38+Yz853dJbzoMV3MM8cJUcLMSUKIE8AzQ2PieZzFxEJOHMOgMQQ+dUgSAckNXhapU/NMhDSWLs1B24A8sO1xrN4NECkcAC9ASkiIJc6k5TRiUDPhnyMMdhKc+Zx19l6SgyeW76BEONY9exVQMzKExGKwwPsCzza7KGSSWRWEQhyEaDXp6ZHEr416ygbiKYOd7TEWvvcQIeusHYMJGhTwF9y7sGnSwaWyFAiyoxzqW0PM/RjghPxF2pWReAowTEXnDh0xgcLs8l2YQmOrj3N7ByiqEoH0cARs4u78WgAVkoEDIDoOi3AkcLOHU60RIg5wC4ZuTC7FaHKQm8Hq1fQuSOBvX/sodmNJSB5geaF5CPIkUeecdMxieoRO5jz9bheL6/tXjrwCyX/UYBUcjCaWHljx1xiX6z9xEjkYAzbGVnB8pvLmyXm9ep+W8CmsSHQQY77Zx1zboxAV0w7ybMhQmfqdmmw3nEp1I0Z+FGO6M8LZdoyZnuzzBdjISicKRnpxzI9fPb+0oYXsNdyi+d3h9bm9MWYHFtPeIZfLwzmFDKy1ai3p+PDls1Llz4yyFpferxjnyjJDSEy9CaCx5m2cJPerq6Xm34eTrZt3PqxYO1XOwDYZrFlH1fWnpU38Y9HRze3lj0vOujZcXKuuXm3jP+s3KbZVra7y2EAAAAAASUVORK5CYII=" alt="Poetry">
    </a>
    <a href="https://github.com/pre-commit/pre-commit">
      <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" alt="pre-commit">
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/cloudreactor-procwrapper/">
      <img src="https://img.shields.io/pypi/v/cloudreactor-procwrapper.svg?logo=python&logoColor=fff&style=flat-square" alt="PyPI Version">
    </a>
    <img src="https://img.shields.io/pypi/pyversions/cloudreactor-procwrapper.svg?style=flat-square&logo=python&amp;logoColor=fff" alt="Supported Python versions">
    <img src="https://img.shields.io/pypi/l/cloudreactor-procwrapper.svg?style=flat-square" alt="License">
  </p>

  Wraps the execution of processes so that an API server
  ([CloudReactor](https://cloudreactor.io/))
  can monitor and manage them.
  Available as a standalone executable or as a python module.



  * Runs either processes started with a command line or a python function you
  supply
  * Implements retries and time limits
  * Injects secrets from AWS Secrets Manager, AWS S3, or local files and extracts
  them into the process environment (for command-lines) or configuration (for
  functions)
  * When used with the CloudReactor service:
    * Reports when a process/function starts and when it exits, along with the
    exit code and runtime metadata (if running in AWS ECS, AWS Lambda, or AWS CodeBuild)
    * Sends heartbeats, optionally with status information like the number of
    items processed
    * Prevents too many concurrent executions
    * Stops execution when manually stopped in the CloudReactor dashboard
    * Sends CloudReactor the data necessary to start the process / function if running in AWS ECS, AWS Lambda, or AWS CodeBuild



  First, secrets and other configuration are fetched and resolved from
  providers like AWS Secrets Manager, AWS S3, or the local filesystem.

  Just before your code runs, the module requests the API server to create a
  Task Execution associated with the Task name or UUID which you pass to the
  module.
  The API server may reject the request if too many instances of the Task are
  currently running, but otherwise records that a Task Execution has started.
  The module then passes control to your code.

  While your code is running, it may report progress to the API server,
  and the API server may signal that your Task stop execution (due to
  user manually stopping the Task Execution), in which
  case the module terminates your code and exits.

  After your code finishes, the module informs the API server of
  the exit code or result. CloudReactor monitors Tasks to ensure they
  are still responsive, and keeps a history of the Executions of Tasks,
  allowing you to view failures and run durations in the past.



  Before your Task is run (including this module),
  the [AWS ECS CloudReactor Deployer](https://github.com/CloudReactor/aws-ecs-cloudreactor-deployer)
  can be used to set it up in AWS ECS,
  and inform CloudReactor of details of your Task.
  That way CloudReactor can start and schedule your Task, and setup your
  Task as a service.
  See [CloudReactor python ECS QuickStart](https://github.com/CloudReactor/cloudreactor-python-ecs-quickstart)
  for an example.

  However, it may not be possible or desired to change your deployment process.
  Instead, you may configure the Task to be *auto-created*.

  Auto-created Tasks are created the first time your Task runs.
  This means there is no need to inform the API server of the Task details
  (during deployment) before it runs.
  Instead, each time the module runs, it informs the API server of the
  Task details at the same time as it requests the creation of a Task Execution.
  One disadvantage of auto-created Tasks is that they are not available
  in the CloudReactor dashboard until the first time they run.

  When configuring a Task to be auto-created, you must specify the name
  or UUID of the Run Environment in CloudReactor that the Task is
  associated with. The Run Environment must be created ahead of time,
  either by the Cloudreactor AWS Setup Wizard,
  or manually in the CloudReactor dashboard.

  You can also specify more Task properties, such as Alert Methods and
  external links in the dashboard, by setting the environment variable
  `PROC_WRAPPER_AUTO_CREATE_TASK_PROPS` set to a JSON-encoded object that has the
  [CloudReactor Task schema](https://apidocs.cloudreactor.io/#operation/tasks_create).



  CloudReactor currently supports four Execution Methods:

  1) [AWS ECS (in Fargate)](https://aws.amazon.com/fargate/)
  2) [AWS Lambda](https://aws.amazon.com/lambda/)
  3) [AWS CodeBuild](https://aws.amazon.com/codebuild/)
  4) Unknown

  If a Task is running in AWS ECS, CloudReactor is able to run additional
  Task Executions, provided the details of running the Task is provided
  during deployment with the AWS ECS CloudReactor Deployer, or if the
  Task is configured to be auto-created, and this module is run. In the
  second case, this module uses the ECS Metadata endpoint to detect
  the ECS Task settings, and sends them to the API server. CloudReactor
  can also schedule Tasks or setup long-running services using Tasks,
  provided they are run in AWS ECS.

  If a Task is running in AWS Lambda, CloudReactor is able to run additional
  Task Executions after the first run of the function.

  However, a Task may use the Unknown execution method if it is not running
  in AWS ECS, AWS Lambda, or AWS CodeBuild. If that is the case, CloudReactor won't be able to
  start the Task in the dashboard or as part of a Workflow,
  schedule the Task, or setup a service with the Task. But the advantage is
  that the Task code can be executed by any method available to you,
  such as bare metal servers, VM's, or Kubernetes.
  All Tasks in CloudReactor, regardless of execution method, have their
  history kept and are monitored.

  This module detects the execution method your Task is
  running with and sends that information to the API server, provided
  you configure your Task to be auto-created.



  Passive Tasks are Tasks that CloudReactor does not manage. This means
  scheduling and service setup must be handled by other means
  (cron jobs, [supervisord](http://supervisord.org/), etc).
  However, Tasks marked as services or that have a schedule will still be
  monitored by CloudReactor, which will send notifications if
  a service Task goes down or a Task does not run on schedule.

  The module reports to the API server that auto-created Tasks are passive,
  unless you specify the `--force-task-passive` commmand-line option or
  set the environment variable `PROC_WRAPPER_TASK_IS_PASSIVE` to `FALSE`.
  If a Task uses the Unknown Execution Method, it must be marked as passive,
  because CloudReactor does not know how to manage it.



  If you just want to use this module to retry processes, limit execution time,
  or fetch secrets, you can use offline mode, in which case no CloudReactor API
  key is required. But CloudReactor offers a free tier so we hope you
  [sign up](https://dash.cloudreactor.io/signup)
  for a free account to enable monitoring and/or management.

  If you want CloudReactor to be able to start your Tasks, you should use the
  [Cloudreactor AWS Setup Wizard](https://github.com/CloudReactor/cloudreactor-aws-setup-wizard)
  to configure your AWS environment to run Tasks in ECS Fargate.
  You can skip this step if running in passive mode is OK for you.

  If you want to use CloudReactor to manage or just monitor your Tasks,
  you need to create a Run Environment and an API key in the CloudReactor
  dashboard. The API key can be scoped to the Run Environment if you
  wish. The key must have at least the Task access level, but for
  an auto-created Task, it must have at least the Developer access level.





  Standalone executables built by [PyInstaller](https://www.pyinstaller.org/) for 64-bit Linux and Windows are available, located in `bin/pyinstaller`.
  These executables bundle
  python so you don't need to have python installed on your machine. They also
  bundle all optional extras so you can fetch secrets from AWS
  Secrets Manager and extract them with jsonpath-ng, for example.



  To download and run the wrapper on a RHEL/Fedora/Amazon Linux 2 machine:

      RUN wget -nv https://github.com/CloudReactor/cloudreactor-procwrapper/raw/5.4.0/bin/pyinstaller/al2/5.4.0/proc_wrapper.bin
      ENTRYPOINT ["proc_wrapper.bin"]

  Example Dockerfiles of known working environments are available for
  [Amazon Linux 2](tests/integration/pyinstaller_executable/docker_context_al2_amd64/)
  and
  [Fedora](tests/integration/pyinstaller_executable/docker_context_al2_amd64/Dockerfile).

  Fedora 27 or later are supported.



  On a Debian based (including Ubuntu) machine:

      RUN wget -nv https://github.com/CloudReactor/cloudreactor-procwrapper/raw/5.4.0/bin/pyinstaller/debian-amd64/5.4.0/proc_wrapper.bin
      ENTRYPOINT ["proc_wrapper.bin"]

  See the example
  [Dockerfile](tests/integration/pyinstaller_executable/docker_context_debian_amd64/Dockerfile) for a known working Debian environment.

  Debian 10 (Buster) or later are supported.

  Special thanks to
  [wine](https://www.winehq.org/) and
  [PyInstaller Docker Images](https://github.com/cdrx/docker-pyinstaller)
  for making it possible to cross-compile!



  Install this module via pip (or your favorite package manager):

  `pip install cloudreactor-procwrapper`

  `cloudreactor-procwrapper` doesn't have any required dependencies, but it can
  be installed with the following extras:

  `aws`: Support for fetching secrets from AWS Secrets Manager or S3, and
  determining the assumed role, implemented by the
  [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
  library

  `jsonpath`: Support for secret resolution using JSON Path, implemented by the
  [jsonpath-ng](https://github.com/h2non/jsonpath-ng) library

  `yaml`: Support for configuration files in YAML format, implemented by the
  [pyyaml](https://pyyaml.org/) library

  `dotenv`: Support for environment variables defined in the dotenv format,
  implemented by the [dotenv](https://github.com/theskumar/python-dotenv) library

  `mergedeep`: Support for secret object value merging using alternative
  strategies, implemented by the
  [mergedeep](https://github.com/clarketm/mergedeep) library

  Use brackets after `cloudreactor-procwrapper` to enable support for the desired
  functionality. For example, to install AWS support, JSON Path secret resolution,
  and support for dotenv files:

      pip install cloudreactor-procwrapper[aws,jsonpath,dotenv]

  Or, to install support for everything:

      pip install cloudreactor-procwrapper[allextras]



  There are two ways of using the module: wrapped mode and embedded mode.



  In wrapped mode, you pass a command line to the module which it
  executes in a child process. The command can be implemented in whatever
  programming language the running machine supports.

  Instead of running

      somecommand --somearg x

  you would run

      ./proc_wrapper somecommand --somearg x

  assuming that are using the PyInstaller standalone executable, and that
  you configure the program using environment variables.

  Or, if you have python installed:

      python -m proc_wrapper somecommand --somearg x

  Here are all the options:

      usage: proc_wrapper [-h] [-v] [-n TASK_NAME] [--task-uuid TASK_UUID] [-a] [--auto-create-task-run-environment-name AUTO_CREATE_TASK_RUN_ENVIRONMENT_NAME]
                          [--auto-create-task-run-environment-uuid AUTO_CREATE_TASK_RUN_ENVIRONMENT_UUID] [--auto-create-task-props AUTO_CREATE_TASK_PROPS] [--force-task-active] [--task-execution-uuid TASK_EXECUTION_UUID]
                          [--task-version-number TASK_VERSION_NUMBER] [--task-version-text TASK_VERSION_TEXT] [--task-version-signature TASK_VERSION_SIGNATURE] [--build-task-execution-uuid BUILD_TASK_EXECUTION_UUID]
                          [--deployment-task-execution-uuid DEPLOYMENT_TASK_EXECUTION_UUID] [--execution-method-props EXECUTION_METHOD_PROPS] [--task-instance-metadata TASK_INSTANCE_METADATA] [-s] [--schedule SCHEDULE]
                          [--max-concurrency MAX_CONCURRENCY] [--max-conflicting-age MAX_CONFLICTING_AGE] [--api-base-url API_BASE_URL] [-k API_KEY] [--api-heartbeat-interval API_HEARTBEAT_INTERVAL]
                          [--api-error-timeout API_ERROR_TIMEOUT] [--api-final-update-timeout API_FINAL_UPDATE_TIMEOUT] [--api-retry-delay API_RETRY_DELAY] [--api-resume-delay API_RESUME_DELAY]
                          [--api-task-execution-creation-error-timeout API_TASK_EXECUTION_CREATION_ERROR_TIMEOUT] [--api-task-execution-creation-conflict-timeout API_TASK_EXECUTION_CREATION_CONFLICT_TIMEOUT]
                          [--api-task-execution-creation-conflict-retry-delay API_TASK_EXECUTION_CREATION_CONFLICT_RETRY_DELAY] [--api-request-timeout API_REQUEST_TIMEOUT] [-o] [-p] [-m API_MANAGED_PROBABILITY]
                          [--api-failure-report-probability API_FAILURE_REPORT_PROBABILITY] [--api-timeout-report-probability API_TIMEOUT_REPORT_PROBABILITY] [-d DEPLOYMENT] [--send-pid] [--send-hostname]
                          [--no-send-runtime-metadata] [--runtime-metadata-refresh-interval RUNTIME_METADATA_REFRESH_INTERVAL] [-l {DEBUG,INFO,WARNING,ERROR,CRITICAL}] [--log-secrets] [--exclude-timestamps-in-log] [-w WORK_DIR]
                          [-c COMMAND_LINE] [--shell-mode {auto,enable,disable}] [--no-strip-shell-wrapping] [--no-process-group-termination] [-t PROCESS_TIMEOUT] [-r PROCESS_MAX_RETRIES] [--process-retry-delay PROCESS_RETRY_DELAY]
                          [--process-check-interval PROCESS_CHECK_INTERVAL] [--process-termination-grace-period PROCESS_TERMINATION_GRACE_PERIOD] [--enable-status-update-listener]
                          [--status-update-socket-port STATUS_UPDATE_SOCKET_PORT] [--status-update-message-max-bytes STATUS_UPDATE_MESSAGE_MAX_BYTES] [--status-update-interval STATUS_UPDATE_INTERVAL] [-e ENV_LOCATIONS]
                          [--config CONFIG_LOCATIONS] [--config-merge-strategy {DEEP,SHALLOW,REPLACE,ADDITIVE,TYPESAFE_REPLACE,TYPESAFE_ADDITIVE}] [--overwrite-env-during-resolution] [--config-ttl CONFIG_TTL]
                          [--no-fail-fast-config-resolution] [--resolved-env-var-name-prefix RESOLVED_ENV_VAR_NAME_PREFIX] [--resolved-env-var-name-suffix RESOLVED_ENV_VAR_NAME_SUFFIX]
                          [--resolved-config-property-name-prefix RESOLVED_CONFIG_PROPERTY_NAME_PREFIX] [--resolved-config-property-name-suffix RESOLVED_CONFIG_PROPERTY_NAME_SUFFIX]
                          [--env-var-name-for-config ENV_VAR_NAME_FOR_CONFIG] [--config-property-name-for-env CONFIG_PROPERTY_NAME_FOR_ENV] [--main-container-name MAIN_CONTAINER_NAME]
                          [--monitor-container-name MONITOR_CONTAINER_NAME] [--sidecar-container-mode] [--rollbar-access-token ROLLBAR_ACCESS_TOKEN] [--rollbar-retries ROLLBAR_RETRIES] [--rollbar-retry-delay ROLLBAR_RETRY_DELAY]
                          [--rollbar-timeout ROLLBAR_TIMEOUT]
                          ...

      Wraps the execution of processes so that a service API endpoint (CloudReactor) is optionally informed of the progress. Also implements retries, timeouts, and secret injection into the environment.

      positional arguments:
        command

      optional arguments:
        -h, --help            show this help message and exit
        -v, --version         Print the version and exit

      task:
        Task settings

        -n TASK_NAME, --task-name TASK_NAME
                              Name of Task (either the Task Name or the Task UUID must be specified
        --task-uuid TASK_UUID
                              UUID of Task (either the Task Name or the Task UUID must be specified)
        -a, --auto-create-task
                              Create the Task even if not known by the API server
        --auto-create-task-run-environment-name AUTO_CREATE_TASK_RUN_ENVIRONMENT_NAME
                              Name of the Run Environment to use if auto-creating the Task (either the name or UUID of the Run Environment must be specified if auto-creating the Task). Defaults to the deployment name if the Run
                              Environment UUID is not specified.
        --auto-create-task-run-environment-uuid AUTO_CREATE_TASK_RUN_ENVIRONMENT_UUID
                              UUID of the Run Environment to use if auto-creating the Task (either the name or UUID of the Run Environment must be specified if auto-creating the Task)
        --auto-create-task-props AUTO_CREATE_TASK_PROPS
                              Additional properties of the auto-created Task, in JSON format. See https://apidocs.cloudreactor.io/#operation/api_v1_tasks_create for the schema.
        --force-task-active   Indicates that the auto-created Task should be scheduled and made a service by the API server, if applicable. Otherwise, auto-created Tasks are marked passive.
        --task-execution-uuid TASK_EXECUTION_UUID
                              UUID of Task Execution to attach to
        --task-version-number TASK_VERSION_NUMBER
                              Numeric version of the Task's source code
        --task-version-text TASK_VERSION_TEXT
                              Human readable version of the Task's source code
        --task-version-signature TASK_VERSION_SIGNATURE
                              Version signature of the Task's source code (such as a git commit hash)
        --build-task-execution-uuid BUILD_TASK_EXECUTION_UUID
                              UUID of Task Execution that built this Task's source code
        --deployment-task-execution-uuid DEPLOYMENT_TASK_EXECUTION_UUID
                              UUID of Task Execution that deployed this Task to the Runtime Environment
        --execution-method-props EXECUTION_METHOD_PROPS
                              Additional properties of the execution method, in JSON format. See https://apidocs.cloudreactor.io/#operation/api_v1_task_executions_create for the schema.
        --task-instance-metadata TASK_INSTANCE_METADATA
                              Additional metadata about the Task instance, in JSON format
        -s, --service         Indicate that this is a Task that should run indefinitely
        --schedule SCHEDULE   Run schedule reported to the API server
        --max-concurrency MAX_CONCURRENCY
                              Maximum number of concurrent Task Executions of the same Task. Defaults to 1.
        --max-conflicting-age MAX_CONFLICTING_AGE
                              Maximum age of conflicting Tasks to consider, in seconds. -1 means no limit. Defaults to the heartbeat interval, plus 60 seconds for services that send heartbeats. Otherwise, defaults to no limit.

      api:
        API client settings

        --api-base-url API_BASE_URL
                              Base URL of API server. Defaults to https://api.cloudreactor.io
        -k API_KEY, --api-key API_KEY
                              API key. Must have at least the Task access level, or Developer access level for auto-created Tasks.
        --api-heartbeat-interval API_HEARTBEAT_INTERVAL
                              Number of seconds to wait between sending heartbeats to the API server. -1 means to not send heartbeats. Defaults to 30 for concurrency limited services, 300 otherwise.
        --api-error-timeout API_ERROR_TIMEOUT
                              Number of seconds to wait while receiving recoverable errors from the API server. Defaults to 300.
        --api-final-update-timeout API_FINAL_UPDATE_TIMEOUT
                              Number of seconds to wait while receiving recoverable errors from the API server when sending the final update before exiting. Defaults to 1800.
        --api-retry-delay API_RETRY_DELAY
                              Number of seconds to wait before retrying an API request. Defaults to 120.
        --api-resume-delay API_RESUME_DELAY
                              Number of seconds to wait before resuming API requests, after retries are exhausted. Defaults to 600. -1 means to never resume.
        --api-task-execution-creation-error-timeout API_TASK_EXECUTION_CREATION_ERROR_TIMEOUT
                              Number of seconds to keep retrying Task Execution creation while receiving error responses from the API server. -1 means to keep trying indefinitely. Defaults to 300.
        --api-task-execution-creation-conflict-timeout API_TASK_EXECUTION_CREATION_CONFLICT_TIMEOUT
                              Number of seconds to keep retrying Task Execution creation while conflict is detected by the API server. -1 means to keep trying indefinitely. Defaults to 1800 for concurrency limited services, 0
                              otherwise.
        --api-task-execution-creation-conflict-retry-delay API_TASK_EXECUTION_CREATION_CONFLICT_RETRY_DELAY
                              Number of seconds between attempts to retry Task Execution creation after conflict is detected. Defaults to 60 for concurrency-limited services, 120 otherwise.
        --api-request-timeout API_REQUEST_TIMEOUT
                              Timeout for contacting API server, in seconds. Defaults to 30.
        -o, --offline-mode    Do not communicate with or rely on an API server
        -p, --prevent-offline-execution
                              Do not start processes if the API server is unavailable or the wrapper is misconfigured.
        -m API_MANAGED_PROBABILITY, --api-managed-probability API_MANAGED_PROBABILITY
                              Sample notifications to the API server with a given probability when starting an execution. Defaults to 1.0 (always send notifications).
        --api-failure-report-probability API_FAILURE_REPORT_PROBABILITY
                              If the notification of an execution was not previously sent on startup and the execution fails, notify the API server with the given probability. Defaults to 1.0 (always send failure notifications).
        --api-timeout-report-probability API_TIMEOUT_REPORT_PROBABILITY
                              If the notification of an execution was not previously sent on startup and the execution times out, notify the API server with given probability. Defaults to 1.0 (always send timeout notifications).
        -d DEPLOYMENT, --deployment DEPLOYMENT
                              Deployment name (production, staging, etc.)
        --send-pid            Send the process ID to the API server
        --send-hostname       Send the hostname to the API server
        --no-send-runtime-metadata
                              Do not send metadata about the runtime environment
        --runtime-metadata-refresh-interval RUNTIME_METADATA_REFRESH_INTERVAL
                              Refresh interval for runtime metadata, in seconds. The default value depends on the execution method.

      log:
        Logging settings

        -l {DEBUG,INFO,WARNING,ERROR,CRITICAL}, --log-level {DEBUG,INFO,WARNING,ERROR,CRITICAL}
                              Log level
        --log-secrets         Log sensitive information
        --exclude-timestamps-in-log
                              Exclude timestamps in log (possibly because the log stream will be enriched by timestamps automatically by a logging service like AWS CloudWatch Logs)

      process:
        Process settings

        -w WORK_DIR, --work-dir WORK_DIR
                              Working directory. Defaults to the current directory.
        -c COMMAND_LINE, --command-line COMMAND_LINE
                              Command line to execute
        --shell-mode {auto,enable,disable}
                              Indicates if the process command should be executed in a shell. Executing in a shell allows shell scripts, commands, and expressions to be used, with the disadvantage that termination signals may not
                              be propagated to child processes. Options are: enable -- Force the command to be executed in a shell; disable -- Force the command to be executed without a shell; auto -- Auto-detect the shell mode by
                              analyzing the command.
        --no-strip-shell-wrapping
                              Do not strip the command-line of shell wrapping like "/bin/sh -c" that can be introduced by Docker when using shell form of ENTRYPOINT and CMD.
        --no-process-group-termination
                              Send termination and kill signals to the wrapped process only, instead of its process group (which is the default). Sending to the process group allows all child processes to receive the signals, even
                              if the wrapped process does not forward signals. However, if your wrapped process manually handles and forwards signals to its child processes, you probably want to send signals to only your wrapped
                              process.
        -t PROCESS_TIMEOUT, --process-timeout PROCESS_TIMEOUT
                              Timeout for process completion, in seconds. -1 means no timeout, which is the default.
        -r PROCESS_MAX_RETRIES, --process-max-retries PROCESS_MAX_RETRIES
                              Maximum number of times to retry failed processes. -1 means to retry forever. Defaults to 0.
        --process-retry-delay PROCESS_RETRY_DELAY
                              Number of seconds to wait before retrying a process. Defaults to 60.
        --process-check-interval PROCESS_CHECK_INTERVAL
                              Number of seconds to wait between checking the status of processes. Defaults to 10.
        --process-termination-grace-period PROCESS_TERMINATION_GRACE_PERIOD
                              Number of seconds to wait after sending SIGTERM to a process, but before killing it with SIGKILL. Defaults to 30.

      updates:
        Status update settings

        --enable-status-update-listener
                              Listen for status updates from the process, sent on the status socket port via UDP. If not specified, status update messages will not be read.
        --status-update-socket-port STATUS_UPDATE_SOCKET_PORT
                              The port used to receive status updates from the process. Defaults to 2373.
        --status-update-message-max-bytes STATUS_UPDATE_MESSAGE_MAX_BYTES
                              The maximum number of bytes status update messages can be. Defaults to 65536.
        --status-update-interval STATUS_UPDATE_INTERVAL
                              Minimum of number of seconds to wait between sending status updates to the API server. -1 means to not send status updates except with heartbeats. Defaults to -1.

      configuration:
        Environment/configuration resolution settings

        -e ENV_LOCATIONS, --env ENV_LOCATIONS
                              Location of either local file, AWS S3 ARN, or AWS Secrets Manager ARN containing properties used to populate the environment for embedded mode, or the process environment for wrapped mode. By default,
                              the file format is assumed to be dotenv. Specify multiple times to include multiple locations.
        --config CONFIG_LOCATIONS
                              Location of either local file, AWS S3 ARN, or AWS Secrets Manager ARN containing properties used to populate the configuration for embedded mode. By default, the file format is assumed to be in JSON.
                              Specify multiple times to include multiple locations.
        --config-merge-strategy {DEEP,SHALLOW,REPLACE,ADDITIVE,TYPESAFE_REPLACE,TYPESAFE_ADDITIVE}
                              Merge strategy for merging configurations. Defaults to 'DEEP', which does not require mergedeep. Besides the 'SHALLOW' strategy, all other strategies require the mergedeep extra to be installed.
        --overwrite-env-during-resolution
                              Overwrite existing environment variables when resolving them
        --config-ttl CONFIG_TTL
                              Number of seconds to cache resolved environment variables and configuration properties instead of refreshing them when a process restarts. -1 means to never refresh. Defaults to -1.
        --no-fail-fast-config-resolution
                              Continue execution even if an error occurs resolving the configuration
        --resolved-env-var-name-prefix RESOLVED_ENV_VAR_NAME_PREFIX
                              Required prefix for names of environment variables that should resolved. The prefix will be removed in the resolved variable name. Defaults to ''.
        --resolved-env-var-name-suffix RESOLVED_ENV_VAR_NAME_SUFFIX
                              Required suffix for names of environment variables that should resolved. The suffix will be removed in the resolved variable name. Defaults to '_FOR_PROC_WRAPPER_TO_RESOLVE'.
        --resolved-config-property-name-prefix RESOLVED_CONFIG_PROPERTY_NAME_PREFIX
                              Required prefix for names of configuration properties that should resolved. The prefix will be removed in the resolved property name. Defaults to ''.
        --resolved-config-property-name-suffix RESOLVED_CONFIG_PROPERTY_NAME_SUFFIX
                              Required suffix for names of configuration properties that should resolved. The suffix will be removed in the resolved property name. Defaults to '__to_resolve'.
        --env-var-name-for-config ENV_VAR_NAME_FOR_CONFIG
                              The name of the environment variable used to set to the value of the JSON encoded configuration. Defaults to not setting any environment variable.
        --config-property-name-for-env CONFIG_PROPERTY_NAME_FOR_ENV
                              The name of the configuration property used to set to the value of the JSON encoded environment. Defaults to not setting any property.

      container:
        Container settings

        --main-container-name MAIN_CONTAINER_NAME
                              The name of the container that is monitored
        --monitor-container-name MONITOR_CONTAINER_NAME
                              The name of the container that will monitor the main container
        --sidecar-container-mode
                              Indicates that the current container is a sidecar container that will monitor the main container

      rollbar:
        Rollbar settings

        --rollbar-access-token ROLLBAR_ACCESS_TOKEN
                              Access token for Rollbar (used to report error when communicating with API server)
        --rollbar-retries ROLLBAR_RETRIES
                              Number of retries per Rollbar request. Defaults to 2.
        --rollbar-retry-delay ROLLBAR_RETRY_DELAY
                              Number of seconds to wait before retrying a Rollbar request. Defaults to 120.
        --rollbar-timeout ROLLBAR_TIMEOUT
                              Timeout for contacting Rollbar server, in seconds. Defaults to 30.



  These environment variables take precedence over command-line arguments:

  * PROC_WRAPPER_TASK_NAME
  * PROC_WRAPPER_TASK_UUID
  * PROC_WRAPPER_TASK_EXECUTION_UUID
  * PROC_WRAPPER_AUTO_CREATE_TASK (TRUE or FALSE)
  * PROC_WRAPPER_AUTO_CREATE_TASK_RUN_ENVIRONMENT_NAME
  * PROC_WRAPPER_AUTO_CREATE_TASK_RUN_ENVIRONMENT_UUID
  * PROC_WRAPPER_AUTO_CREATE_TASK_PROPS (JSON encoded property map)
  * PROC_WRAPPER_TASK_IS_PASSIVE (TRUE OR FALSE)
  * PROC_WRAPPER_TASK_IS_SERVICE (TRUE or FALSE)
  * PROC_WRAPPER_EXECUTION_METHOD_PROPS (JSON encoded property map)
  * PROC_WRAPPER_TASK_MAX_CONCURRENCY (set to -1 to indicate no limit)
  * PROC_WRAPPER_PREVENT_OFFLINE_EXECUTION (TRUE or FALSE)
  * PROC_WRAPPER_TASK_VERSION_NUMBER
  * PROC_WRAPPER_TASK_VERSION_TEXT
  * PROC_WRAPPER_TASK_VERSION_SIGNATURE
  * PROC_WRAPPER_TASK_INSTANCE_METADATA (JSON encoded property map)
  * PROC_WRAPPER_LOG_LEVEL (TRACE, DEBUG, INFO, WARNING, ERROR, or CRITICAL)
  * PROC_WRAPPER_LOG_SECRETS (TRUE or FALSE)
  * PROC_WRAPPER_INCLUDE_TIMESTAMPS_IN_LOG (TRUE or FALSE)
  * PROC_WRAPPER_DEPLOYMENT
  * PROC_WRAPPER_API_BASE_URL
  * PROC_WRAPPER_API_KEY
  * PROC_WRAPPER_API_HEARTBEAT_INTERVAL_SECONDS
  * PROC_WRAPPER_API_ERROR_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_RETRY_DELAY_SECONDS
  * PROC_WRAPPER_API_RESUME_DELAY_SECONDS
  * PROC_WRAPPER_API_TASK_EXECUTION_CREATION_ERROR_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_TASK_EXECUTION_CREATION_CONFLICT_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_TASK_EXECUTION_CREATION_CONFLICT_RETRY_DELAY_SECONDS
  * PROC_WRAPPER_API_FINAL_UPDATE_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_REQUEST_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_MANAGED_PROBABILITY
  * PROC_WRAPPER_API_FAILURE_REPORT_PROBABILITY
  * PROC_WRAPPER_API_TIMEOUT_REPORT_PROBABILITY
  * PROC_WRAPPER_ENV_LOCATIONS (comma-separated list of locations)
  * PROC_WRAPPER_CONFIG_LOCATIONS (comma-separated list of locations)
  * PROC_WRAPPER_OVERWRITE_ENV_WITH_SECRETS (TRUE or FALSE)
  * PROC_WRAPPER_RESOLVE_SECRETS (TRUE or FALSE)
  * PROC_WRAPPER_MAX_CONFIG_RESOLUTION_DEPTH
  * PROC_WRAPPER_MAX_CONFIG_RESOLUTION_ITERATIONS
  * PROC_WRAPPER_CONFIG_TTL_SECONDS
  * PROC_WRAPPER_FAIL_FAST_CONFIG_RESOLUTION (TRUE or FALSE)
  * PROC_WRAPPER_RESOLVABLE_ENV_VAR_NAME_PREFIX
  * PROC_WRAPPER_RESOLVABLE_ENV_VAR_NAME_SUFFIX
  * PROC_WRAPPER_RESOLVABLE_CONFIG_PROPERTY_NAME_PREFIX
  * PROC_WRAPPER_RESOLVABLE_CONFIG_PROPERTY_NAME_SUFFIX
  * PROC_WRAPPER_ENV_VAR_NAME_FOR_CONFIG
  * PROC_WRAPPER_CONFIG_PROPERTY_NAME_FOR_ENV
  * PROC_WRAPPER_SEND_PID (TRUE or FALSE)
  * PROC_WRAPPER_SEND_HOSTNAME (TRUE or FALSE)
  * PROC_WRAPPER_SEND_RUNTIME_METADATA (TRUE or FALSE)
  * PROC_WRAPPER_MAX_CONFLICTING_AGE_SECONDS
  * PROC_WRAPPER_TASK_COMMAND
  * PROC_WRAPPER_SHELL_MODE (TRUE or FALSE)
  * PROC_WRAPPER_STRIP_SHELL_WRAPPING (TRUE or FALSE)
  * PROC_WRAPPER_WORK_DIR
  * PROC_WRAPPER_PROCESS_MAX_RETRIES
  * PROC_WRAPPER_PROCESS_TIMEOUT_SECONDS
  * PROC_WRAPPER_PROCESS_RETRY_DELAY_SECONDS
  * PROC_WRAPPER_PROCESS_CHECK_INTERVAL_SECONDS
  * PROC_WRAPPER_PROCESS_TERMINATION_GRACE_PERIOD_SECONDS
  * PROC_WRAPPER_PROCESS_GROUP_TERMINATION (TRUE or FALSE)
  * PROC_WRAPPER_STATUS_UPDATE_SOCKET_PORT
  * PROC_WRAPPER_STATUS_UPDATE_MESSAGE_MAX_BYTES
  * PROC_WRAPPER_ROLLBAR_ACCESS_TOKEN
  * PROC_WRAPPER_MAIN_CONTAINER_NAME
  * PROC_WRAPPER_MONITOR_CONTAINER_NAME
  * PROC_WRAPPER_SIDECAR_CONTAINER_MODE (TRUE or FALSE)
  * PROC_WRAPPER_ROLLBAR_TIMEOUT_SECONDS
  * PROC_WRAPPER_ROLLBAR_RETRIES
  * PROC_WRAPPER_ROLLBAR_RETRY_DELAY_SECONDS

  With the exception of the settings for Secret Fetching and Resolution,
  these environment variables are read after Secret Fetching so that they can
  come from secret values.

  The command is executed with the same environment that the wrapper script gets,
  except that these properties are copied/overridden:

  * PROC_WRAPPER_DEPLOYMENT
  * PROC_WRAPPER_API_BASE_URL
  * PROC_WRAPPER_API_KEY
  * PROC_WRAPPER_API_ERROR_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_RETRY_DELAY_SECONDS
  * PROC_WRAPPER_API_RESUME_DELAY_SECONDS
  * PROC_WRAPPER_API_REQUEST_TIMEOUT_SECONDS
  * PROC_WRAPPER_API_MANAGED_PROBABILITY
  * PROC_WRAPPER_API_FAILURE_REPORT_PROBABILITY
  * PROC_WRAPPER_API_TIMEOUT_REPORT_PROBABILITY
  * PROC_WRAPPER_ROLLBAR_ACCESS_TOKEN
  * PROC_WRAPPER_ROLLBAR_TIMEOUT_SECONDS
  * PROC_WRAPPER_ROLLBAR_RETRIES
  * PROC_WRAPPER_ROLLBAR_RETRY_DELAY_SECONDS
  * PROC_WRAPPER_ROLLBAR_RESUME_DELAY_SECONDS
  * PROC_WRAPPER_TASK_EXECUTION_UUID
  * PROC_WRAPPER_TASK_UUID
  * PROC_WRAPPER_TASK_NAME
  * PROC_WRAPPER_TASK_VERSION_NUMBER
  * PROC_WRAPPER_TASK_VERSION_TEXT
  * PROC_WRAPPER_TASK_VERSION_SIGNATURE
  * PROC_WRAPPER_TASK_INSTANCE_METADATA
  * PROC_WRAPPER_SCHEDULE
  * PROC_WRAPPER_PROCESS_TIMEOUT_SECONDS
  * PROC_WRAPPER_TASK_MAX_CONCURRENCY
  * PROC_WRAPPER_PREVENT_OFFLINE_EXECUTION
  * PROC_WRAPPER_PROCESS_TERMINATION_GRACE_PERIOD_SECONDS
  * PROC_WRAPPER_ENABLE_STATUS_UPDATE_LISTENER
  * PROC_WRAPPER_STATUS_UPDATE_SOCKET_PORT
  * PROC_WRAPPER_STATUS_UPDATE_INTERVAL_SECONDS
  * PROC_WRAPPER_STATUS_UPDATE_MESSAGE_MAX_BYTES

  Wrapped mode is suitable for running in a shell on your own (virtual) machine
  or in a Docker container. It requires multi-process support, as the module
  runs at the same time as the command it wraps.

  In AWS ECS, it is possible to run proc_wrapper in sidecar container that
  monitors another (main) container. In that case, proc_wrapper will report the
  status and runtime metadata of the main container. The advantage of running
  proc_wrapper in a sidecar container is that the main container doesn't need
  to be modified to run proc_wrapper. To configure proc_wrapper as a sidecar,
  set the main container name and enable sidecar container mode.



  You can use embedded mode to execute python code from inside a python program.
  Include the `proc_wrapper` package in your python project's
  dependencies. To run a task you want to be monitored:

      from typing import Any, Mapping

      from proc_wrapper import ProcWrapper, ProcWrapperParams


      def fun(wrapper: ProcWrapper, cbdata: dict[str, int],
              config: Mapping[str, Any]) -> int:
          print(cbdata)
          return cbdata['a']


      
      def entrypoint(event: Any, context: Any) -> int:
          params = ProcWrapperParams()
          params.auto_create_task = True

          
          
          
          proc_wrapper_params.task_is_passive = False

          params.task_name = 'embedded_test_production'
          params.auto_create_task_run_environment_name = 'production'

          
          
          params.api_key = 'YOUR_CLOUDREACTOR_API_KEY'

          
          
          proc_wrapper = ProcWrapper(params=params, runtime_context=context,
              input_value=event)

          x = proc_wrapper.managed_call(fun, {'a': 1, 'b': 2})
          
          print(x)

          return x

  This is suitable for running in single-threaded environments like
  AWS Lambda, or as part of a larger process that executes
  sub-routines that should be monitored. See
  [cloudreactor-python-lambda-quickstart](https://github.com/CloudReactor/cloudreactor-python-lambda-quickstart)
  for an example project that uses proc_wrapper in a function run by AWS Lambda.



  In embedded mode, besides setting properties of `ProcWrapperParams` in code,
  `ProcWrapper` can be also configured in two ways:

  First, using environment variables, as in wrapped mode.

  Second, using the configuration dictionary. If the configuration dictionary
  contains the key `proc_wrapper_params` and its value is a dictionary, the
  keys and values in the dictionary will be used to to set these attributes in
  `ProcWrapperParams`:

  | Key                              	               | Type      	| Mutable 	| Uses Resolved Config 	 |
  |--------------------------------------------------|-----------	|---------	|------------------------|
  | log_secrets                      	               | bool      	| No      	| No                   	 |
  | env_locations                    	               | list[str] 	| No      	| No                   	 |
  | config_locations                 	               | list[str] 	| No      	| No                   	 |
  | config_merge_strategy            	               | str       	| No      	| No                   	 |
  | overwrite_env_during_resolution  	               | bool      	| No      	| No                   	 |
  | max_config_resolution_depth      	               | int       	| No      	| No                   	 |
  | max_config_resolution_iterations 	               | int       	| No      	| No                   	 |
  | config_ttl                       	               | int       	| No      	| No                   	 |
  | fail_fast_config_resolution      	               | bool      	| No      	| No                   	 |
  | resolved_env_var_name_prefix     	               | str       	| No      	| No                   	 |
  | resolved_env_var_name_suffix     	               | str       	| No      	| No                   	 |
  | resolved_config_property_name_prefix             | str     	| No      	| No                   	 |
  | resolved_config_property_name_suffix             | str    	| No      	| No                   	 |
  | schedule                                         | str       	| No      	| Yes                  	 |
  | max_concurrency                                  | int       	| No      	| Yes                  	 |
  | max_conflicting_age                              | int       	| No      	| Yes                  	 |
  | offline_mode                                     | bool       	| No      	| Yes                  	 |
  | prevent_offline_execution                        | bool       	| No      	| Yes                  	 |
  | service                                          | bool       	| No      	| Yes                  	 |
  | deployment                                       | str       	| No      	| Yes                  	 |
  | api_base_url                                     | str       	| No      	| Yes                  	 |
  | api_heartbeat_interval                           | int       	| No      	| Yes                  	 |
  | enable_status_listener                           | bool      	| No      	| Yes                  	 |
  | status_update_socket_port                        | int        	| No      	| Yes                  	 |
  | status_update_message_max_bytes                  | int        	| No      	| Yes                  	 |
  | status_update_interval                           | int        	| No      	| Yes                  	 |
  | log_level                                        | str        	| No      	| Yes                  	 |
  | include_timestamps_in_log                        | bool      	| No      	| Yes                  	 |
  | api_key                                          | str        	| Yes     	| Yes                  	 |
  | api_request_timeout                              | int        	| Yes      	| Yes                  	 |
  | api_error_timeout                                | int        	| Yes     	| Yes                  	 |
  | api_retry_delay                                  | int        	| Yes     	| Yes                  	 |
  | api_resume_delay                                 | int        	| Yes     	| Yes                  	 |
  | api_task_execution_creation_error_timeout        | int | Yes     	| Yes                  	 |
  | api_task_execution_creation_conflict_timeout     | int | Yes    | Yes                  	 |
  | api_task_execution_creation_conflict_retry_delay | int| Yes	| Yes                  	 |
  | api-managed-probability                          | float         | No        | Yes                    |
  | api-failure-report-probability                   | float         | No        | Yes                    |
  | api-timeout-report-probability                   | float         | No        | Yes                    |
  | process_timeout                                  | int        	| Yes     	| Yes                  	 |
  | process_max_retries                              | int        	| Yes     	| Yes                  	 |
  | process_retry_delay                              | int        	| Yes     	| Yes                  	 |
  | command                                          | list[str]  	| Yes     	| Yes                  	 |
  | command_line                                     | str        	| Yes     	| Yes                  	 |
  | shell_mode                                       | bool      	| Yes     	| Yes                  	 |
  | strip_shell_wrapping                             | bool      	| Yes     	| Yes                  	 |
  | work_dir                                         | str       	| Yes     	| Yes                  	 |
  | process_termination_grace_period                 | int       	| Yes     	| Yes                  	 |
  | send_pid                                         | bool      	| Yes     	| Yes                  	 |
  | send_hostname                                    | bool      	| Yes     	| Yes                  	 |
  | send_runtime_metadata                            | bool      	| Yes     	| Yes                  	 |

  Keys that are marked with "Mutable" -- "No" in the table above can be
  overridden when the configuration is reloaded after the `config_ttl` expires.

  Keys that are marked as "Uses Resolved Config" -- "Yes" in the table above can
  come from the resolved configuration after secret resolution (see below).



  A common requirement is that deployed code / images do not contain secrets
  internally which could be decompiled. Instead, programs should fetch secrets
  from an external source in a secure manner. If your program runs in AWS, it
  can make use of AWS's roles that have permission to access data in
  Secrets Manager or S3. However, in many scenarios, having your program access
  AWS directly has the following disadvantages:

  1) Your program becomes coupled to AWS, so it is difficult to run locally or
  switch to another infrastructure provider
  2) You need to write code or use a library for each programming language you
  use, so secret fetching is done in a non-uniform way
  3) Writing code to merge and parse secrets from different sources is tedious

  Therefore, proc_wrapper implements Secret Fetching and Resolution to solve
  these problems so your programs don't have to. Both usage modes can fetch secrets from
  [AWS Secrets Manager](https://aws.amazon.com/secrets-manager/),
  AWS S3, or the local filesystem, and optionally extract embedded data
  into the environment or a configuration dictionary. The environment is used to
  pass values to processes run in wrapped mode,
  while the configuration dictionary is passed to the callback function in
  embedded mode.

  proc_wrapper parses secret location strings that specify the how to resolve
  a secret value. Each secret location string has the format:

  `[PROVIDER_CODE:]<Provider specific address>[!FORMAT][|JP:<JSON Path expression>]`



  Providers indicate the raw source of the secret data. The table below lists the
  supported providers:

  | Provider Code 	| Value Prefix              	| Provider                     	| Example Address                                             	| Required extras            | Notes                                                         	|
  |---------------	|---------------------------	|------------------------------	|-------------------------------------------------------------	|-----------------------------------------------------------------------------	|---------------------------------------------------------------	|
  | `AWS_SM`      	| `arn:aws:secretsmanager:` 	| AWS Secrets Manager          	| `arn:aws:secretsmanager:us-east-2:1234567890:secret:config` 	| aws 	| Can also include version suffix like `-PPrpY`                 	|
  | `AWS_S3`      	| `arn:aws:s3:::`           	| AWS S3 Object                	| `arn:aws:s3:::examplebucket/staging/app1/config.json`       	| aws 	|                                                               	|
  | `FILE`        	| `file://`                 	| Local file                   	| `file:///home/appuser/app/.env`                                    	|                                                                             	| The default provider if no provider is auto-detected          	|
  | `ENV`         	|                           	| The process environment      	| `SOME_TOKEN`                                                	|                                                                             	| The name of another environment variable                      	|
  | `CONFIG`      	|                           	| The configuration dictionary 	| `$.db`                                                      	| jsonpath         	| JSON path expression to extract the data in the configuration 	|
  | `PLAIN`       	|                           	| Plaintext                    	| `{"user": "postgres", "password": "badpassword"}`           	|                                                                             	|                                                               	|

  If you don't specify an explicit provider prefix in a secret location
  (e.g. `AWS_SM:`), the provider can be auto-detected from the address portion
  using the Value Prefix. For example the secret location
  `arn:aws:s3:::examplebucket/staging/app1/config.json` will be auto-detected
  to with the AWS_S3 provider because it starts with `arn:aws:s3:::`.



  Formats indicate how the raw string data is parsed into a secret value (which may be
  a string, number, boolean, dictionary, or array). The table below lists the
  supported formats:

  | Format Code 	| Extensions      	| MIME types                                                                            	| Required extras                                        	| Notes                                            	|
  |-------------	|-----------------	|---------------------------------------------------------------------------------------	|------------------------------------------------------	|--------------------------------------------------	|
  | `dotenv`    	| `.env`          	| None                                                                                  	| dotenv 	| Also auto-detected if location includes `.env.`  	|
  | `json`      	| `.json`         	| `application/json`, `text/x-json`                                                     	|                                               	|  	|
  | `yaml`      	| `.yaml`, `.yml` 	| `application/x-yaml`, `application/yaml`, `text/vnd.yaml`, `text/yaml`, `text/x-yaml` 	| yaml                        	| pyyaml's `safe_load()` is used for security               	|

  The format of a secret value can be auto-detected from the extension or by the
  MIME type if available. Otherwise, you may need to an explicit format code
  (e.g. `!yaml`).



  [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
  is used to fetch secrets when the `aws` extra is installed. It will try to
  access to AWS Secrets Manager or S3 using environment variables
  `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` if they are set, or use the EC2
  instance role, ECS task role, or Lambda execution role if available.

  For Secrets Manager, you can also use "partial ARNs" (without the hyphened
  suffix) as keys. In the example above

      arn:aws:secretsmanager:us-east-2:1234567890:secret:config

  could be used to fetch the same secret, provided there are no conflicting secret ARNs.
  This allows you to get the latest version of the secret.

  If the secret was stored in Secrets Manager as binary, the
  corresponding value will be set to the Base-64 encoded value.

  If you're deploying a python function using AWS Lambda, note that boto3 is
  already included in the available packages, so there's no need to include it
  (unless the bundled version isn't compatible). Also we strongly encourage you
  to add:

      logging.getLogger("botocore").setLevel(logging.INFO)

  to your code if you are using proc_wrapper for secrets resolution. This
  prevent secrets from Secrets Manager from being leaked. For details, see this
  [issue](https://github.com/boto/boto3/issues/2292).



  Fetching secrets can be relatively expensive and it makes sense to group related
  secrets together. Therefore it is common to store dictionaries (formatted
  as JSON or YAML) as secrets. However, each desired environment variable
  or configuration property may only consist of a fragment of the dictionary.
  For example, given the JSON-formatted dictionary

      {
        "username": "postgres",
        "password": "badpassword"
      }

  you may want to populate the environment variable `DB_USERNAME` with
  `postgres`.

  To facilitate this, dictionary fragments can be extracted to individual
  environment variables using [jsonpath-ng](https://github.com/h2non/jsonpath-ng)
  when the `jsonpath` extra is installed.
  To specify that a variable be extracted from a dictionary using
  a JSON Path expression, append `|JP:` followed by the JSON Path expression
  to the secret location string. For example, if the AWS Secrets Manager
  ARN

      arn:aws:secretsmanager:us-east-2:1234567890:secret:db-PPrpY

  contains the dictionary above, then the secret location string

      arn:aws:secretsmanager:us-east-2:1234567890:secret:db-PPrpY|JP:$.username

  will resolve to `postgres` as desired.

  If you do something similar to get the password from the same JSON value,
  proc_wrapper is smart enough to cache the fetched dictionary, so that the
  raw data is only fetched once.

  Since JSON path expressions yield a list of results, the secrets fetcher
  implements the following rules to transform the list to the final value:

  1. If the list of results has a single value, that value is used as the
  final value, unless `[*]` is appended to the JSON path expression.
  2. Otherwise, the final value is the list of results



  In some deployment scenarios, multiple secrets can be injected into a
  single environment variable as a JSON encoded object. In that case,
  the module can extract secrets using the *ENV* secret source. For example,
  you may have arranged to have the environment variable DB_CONFIG injected
  with the JSON encoded value:

      { "username": "postgres", "password": "nohackme" }

  Then to extract the username to the environment variable DB_USERNAME you
  you would add the environment variable DB_USER_FOR_PROC_WRAPPER_TO_RESOLVE
  set to

      ENV:DB_CONFIG|JP:$.username



  Now let's use secret location strings to
  inject the values into the environment (for wrapped mode)
  and/or the the configuration dictionary (for embedded mode). proc_wrapper
  supports two methods of secret injection which can be combined together:

  * Top-level fetching
  * Secrets Resolution



  Top-level fetching refers to fetching a dictionary that contains multiple secrets
  and populating the environment / configuration dictionary with it.
  To use top-level fetching, you specify the secret locations
  from which you want to fetch the secrets and the corresponding values are
  merged together into the environment / configuration.

  To use top-level fetching in wrapped mode, populate the
  environment variables `PROC_WRAPPER_ENV_LOCATIONS` with a comma-separated
  list of secret locations, or use the command-line option
  `--env-locations <secret_location>` one or more times. Secret location
  strings passed in via `PROC_WRAPPER_ENV_LOCATIONS` or `--env-locations`
  will be parsed as `dotenv` files unless format is auto-detected or
  explicitly specified.

  To use top-level fetching in embedded mode, set the `ProcWrapperParams` property
  `config_locations` to a list of secret locations. Alternatively, you can set
  the environment variable `PROC_WRAPPER_CONFIG_LOCATIONS` to a comma-separated
  list, and this will be picked up automatically. Secret location values
  will be parsed as JSON unless the format is auto-detected or explicitly
  specified. The `config` argument
  passed to the your callback function will contain a merged dictionary of all
  fetched and parsed dictionary values. For example:

      def callback(wrapper: ProcWrapper, cbdata: str,
              config: Dict[str, Any]) -> str:
          return "super" + cbdata + config["username"]


      def main():
          params = ProcWrapperParams()

          
          
          params.initial_config = {
              "log_level": "DEBUG"
          }

          
          
          params.config_locations = [
              "arn:aws:secretsmanager:us-east-2:1234567890:secret:db-PPrpY",
              
              
          ]

          wrapper = ProcWrapper(params=params)

          
          return wrapper.managed_call(callback, "duper")



  Top-level fetching can potentially fetch multiple dictionaries which are
  merged together in the final environment / configuration dictionary.
  The default merge strategy (`DEEP`) merges recursively, even dictionaries
  in lists. The `SHALLOW` merge strategy just overwrites top-level keys, with later
  secret locations taking precedence. However, if you install the
  [mergedeep](https://github.com/clarketm/mergedeep) library with the `mergedeep`
  extra, you can also set the merge strategy to one of:

  * `REPLACE`
  * `ADDITIVE`
  * `TYPESAFE_REPLACE`
  * `TYPESAFE_ADDITIVE`

  so that nested lists can be appended to instead of replaced (in the case of the
  `ADDITIVE` strategies), or errors will be raised if incompatibly-typed values
  are merged (in the case of the `TYPESAFE` strategies). In wrapped mode,
  the merge strategy can be set with the `--config-merge-strategy` command-line
  argument or `PROC_WRAPPER_CONFIG_MERGE_STRATEGY` environment variable. In
  embedded mode, the merge strategy can be set in the
  `config_merge_strategy` string property of `ProcWrapperParams`.



  Secret Resolution substitutes configuration or environment values that are
  secret location strings with the computed values of those strings. Compared
  to Secret Fetching, Secret Resolution is more useful when you want more
  control over the names of variables or when you have secret values deep
  inside your configuration.

  In wrapped mode, if you want to set the environment variable `MY_SECRET` with
  a value fetched
  from AWS Secrets Manager, you would set the environment variable
  `MY_SECRET_FOR_PROC_WRAPPER_TO_RESOLVE` to a secret location string
  which is ARN of the secret, for example:

      arn:aws:secretsmanager:us-east-2:1234567890:secret:db-PPrpY

  (The `_FOR_PROC_WRAPPER_TO_RESOLVE` suffix of environment variable names is
  removed during resolution. It can also be configured with the `PROC_WRAPPER_RESOLVABLE_ENV_VAR_NAME_SUFFIX` environment variable.)

  In embedded mode, if you want the final configuration dictionary to look like:

      {
        "db_username": "postgres",
        "db_password": "badpassword",
        ...
      }


  The initial configuration dictionary would look like:

      {
        "db_username__to_resolve": "arn:aws:secretsmanager:us-east-2:1234567890:secret:db-PPrpY|JP:$.username",
        "db_password__to_resolve": "arn:aws:secretsmanager:us-east-2:1234567890:secret:db-PPrpY|JP:$.password",

        ...
      }

  (The `__to_resolve` suffix (with 2 underscores!) of keys is removed during
  resolution. It can also be configured with the `resolved_config_property_name_suffix`
  property of `ProcWrapperParams`.)

  proc_wrapper can also resolve keys in embedded dictionaries, like:

      {
        "db": {
          "username__to_resolve": "arn:aws:secretsmanager:us-east-2:1234567890:secret:config-PPrpY|JP:$.username",
          "password__to_resolve":
          "arn:aws:secretsmanager:us-east-2:1234567890:secret:config-PPrpY|JP:$.password",
          ...
        },
        ...
      }

  up to a maximum depth that you can control with `ProcWrapperParams.max_config_resolution_depth` (which defaults to 5). That would resolve to

      {
        "db": {
          "username": "postgres",
          "password": "badpassword"
          ...
        },
        ...
      }

  You can also inject entire dictionaries, like:

      {
        "db__to_resolve": "arn:aws:secretsmanager:us-east-2:1234567890:secret:config-PPrpY",
        ...
      }

  which would resolve to

      {
        "db": {
          "username": "postgres",
          "password": "badpassword"
        },
        ...
      }

  To enable secret resolution in wrapped mode, set environment variable `PROC_WRAPPER_RESOLVE_SECRETS` to `TRUE`. In embedded mode, secret
  resolution is enabled by default; set the
  `max_config_resolution_iterations` property of `ProcWrapperParams` to `0`
  to disable resolution.

  Secret resolution is run multiple times so that if a resolved value contains
  a secret location string, it will be resolved on the next pass. By default,
  proc_wrapper limits the maximum number of resolution passes to 3 but you
  can control this with the environment variable
  `PROC_WRAPPER_MAX_CONFIG_RESOLUTION_ITERATIONS` in embedded mode,
  or by setting the `max_config_resolution_iterations` property of
  `ProcWrapperParams` in wrapped mode.



  During secret fetching and secret resolution, proc_wrapper internally maintains
  the computed environment as a dictionary which may have embedded lists and
  dictionaries. However, the final environment passed to the process is a flat
  dictionary containing only string values. So proc_wrapper converts
  all top-level values to strings using these rules:

  * Lists and dictionaries are converted to their JSON-encoded string value
  * Boolean values are converted to their upper-cased string representation
  (e.g. the string `FALSE` for the boolean value `false`)
  * The `None` value is converted to the empty string
  * All other values are converted using python's `str()` function



  You can set a Time to Live (TTL) on the duration that secret values are cached.
  Caching helps reduce expensive lookups of secrets and bandwidth usage.

  In wrapped mode, set the TTL of environment variables set from secret locations
  using the `--config-ttl` command-line argument or
  `PROC_WRAPPER_CONFIG_TTL_SECONDS` environment variable.
  If the process exits, you have configured the script to retry,
  and the TTL has expired since the last fetch,
  proc_wrapper will re-fetch the secrets
  and resolve them again, for the environment passed to the next invocation of
  your process.

  In embedded mode, set the TTL of configuration dictionary values set from
  secret locations by setting the `config_ttl` property of
  `ProcWrapperParams`. If 1) your callback function raises an exception, 2) you have
  configured the script to retry; and 3) the TTL has expired since the last fetch,
  proc_wrapper will re-fetch the secrets
  and resolve them again, for the configuration passed to the next invocation of
  the callback function.





  While your process in running, you can send status updates to
  CloudReactor by using the StatusUpdater class. Status updates are shown in
  the CloudReactor dashboard and allow you to track the current progress of a
  Task and also how many items are being processed in multiple executions
  over time.

  In wrapped mode, your application code would send updates to the
  proc_wrapper program via UDP port 2373 (configurable with the PROC_WRAPPER_STATUS_UPDATE_PORT environment variable).
  If your application code is in python, you can use the provided
  StatusUpdater class to do this:

      from proc_wrapper import StatusUpdater

      with StatusUpdater() as updater:
          updater.send_update(last_status_message="Starting ...")
          success_count = 0

          for i in range(100):
              try:
                  do_work()
                  success_count += 1
                  updater.send_update(success_count=success_count)
              except Exception:
                  failed_count += 1
                  updater.send_update(failed_count=failed_count)

          updater.send_update(last_status_message="Finished!")



  In embedded mode, your callback in python code can use the wrapper instance to
  send updates:

      from typing import Any, Mapping

      import proc_wrapper
      from proc_wrapper import ProcWrapper

      def fun(wrapper: ProcWrapper, cbdata: dict[str, int],
              config: Mapping[str, Any]) -> int:
          wrapper.update_status(last_status_message="Starting the fun ...")

          success_count = 0
          error_count = 0
          for i in range(100):
              try:
                  do_work()
                  success_count += 1
              except Exception:

                  error_count += 1
              wrapper.update_status(success_count=success_count,
                      error_count=error_count)

          wrapper.update_status(last_status_message="The fun is over.")

          return cbdata["a"]

      params = ProcWrapperParams()
      params.auto_create_task = True
      params.auto_create_task_run_environment_name = "production"
      params.task_name = "embedded_test"
      params.api_key = "YOUR_CLOUDREACTOR_API_KEY"

      proc_wrapper = ProcWrapper(params=params)
      proc_wrapper.managed_call(fun, {"a": 1, "b": 2})



  In case the wrapped process or embedded function will be execution very frequently,
  it may be advantageous to skip notifications to the API server in order to avoid the
  overhead (delay, bandwidth) of communication with the API server, or to reduce usage of
  API credits. For this purpose, you can configure proc_wrapper to communicate with the API
  server with a  certain probability using the `api-managed-probability` setting. If a
  generated random  number between 0 and 1 is above the probability threshold, the initial
  notification to create a Task Execution will be skipped. If the wrapped process or
  embedded function succeeds, no communication with the API server will be sent.

  However, if the wrapped process or embedded function fails, proc_wrapper will communicate
  with the API server with probability `api-failure-notification-probability`, creating
  a Task Exection at that point with a `FAILED` status. Similarly, if the wrapped process
  times out, proc_wrapper will communicate  with the API server with probability
  `api-timeout-notification-probability`, creating
  a Task Exection at that point with a `TERMINATED_AFTER_TIME_OUT` status.
  (Currently, timing out embedded functions is not supported.)



  These projects contain sample Tasks that use this library to report their
  execution status and results to CloudReactor

  * [cloudreactor-python-ecs-quickstart](https://github.com/CloudReactor/cloudreactor-python-ecs-quickstart)
  runs python code in a Docker container in AWS ECS Fargate (wrapped mode)
  * [cloudreactor-python-lambda-quickstart](https://github.com/CloudReactor/cloudreactor-python-lambda-quickstart)
  runs python code in AWS Lambda (embedded mode)
  * [cloudreactor-java-ecs-quickstart](https://github.com/CloudReactor/cloudreactor-java-ecs-quickstart)
  runs Java code in a Docker container in AWS ECS Fargate (wrapped mode)
  * [aws-otel-collector-cloudreactor](https://github.com/CloudReactor/aws-otel-collector-cloudreactor)
  enhances the AWS OTEL collector to report execution status to CloudReactor, and
  can be used as a sidecar container so that the main container doesn't need to
  run proc_wrapper.



  This software is dual-licensed under open source (MPL 2.0) and commercial
  licenses. See `LICENSE` for details.



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/jtsay362"><img src="https://avatars0.githubusercontent.com/u/1079646?s=460&v=4?s=80" width="80px;" alt=""/><br /><sub><b>Jeff Tsay</b></sub></a><br /><a href="https://github.com/CloudReactor/cloudreactor-procwrapper/commits?author=jtsay362" title="Code">💻</a> <a href="https://github.com/CloudReactor/cloudreactor-procwrapper/commits?author=jtsay362" title="Documentation">📖</a> <a href="#infra-jtsay362" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#maintenance-jtsay362" title="Maintenance">🚧</a></td>
      <td align="center"><a href="https://github.com/mwaldne"><img src="https://avatars0.githubusercontent.com/u/40419?s=460&u=3a5266861feeb27db392622371ecc57ebca09f32&v=4?s=80" width="80px;" alt=""/><br /><sub><b>Mike Waldner</b></sub></a><br /><a href="https://github.com/CloudReactor/cloudreactor-procwrapper/commits?author=mwaldne" title="Code">💻</a></td>
      <td align="center"><a href="https://browniebroke.com/"><img src="https://avatars.githubusercontent.com/u/861044?v=4?s=80" width="80px;" alt=""/><br /><sub><b>Bruno Alla</b></sub></a><br /><a href="https://github.com/CloudReactor/cloudreactor-procwrapper/commits?author=browniebroke" title="Code">💻</a> <a href="#ideas-browniebroke" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/CloudReactor/cloudreactor-procwrapper/commits?author=browniebroke" title="Documentation">📖</a></td>
    </tr>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!



  This package was created with
  [Cookiecutter](https://github.com/audreyr/cookiecutter) and the
  [browniebroke/cookiecutter-pypackage](https://github.com/browniebroke/cookiecutter-pypackage)
  project template.


pkgId: e4a83a8065753a3a80d467fa98f5b32b653f795e7132c0e09a2f8d3b8727c64d
name: python3-comfy-proxy
arch: noarch
version: 0.1.0
epoch: 0
release: 1
url: https://pypi.org/project/comfy-proxy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-comfy-proxy-0.1.0-1.src.rpm
location_href: Packages/python3-comfy-proxy-0.1.0-1.noarch.rpm
checksum_type: sha256
summary:
  A Python client library for interacting with ComfyUI servers and managing image generation workflows.

description:
  A Python client library for interacting with ComfyUI servers and managing image generation workflows.



  - Single and multi-instance ComfyUI server management
  - Async workflow execution
  - Flexible address configuration (single, multiple, port ranges)
  - Built-in workflow templates
  - Customizable image sizes and parameters
  - Websocket-based image generation and retrieval



  ComfyProxy requires Python 3.11 or later. Install using pip:

  ```bash
  pip install comfy-proxy
  ```



  ```python
  import asyncio
  from comfy_proxy.comfy import SingleComfy
  from comfy_proxy.workflows.flux import FluxModel, FluxWorkflowParams, FluxWorkflow
  from comfy_proxy.workflow import Sizes

  async def generate_image():
      
      comfy = Comfy("127.0.0.1:7821")

      
      model = FluxModel()
      params = FluxWorkflowParams(
          prompt="a beautiful sunset over mountains",
          model=model,
          size=Sizes.LANDSCAPE_16_9,
          seed=42,
          batch_size=1
      )

      
      workflow = FluxWorkflow(params)
      async for image_data in comfy.generate(workflow):
          with open("generated_image.png", "wb") as f:
              f.write(image_data)
          break  # Save first image only


  asyncio.run(generate_image())
  ```



  ComfyProxy can distribute work across multiple ComfyUI servers:

  ```python
  from comfy_proxy.comfy import Comfy


  comfy = Comfy("127.0.0.1:8188-8192")  # Port range

  comfy = Comfy(["127.0.0.1:8188", "127.0.0.1:8189"])  # List

  comfy = Comfy("127.0.0.1:8188,127.0.0.1:8189")  # Comma-separated
  ```



  Requirements:
  - Python 3.11+
  - Poetry for dependency management

  Setup:
  ```bash

  git clone https://github.com/yourusername/comfy-proxy.git
  cd comfy-proxy


  poetry install


  poetry run pytest
  ```



  ComfyProxy comes with some built-in workflows (like `FluxWorkflow`), but you can easily create your own:

  ```python
  from comfy_proxy.workflow import ComfyWorkflow, ComfyNode

  class MyCustomWorkflow(ComfyWorkflow):
      def __init__(self, params):
          super().__init__()
          self.params = params
          self._build_workflow()

      def _build_workflow(self):
          
          checkpoint_node = self.add_node(
              "CheckpointLoaderSimple",
              {"ckpt_name": "sd_xl_base_1.0.safetensors"}
          )
          
  ```

  We welcome contributions of basic workflows for popular models:
  - Stable Diffusion 1.5
  - SDXL
  - SD Turbo
  - SD 3.0
  - etc.

  For more complex use cases, you can implement the `ComfyWorkflow` class directly in your own codebase to create custom workflows with additional functionality.



  MIT License - see [LICENSE](LICENSE) file for details.


pkgId: feb92dc14b64cb7f8d75ea8360a2ad0ee680b2b8a2ae197214f8e1bb8713f6ed
name: python3-ctbl-tools
arch: noarch
version: 0.1.8
epoch: 0
release: 1
url: https://pypi.org/project/ctbl-tools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ctbl-tools-0.1.8-1.src.rpm
location_href: Packages/python3-ctbl-tools-0.1.8-1.noarch.rpm
checksum_type: sha256
summary:
  A set of helpers classes for daily tasks: a reusable config file, a process helper, and a git interface.

description:
  A package with miscelaneous classes meant to help at coding console helpers. Currently there are three classes:

  1. **config**: it implements a config file that saves itself. It is a specialization of [configparser](https://docs.python.org/3/library/configparser.html).
  2. **process**: it runs external processes, it saves the return code, and it helps (a little bit) to parse the standard output (or the standard error).
  3. **git**: a simple interface for git commands.



  It implements a config file that saves itself.

  The idea is: we want to use a config file for an application, which is a simple text file that contains pairs of values, in a similar fashion to an INI file. If the file exists, it is used; if it doesn't, it is created. We use [configparser](https://docs.python.org/3/library/configparser.html) for this.

  An example:

  ```python
  from ctbl_tools.config import config

  cfg = config(initpath = '~/somewhere/blabla.ini')
  cfg.create_section('my_configuration')
  cfg.set('my_configuration', 'x', 1)
  cfg.set('my_configuration', 'y', '2')
  ```

  When the program above ends, it will save all created configuration to the file ~/somewhere/blabla.ini.



  It runs an external program, and it stores the return code and both the standard output and standard error.

  You first create an object of this type:
  ```python
  p = process()
  ```

  Then run a command:
  ```python
  p.run("whoami")
  ```

  Immediately after you gain access to the return code, stdout and stderr:
  ```python
  print(p.returncode)
  for line in p.stdout:
    print(line)
  ```

  You may check if return code was 0 (i.e., all good) by checking `p.is_ok()` to be true. You may also check whether there is any stdout or any stderr with `p.is_there_stdout()` and with `p.is_there_stderr()`, respectively.

  Finally you may extract information out of stdout by using `extract()`. This method receives a regular expression and a boolean that is true by default (meaning that you want to inspect stdout; if false it will inspect stderr instead). The method will look for all matches in each line of stdout and store them in a list. The list stores as many elements as lines stdout has, and each element is a list of all matches within the corresponding line.



  It provides a simple programmatical interface to git.

  First, you create a git object by providing a local path to a repo:

  ```python
  from ctbl_tools.git import git

  x = git("~/Dev/my_repo")
  ```
  The previous will fail if provided path is not a git repo.

  Then you may either get the remote urls with `x.get_remote()`, or a get the status of the working tree by invoking `x.get_status()`.

  You may also do a commit with a list of files with `x.commit(list-of-files)`, or do a push (`x.git_push('my-commit-message')`) or a pull (`x.git_pull()`).

  This package also includes two auxiliary functions:

  * `git_clone(url:str, path:str)`: It clones `url` into `path`.
  * `is_git_url(url:str)`: It checks whether `url` is a valid git url.


pkgId: 750379228c9c584f6cf506c3dc27ba2063ce0ca0ab62f4443cbb10ba8ba58b92
name: python3-dataclass-wizard
arch: noarch
version: 0.33.0
epoch: 0
release: 1
url: https://github.com/rnag/dataclass-wizard
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dataclass-wizard-0.33.0-1.src.rpm
location_href: Packages/python3-dataclass-wizard-0.33.0-1.noarch.rpm
checksum_type: sha256
summary:
  Lightning-fast JSON wizardry for Python dataclasses — effortless serialization with no external tools required!


pkgId: 62510d72fa8e515675758b91d0c2194366b029b2affb78c505aab7691c6afef6
name: python3-descriptorlib
arch: noarch
version: 0.1.0
epoch: 0
release: 1
url: https://pypi.org/project/descriptorlib/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-descriptorlib-0.1.0-1.src.rpm
location_href: Packages/python3-descriptorlib-0.1.0-1.noarch.rpm
checksum_type: sha256
summary:
  Descriptorlib is a Python library that provides a series of powerful descriptors for enhancing the attribute functionality of Python classes.

description:
  [![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
  [![License](https://img.shields.io/badge/license-LGPL-green.svg)](LICENSE)
  [![Coverage Status](https://img.shields.io/coveralls/nostalgiatan/Descriptorlib/master.svg?style=flat-square)](https://coveralls.io/r/https://github.com/nostalgiatan/Descriptorlib)
  [![PyPI](https://img.shields.io/pypi/v/Descriptorlib.svg?style=flat-square)](https://pypi.org/project/Descriptorlib/)
  [![Documentation Status](https://readthedocs.org/projects/descriptorlib/badge/?version=latest&style=flat-square)](https://descriptorlib.readthedocs.io/en/latest/?badge=latest)
  `Descriptorlib` 是一个 Python 库，它提供了一系列强大的描述符，用于增强 Python 类的属性功能。通过使用描述符，你可以轻松实现属性的类型检查、只读、延迟初始化、版本控制、线程安全等特性。

  使用 pip 安装 `Descriptorlib`:
  ```bash
  pip install Descriptorlib
  ```

  `Descriptorlib` 提供了详细的文档，包括中文和英文版本。每个描述符都有其对应的文档，方便用户查找和使用。
  - [Chinese Documentation](/docs/Chinese/Descriptordocs)
  - [English Documentation](/docs/English/Descriptordocs)

  在 `Chinese` 和 `English` 目录下都有一个 `FAQ` 目录，收录了常见问题与解决方案。

  我们为每个描述符提供了单元测试，确保它们的可用性和正确性。测试代码位于 `tests` 目录。

  `examples` 目录提供了描述符的使用示例，帮助用户快速上手。

  - **monomer**: 所有描述符都储存在此目录下。
  - **libException**: 包含所有错误信息的目录。
  - **utils**:包含公用于所有描述符的工具目录。

  我们欢迎和鼓励社区成员为 `Descriptorlib` 做出贡献。请参考 [CONTRIBUTING.md](CONTRIBUTING.md) 了解如何贡献代码。

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


pkgId: 84b49ace9b20241c3205384d243fbdaed1d1dc8e833c1c8bb9481bfe2781fc55
name: python3-device-smi
arch: noarch
version: 0.3.3
epoch: 0
release: 1
url: https://github.com/ModelCloud/Device-SMI/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-device-smi-0.3.3-1.src.rpm
location_href: Packages/python3-device-smi-0.3.3-1.noarch.rpm
checksum_type: sha256
summary:
  Retrieve gpu, cpu, and npu device info and properties from Linux/MacOS with zero package dependency.

description:
  Self-contained Python lib with zero-dependencies that give you a unified `device` properties for `gpu`, `cpu`, and `npu`. No more calling separate tools such as `nvidia-smi` or `/proc/cpuinfo` and parsing it yourself.

  <p align="center">
      <a href="https://github.com/ModelCloud/Device-SMI/releases" style="text-decoration:none;"><img alt="GitHub release" src="https://img.shields.io/github/release/ModelCloud/Device-SMI.svg"></a>
      <a href="https://pypi.org/project/device-smi/" style="text-decoration:none;"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/device-smi"></a>
      <a href="https://pepy.tech/projects/device-smi" style="text-decoration:none;"><img src="https://static.pepy.tech/badge/device-smi" alt="PyPI Downloads"></a>
      <a href="https://github.com/ModelCloud/Device-SMI/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/device-smi" alt="License"></a>
      <a href="https://huggingface.co/modelcloud/"><img src="https://img.shields.io/badge/🤗%20Hugging%20Face-ModelCloud-%23ff8811.svg"></a>
  </p>


  * 12/20/2024 [0.3.3](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.3) Patch fix for Windows install compatibility.
  * 12/05/2024 [0.3.2](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.2) Added Windows `WSL` support.
  * 12/03/2024 [0.3.1](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.1) Added `CPUDevice` compat for Windows.
  * 12/02/2024 [0.3.0](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.3.0) Added `OSDevice`.[`name`, `version`, `kernel`, `arch`] for Linux/MacOS/Windows/FreeBSD/Solaris. Added `cpu.`[`count`, `cores`, `threads`] properties. Bug fix for gpu device index.
  * 11/29/2024 [0.2.1](https://github.com/ModelCloud/Device-SMI/releases/tag/v0.2.1) Added `pcie.`[`gen`, `speed`, `id`] + [`firmware`, `driver`] properties to `GPU` device.



  - Retrieve information for both CPU and GPU devices.
  - Includes details about memory usage, utilization, driver, pcie info when applicable, and other device specifications.
  - Zero pypi dependency.
  - Linux/MacOS support

  Supported Devices:

  - **OS**: Linux, MacOS, Windows, FreeBSD, Solaris
  - **CPU**: [Intel/AMD/Apple] Linux/MacOS system interface
  - **NVIDIA GPU**: NVIDIA System Management Interface `nvidia-smi`
  - **Intel XPU**: Intel/XPU System Management Interface `xpu-smi`
  - **Apple GPU**: MacOS interfaces



  For OS, use `os` to init a new Device object.

  ```py
  from device_smi import Device

  dev = Device("os")
  print(dev)
  ```

  Output: (Ubuntu 22.04)

  > {'type': 'os', 'name': 'ubuntu', 'version': '22.04', 'kernel': '6.12.1-x64v3-xanmod2', 'arch': 'x86_64'}

  For GPU/XPU, use [`gpu`, `cuda`] for Nvidia and `xpu` for Intel/XPU. Index usage for multiple GPUs: `cuda:0`

  ```py
  from device_smi import Device

  dev = Device("cuda:0")
  print(dev)
  ```

  Output: (Nvidia 4090)

  > {'pcie': {'gen': 2, 'speed': 1, 'id': '00000000:16:00.0'}, 'gpu': {'driver': '565.57.01', 'firmware': '95.02.3C.40.E7'}, 'type': 'gpu', 'model': 'geforce rtx 4090', 'memory_total': 25757220864, 'vendor': 'nvidia', 'features': ['8.9']}

  For CPU, use `cpu` to init a new Device object.

  ```py
  from device_smi import Device

  dev = Device("cpu")
  print(dev)
  ```

  Output: (AMD EPYC 7443)

  > {'type': 'cpu', 'model': 'epyc 7443', 'vendor': 'amd', 'memory_total': 1000000000000, 'count': 2, 'cores': 48, 'threads': 96, 'features': ['3dnowprefetch', 'abm', 'adx', 'aes', 'amd_ppin', 'aperfmperf', 'apic', 'arat', 'avx', 'avx2', 'bmi1', 'bmi2', 'bpext', 'brs', 'cat_l3', 'cdp_l3', 'clflush', 'clflushopt', 'clwb', 'clzero', 'cmov', 'cmp_legacy', 'constant_tsc', 'cpb', 'cpuid', 'cqm', 'cqm_llc', 'cqm_mbm_local', 'cqm_mbm_total', 'cqm_occup_llc', 'cr8_legacy', 'cx16', 'cx8', 'de', 'debug_swap', 'decodeassists', 'erms', 'extapic', 'extd_apicid', 'f16c', 'flushbyasid', 'fma', 'fpu', 'fsgsbase', 'fsrm', 'fxsr', 'fxsr_opt', 'ht', 'hw_pstate', 'ibpb', 'ibrs', 'ibs', 'invpcid', 'irperf', 'lahf_lm', 'lbrv', 'lm', 'mba', 'mca', 'mce', 'misalignsse', 'mmx', 'mmxext', 'monitor', 'movbe', 'msr', 'mtrr', 'mwaitx', 'nonstop_tsc', 'nopl', 'npt', 'nrip_save', 'nx', 'ospke', 'osvw', 'overflow_recov', 'pae', 'pat', 'pausefilter', 'pcid', 'pclmulqdq', 'pdpe1gb', 'perfctr_core', 'perfctr_llc', 'perfctr_nb', 'pfthreshold', 'pge', 'pku', 'pni', 'popcnt', 'pse', 'pse36', 'rapl', 'rdpid', 'rdpru', 'rdrand', 'rdseed', 'rdt_a', 'rdtscp', 'rep_good', 'sep', 'sha_ni', 'skinit', 'smap', 'smca', 'smep', 'ssbd', 'sse', 'sse2', 'sse4_1', 'sse4_2', 'sse4a', 'ssse3', 'stibp', 'succor', 'svm', 'svm_lock', 'syscall', 'tce', 'topoext', 'tsc', 'tsc_scale', 'umip', 'user_shstk', 'v_spec_ctrl', 'v_vmsave_vmload', 'vaes', 'vgif', 'vmcb_clean', 'vme', 'vmmcall', 'vpclmulqdq', 'wbnoinvd', 'wdt', 'xgetbv1', 'xsave', 'xsavec', 'xsaveerptr', 'xsaveopt', 'xsaves', 'xtopology']}




  - Support AMD GPU
  - Support Intel/Gaudi
  - Support Google/TPU
  - Add NPU support (ARM/Intel/AMD)


pkgId: e9bdb6dd5aae13b21429217115f1ddd7b99b8786e41fa96fb86ba85172ac912f
name: python3-dfhelper
arch: noarch
version: 0.0.5
epoch: 0
release: 1
url: https://github.com/kodurd/dfhelper
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dfhelper-0.0.5-1.src.rpm
location_href: Packages/python3-dfhelper-0.0.5-1.noarch.rpm
checksum_type: sha256
summary:
  dfhelper is a Python package that simplifies data preprocessing and visualization in Jupyter Notebooks.

description:
  Dfhelper is a versatile Python package that streamlines data preprocessing and visualization in Jupyter Notebooks.
  With intuitive functions for cleaning and transforming pandas DataFrames and the ability to render them as interactive
  HTML tables, this toolkit is an essential addition to any data scientist's arsenal. Simplify your data analysis process
  and gain clearer insights with dfhelper.


  ```
  !pip install dfhelper
  ```


  1) Output date frames in HTML. This is extremely useful when working with multiple selections
  2) Output in HTML df.info() multiple dataframes
  3) Output the size of the date frames in html.
  4) The ability to display dataframes vertically and horizontally
  5) Functions for summarizing the date of Ephraim, created for conducting EDA


  ```python
  import pandas as pd
  from dfhelper.viz import df_view, df_info_view, df_shape_view
  from dfhelper.scout import summarize_df, summarize_dfs



  df1 = pd.DataFrame(
              {"A": [1, 0, 0, None],
               "B": [1, 1, 2, 2],
               "C": [None, None, None, None]}
          )

  df2 = pd.DataFrame(
              {"A": [1, 5, 0, 10],
               "B": [1, 1, 2, 2],
               "C": [None, 4, 16, 101]}
          )


  df_view(df1, df2)

  df_info_view(df1, df2)

  df_shape_view(df1, df2)



  summarize_df(df1)

  summarize_dfs(df1, df2)
  ```


pkgId: cae208d77809d1108ce0193060e4dce3bb9c859db8e7fdde0a0b4e25c60fb73d
name: python3-django-modelcluster
arch: noarch
version: 6.4
epoch: 0
release: 1
url: https://github.com/wagtail/django-modelcluster
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-modelcluster-6.4-1.src.rpm
location_href: Packages/python3-django-modelcluster-6.4-1.noarch.rpm
checksum_type: sha256
summary:
  Django extension to allow working with 'clusters' of models as a single unit, independently of the database

description:
  If you had a data model like this:
   class Band(models.Model):
       name = models.CharField(max_length=255)
   class BandMember(models.Model):
       band = models.ForeignKey('Band', related_name='members', on_delete=models.CASCADE)
       name = models.CharField(max_length=255)
  wouldn't it be nice if you could construct bundles of objects like this, independently of the database:
   beatles = Band(name='The Beatles')
   beatles.members = [
       BandMember(name='John Lennon'),
       BandMember(name='Paul McCartney'),
   ]
  Unfortunately, you can't. Objects need to exist in the database for foreign key relations to work:
   IntegrityError: null value in column "band_id" violates not-null constraint
  But what if you could? There are all sorts of scenarios where you might want to work with a 'cluster' of related objects, without necessarily holding them in the database: maybe you want to render a preview of the data the user has just submitted, prior to saving. Maybe you need to construct a tree of things, serialize them and hand them off to some external system. Maybe you have a workflow where your models exist in an incomplete 'draft' state for an extended time, or you need to handle multiple revisions, and you don't want to redesign your database around that requirement.
  **django-modelcluster** extends Django's foreign key relations to make this possible. It introduces a new type of relation, *ParentalKey*, where the related models are stored locally to the 'parent' model until the parent is explicitly saved. Up to that point, the related models can still be accessed through a subset of the QuerySet API:
   from modelcluster.models import ClusterableModel
   from modelcluster.fields import ParentalKey
   class Band(ClusterableModel):
       name = models.CharField(max_length=255)
   class BandMember(models.Model):
       band = ParentalKey('Band', related_name='members', on_delete=models.CASCADE)
       name = models.CharField(max_length=255)
   >>> beatles = Band(name='The Beatles')
   >>> beatles.members = [
   >>> [member.name for member in beatles.members.all()]
   ['John Lennon', 'Paul McCartney']
   >>> beatles.members.add(BandMember(name='George Harrison'))
   >>> beatles.members.count()
   3
   >>> beatles.save()  # only now are the records written to the database
  For more examples, see the unit tests.


pkgId: 502b0cba14de84327943c1f5d2ceb281be9d904987692230f3f2261e9108b3f6
name: python3-django-pgtransaction
arch: noarch
version: 1.5.1
epoch: 0
release: 1
url: https://github.com/AmbitionEng/django-pgtransaction
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-pgtransaction-1.5.1-1.src.rpm
location_href: Packages/python3-django-pgtransaction-1.5.1-1.noarch.rpm
checksum_type: sha256
summary:
  A context manager/decorator which extends Django's atomic function with the ability to set isolation level and retries for a given transaction.

description:
  `django-pgtransaction` offers a drop-in replacement for the default `django.db.transaction` module which, when used on top of a PostgreSQL database, extends the functionality of that module with Postgres-specific features.

  At present, django-pgtransaction offers an extension of the `django.db.transaction.atomic` context manager/decorator which allows one to dynamically set the [isolation level](https://www.postgresql.org/docs/current/transaction-iso.html) when opening a transaction, as well as specifying a retry policy for when an operation in that transaction results in a Postgres locking exception. See the quickstart below or [the docs](https://django-pgtransaction.readthedocs.io/) for examples.



  Set the isolation level of a transaction by using `pgtransaction.atomic`:

  ```python
  import pgtransaction

  with pgtransaction.atomic(isolation_level=pgtransaction.SERIALIZABLE):
      
  ```

  There are three isolation levels: `pgtransaction.READ_COMMITTED`, `pgtransaction.REPEATABLE_READ`, and `pgtransaction.SERIALIZABLE`. By default it inherits the parent isolation level, which is Django's default of "READ COMMITTED".

  When using stricter isolation levels like `pgtransaction.SERIALIZABLE`, Postgres will throw serialization errors upon concurrent updates to rows. Use the `retry` argument with the decorator to retry these failures:

  ```python
  @pgtransaction.atomic(isolation_level=pgtransaction.SERIALIZABLE, retry=3)
  def do_queries():
      
  ```

  Note that the `retry` argument will not work when used as a context manager. A `RuntimeError` will be thrown.

  By default, retries are only performed when `psycopg.errors.SerializationError` or `psycopg.errors.DeadlockDetected` errors are raised. Configure retried psycopg errors with `settings.PGTRANSACTION_RETRY_EXCEPTIONS`. You can set a default retry amount with `settings.PGTRANSACTION_RETRY`.

  `pgtransaction.atomic` can be nested, but keep the following in mind:

  1. The isolation level cannot be changed once a query has been performed.
  2. The retry argument only works on the outermost invocation as a decorator, otherwise `RuntimeError` is raised.



  `django-pgtransaction` is compatible with Python 3.9 - 3.13, Django 4.2 - 5.1, Psycopg 2 - 3, and Postgres 13 - 17.



  Check out the [Postgres docs](https://www.postgresql.org/docs/current/transaction-iso.html) to learn about transaction isolation in Postgres.

  [View the django-pgtransaction docs here](https://django-pgtransaction.readthedocs.io/)



  Install `django-pgtransaction` with:

      pip3 install django-pgtransaction
  After this, add `pgtransaction` to the `INSTALLED_APPS` setting of your Django project.



  For information on setting up django-pgtransaction for development and contributing changes, view [CONTRIBUTING.md](CONTRIBUTING.md).



  - [Paul Gilmartin](https://github.com/PaulGilmartin)
  - [Wes Kendall](https://github.com/wesleykendall)


pkgId: e81c6c4f9514b3475b9f541a0f30398df84be3a29ad531da65523a9f2801316d
name: python3-django-query-to-table
arch: noarch
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/birddevelper/django-query-to-table
rpm_license: GNU
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-django-query-to-table-1.0.0-1.src.rpm
location_href: Packages/python3-django-query-to-table-1.0.0-1.noarch.rpm
checksum_type: sha256
summary:
  A simple to use Django package to turn your queryset and sql query into a beautiful reporting html table

description:
  [![Downloads](https://static.pepy.tech/personalized-badge/django-query-to-table?period=total&units=international_system&left_color=black&right_color=green&left_text=Downloads)](https://pepy.tech/project/django-query-to-table)



  You can read more about this package here : [django query to table package](https://mshaeri.com/blog/generate-html-table-report-from-sql-query-in-django/)

  The package contains two functions named:
  - **generate_from_sql**: Generate HTML table by given SQL query
  - **generate_from_queryset**:Generate HTML table by given Django queryset

  Parameters:

  * title : The title of the report that will be shown on top of table
  * sqltext/queryset : The sql select query to retrieve data / django queryset
  * footerCols : A list of columns name that you want to have Sum of values on footer . Example : ['amount','price']
  * htmlClass : Html CSS classes for the table
  * direction (default = "ltr") : Indicates direction of the report page.  "ltr"- Left to Right , "rtl" -  Right to Left
  * font (default = "Tahoma") : Font of title and table contents
  * totalText (default = "Total") : Title of footer row that will be the put below the first column.
  * rowIndex (default = False) : Indicates whether the table should have index column or not.
  * headerRowColor (default = '#eeeeee') :  The header (title) row background color.
  * evenRowColor (default = '#ffffff') :  The even rows background color.
  * oddRowColor (default = '#ffffff') :  The odd rows background color.




  Run following command to install DjangoQtt :

  ```shell
  pip install django-query-to-table
  ```



  - Generate HTML table by SQL query:

  ```python
  from django_query_to_table import DjangoQtt
  from django.http import HttpResponse


  def listOfPersons(request):
    reportTitle = "Employee List"
    sqlQuery = "SELECT FirstName as 'First Name', LastName as 'Last Name', phone as 'Phone Number', salary as 'Salary' FROM persons"
    columnsToBeSummarized = ['Salary']
    fontName = "Arial"
    cssClasses = "reportTable container"
    headerRowBackgroundColor = '#ffeeee'
    evenRowsBackgroundColor = '#ffeeff'
    oddRowsBackgroundColor = '#ffffff'
    rowIndexVisibility = True
    table = DjangoQtt.generate_from_sql(reportTitle, sqlQuery, columnsToBeSummarized, cssClasses,
                                    "ltr", fontName, "Total Salary", rowIndexVisibility,
                                    headerRowBackgroundColor, evenRowsBackgroundColor, oddRowsBackgroundColor
                                    )

    
    return HttpResponse(table)

   ```

  - Generate HTML table from querset:

  ```python
  from django_query_to_table import DjangoQtt
  from django.http import HttpResponse
  from .models import Order

  def listOfPersons(request):

    order_queryset = Order.objects.all().values("customer", "product", "amount")
    reportTitle = "Order List"
    columnsToBeSummarized = ['amount']
    fontName = "Arial"
    cssClasses = "reportTable container"
    headerRowBackgroundColor = '#ffeeee'
    evenRowsBackgroundColor = '#ffeeff'
    oddRowsBackgroundColor = '#ffffff'
    rowIndexVisibility = True
    table = DjangoQtt.generate_from_queryset(reportTitle, order_queryset, columnsToBeSummarized, cssClasses,
                                    "ltr", fontName, "Total amount", rowIndexVisibility,
                                    headerRowBackgroundColor, evenRowsBackgroundColor, oddRowsBackgroundColor
                                    )

    
    return HttpResponse(table)

   ```


pkgId: 47f1c5d4c221bde5623b388cb776f8ca7004b8e3ec66da7cc46ec4b44239e9c6
name: python3-dpr
arch: noarch
version: 0.2.2
epoch: 0
release: 1
url: https://github.com/samuelstjean/dpr
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-dpr-0.2.2-1.src.rpm
location_href: Packages/python3-dpr-0.2.2-1.noarch.rpm
checksum_type: sha256
summary:
  Implementation of "Reducing variability in along-tract analysis with diffusion profile realignment".

description:
  An example and assorted implementation from the manuscript **Reducing variability in along-tract analysis with diffusion profile realignment**.
  Have a look at the [example](example.ipynb) on how to use the package and run it on a small example dataset.

  To install the package, just run
  ~~~
  pip install dpr
  ~~~

  The documentation is available at https://dpr.readthedocs.io.



  There is also a shiny new version written in matlab, with an assorted example, available in the [matlab](matlab) folder.
  Feel free to check out and edit the functions as needed for your own usage.



  There is also a command line version for easy usage, here in an example for the AFD metric on the left arcuate fasciculus.
  The text file is already ordered in increasing order for each subject, which have the same distance between every point and are already zero padded accordingly.

  We also supply the **--exploredti** option to remove the header column, **--do_graph** to save a png file with the results.

  We finally resample everything to 75 points with **--points 75**.

  The **-f** option overwrites the output files and the **-v** option prints useful informative messages throughout (and are optional).

  ~~~bash
  dpr datasets/af_left_AFD.txt datasets/af_left_AFD_realigned.txt --exploredti --do_graph -f -v --points 75
  ~~~

  The output ```datasets/af_left_AFD_realigned.txt``` is a text file where each line is a subject and each column is a different point of the along tract analysis.

  We also get a png file ```datasets/af_left_AFD_realigned.png``` with the before/after realignment process.

  ![](datasets/af_left_AFD_realigned.png)

  Note how the zero padding present in the original data is decreasing the metrics as less and less subjects are present.
  The realigned metric is instead using padding with Nans, remember to consider/keep track of it in subsequent analysis as needed.



  We can also draw the p-values (computed separately) over the bundle using the script ```dpr_make_fancy_graph```.
  This requires the original coordinates, the truncated version between rois and the coordinates to the representative streamline.

  ~~~bash
  dpr_make_fancy_graph datasets/af_left_pval_unaligned.txt datasets/af_left_coordinates.txt datasets/af_left_truncated_coordinates.txt datasets/af_left_average_coordinates.txt 0,2 pvals_unaligned.png --title 'p-values before realignment' -f
  dpr_make_fancy_graph datasets/af_left_pval_realigned.txt datasets/af_left_coordinates.txt datasets/af_left_truncated_coordinates.txt datasets/af_left_average_coordinates.txt 0,2 pvals_realigned.png -f
  ~~~

  And this is the results

  ![](datasets/pvals_unaligned.png)
  ![](datasets/pvals_realigned.png)



  The main reference is

  ~~~
  Samuel St-Jean, Maxime Chamberland, Max A. Viergever, Alexander Leemans,
  Reducing variability in along-tract analysis with diffusion profile realignment,
  NeuroImage, 2019. ISSN 1053-811
  ~~~

  The data is also available at https://zenodo.org/record/2483169.

  The open access manuscript is also available at https://www.sciencedirect.com/science/article/pii/S1053811919305014.

  To refer to a specific version of the code, everything is also archived over at https://zenodo.org/record/3248894.


pkgId: aac12f5aacb93aaf85ed71c129e2d119649db304c08ced0453cd66666565f551
name: python3-exceptionx
arch: noarch
version: 4.1.8
epoch: 0
release: 1
url: http://gqylpy.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-exceptionx-4.1.8-1.src.rpm
location_href: Packages/python3-exceptionx-4.1.8-1.noarch.rpm
checksum_type: sha256
summary:
  The `exceptionx` is a flexible and convenient Python exception handling library that allows you to dynamically create exception classes and provides various exception handling mechanisms.

description:
  [<img alt="LOGO" src="https://python.org/favicon.ico" height="21" width="21"/>](http://gqylpy.com)
  [![Release](https://img.shields.io/github/release/gqylpy/exceptionx.svg?style=flat-square")](https://github.com/gqylpy/exceptionx/releases/latest)
  [![Python Versions](https://img.shields.io/pypi/pyversions/exceptionx)](https://pypi.org/project/exceptionx)
  [![License](https://img.shields.io/pypi/l/exceptionx)](https://github.com/gqylpy/exceptionx/blob/main/LICENSE)
  [![Downloads](https://static.pepy.tech/badge/exceptionx)](https://pepy.tech/project/exceptionx)


  English | [中文](https://github.com/gqylpy/exceptionx/blob/main/README_CN.md)

  __exceptionx__ is a flexible and convenient Python exception handling library that allows you to dynamically create exception classes and provides various exception handling mechanisms.
  > The predecessor of exceptionx is [gqylpy-exception](https://github.com/gqylpy/gqylpy-exception).

  <kbd>pip3 install exceptionx</kbd>



  With exceptionx, you can instantly create exception classes when needed, without the need for advance definition. For example, if you want to throw an exception named `NotUnderstandError`, you can simply import the library and call it as follows:

  ```python
  import exceptionx as ex

  raise ex.NotUnderstandError(...)
  ```

  Here, `NotUnderstandError` is not predefined by exceptionx but is dynamically created through the magic method `__getattr__` when you try to access `e.NotUnderstandError`. This flexibility means you can create exception classes with any name as needed.

  Additionally, exceptionx ensures that the same exception class is not created repeatedly. All created exception classes are stored in the `e.__history__` dictionary for quick access later.

  There is another usage, import and create immediately:

  ```python
  from exceptionx import NotUnderstandError

  raise NotUnderstandError(...)
  ```



  exceptionx also provides a series of powerful exception handling tools:

  - `TryExcept`: A decorator that catches exceptions raised in the decorated function and outputs the exception information to the terminal (instead of throwing it). This helps prevent the program from crashing due to unhandled exceptions.
  - `Retry`: A decorator that works similarly to `TryExcept` but attempts to re-execute the function, controlling the number of attempts and the interval between each retry through parameters. It throws an exception after reaching the maximum number of attempts.
  - `TryContext`: A context manager that allows you to easily catch exceptions raised in a code block using the `with` statement and output the exception information to the terminal.

  **Handling Exceptions in Functions with `TryExcept`**

  ```python
  from exceptionx import TryExcept

  @TryExcept(ValueError)
  def func():
      int('a')
  ```

  The default handling scheme is to output brief exception information to the terminal without interrupting program execution. Of course, it can also be output to logs or processed in other ways through parameters.

  > According to Python programming conventions, exception types should be explicitly specified when handling exceptions. Therefore, when using the `TryExcept` decorator, it is necessary to explicitly pass the handled exception types.

  **Retrying Exceptions in Functions with `Retry`**

  ```python
  from exceptionx import Retry

  @Retry(sleep=1, count=3)
  def func():
      int('a')
  ```

  If an exception is raised in the decorated function, it will attempt to re-execute the decorated function. The default behavior is to retry exceptions of type `Exception` and all its subclasses. Calling `Retry(sleep=1, count=3)` as above means a maximum of 3 attempts will be made, with a 1-second interval between each attempt.

  `Retry` can be used in combination with `TryExcept` to retry exceptions first and then handle them if the retries are unsuccessful:

  ```python
  from exceptionx import TryExcept, Retry

  @TryExcept(ValueError)
  @Retry(sleep=1, count=3)
  def func():
      int('a')
  ```

  **Handling Exceptions in Contexts with `TryContext`**

  ```python
  from exceptionx import TryContext

  with TryContext(ValueError):
      int('a')
  ```

  With exceptionx, you can handle exceptions in Python programs more flexibly and efficiently, enhancing the robustness and reliability of your code.


pkgId: 14489346c537887d8d269780420dea89aaab8f81f0782a120daef01557f1595d
name: python3-executorlib
arch: noarch
version: 0.0.6
epoch: 0
release: 1
url: https://github.com/pyiron/executorlib
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-executorlib-0.0.6-1.src.rpm
location_href: Packages/python3-executorlib-0.0.6-1.noarch.rpm
checksum_type: sha256
summary:
  Scale serial and MPI-parallel python functions over hundreds of compute nodes all from within a jupyter notebook or serial python process.

description:
  [![Unittests](https://github.com/pyiron/executorlib/actions/workflows/unittest-openmpi.yml/badge.svg)](https://github.com/pyiron/executorlib/actions/workflows/unittest-openmpi.yml)
  [![Coverage Status](https://coveralls.io/repos/github/pyiron/executorlib/badge.svg?branch=main)](https://coveralls.io/github/pyiron/executorlib?branch=main)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/pyiron/executorlib/HEAD?labpath=notebooks%2Fexamples.ipynb)

  Up-scale python functions for high performance computing (HPC) with executorlib.


  * **Up-scale your Python functions beyond a single computer.** - executorlib extends the [Executor interface](https://docs.python.org/3/library/concurrent.futures.html#executor-objects)
    from the Python standard library and combines it with job schedulers for high performance computing (HPC) including
    the [Simple Linux Utility for Resource Management (SLURM)](https://slurm.schedmd.com) and [flux](http://flux-framework.org).
    With this combination executorlib allows users to distribute their Python functions over multiple compute nodes.
  * **Parallelize your Python program one function at a time** - executorlib allows users to assign dedicated computing
    resources like CPU cores, threads or GPUs to one Python function call at a time. So you can accelerate your Python
    code function by function.
  * **Permanent caching of intermediate results to accelerate rapid prototyping** - To accelerate the development of
    machine learning pipelines and simulation workflows executorlib provides optional caching of intermediate results for
    iterative development in interactive environments like jupyter notebooks.


  The Python standard library provides the [Executor interface](https://docs.python.org/3/library/concurrent.futures.html#executor-objects)
  with the [ProcessPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#processpoolexecutor) and the
  [ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#threadpoolexecutor) for parallel
  execution of Python functions on a single computer. executorlib extends this functionality to distribute Python
  functions over multiple computers within a high performance computing (HPC) cluster. This can be either achieved by
  submitting each function as individual job to the HPC job scheduler - [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html) -
  or by requesting a compute allocation of multiple nodes and then distribute the Python functions within this - allocation -
  [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html). Finally, to accelerate the
  development process executorlib also provides a - [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html) -
  to use the executorlib functionality on a single workstation for testing. Starting with the [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html)
  set by setting the backend parameter to local - `backend="local"`:
  ```python
  from executorlib import Executor


  with Executor(backend="local") as exe:
      future_lst = [exe.submit(sum, [i, i]) for i in range(1, 5)]
      print([f.result() for f in future_lst])
  ```
  In the same way executorlib can also execute Python functions which use additional computing resources, like multiple
  CPU cores, CPU threads or GPUs. For example if the Python function internally uses the Message Passing Interface (MPI)
  via the [mpi4py](https://mpi4py.readthedocs.io) Python libary:
  ```python
  from executorlib import Executor


  def calc(i):
      from mpi4py import MPI

      size = MPI.COMM_WORLD.Get_size()
      rank = MPI.COMM_WORLD.Get_rank()
      return i, size, rank


  with Executor(backend="local") as exe:
      fs = exe.submit(calc, 3, resource_dict={"cores": 2})
      print(fs.result())
  ```
  The additional `resource_dict` parameter defines the computing resources allocated to the execution of the submitted
  Python function. In addition to the compute cores `cores`, the resource dictionary can also define the threads per core
  as `threads_per_core`, the GPUs per core as `gpus_per_core`, the working directory with `cwd`, the option to use the
  OpenMPI oversubscribe feature with `openmpi_oversubscribe` and finally for the [Simple Linux Utility for Resource
  Management (SLURM)](https://slurm.schedmd.com) queuing system the option to provide additional command line arguments
  with the `slurm_cmd_args` parameter - [resource dictionary](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#resource-dictionary)
  This flexibility to assign computing resources on a per-function-call basis simplifies the up-scaling of Python programs.
  Only the part of the Python functions which benefit from parallel execution are implemented as MPI parallel Python
  funtions, while the rest of the program remains serial.

  The same function can be submitted to the [SLURM](https://slurm.schedmd.com) queuing by just changing the `backend`
  parameter to `slurm_submission`. The rest of the example remains the same, which highlights how executorlib accelerates
  the rapid prototyping and up-scaling of HPC Python programs.
  ```python
  from executorlib import Executor


  def calc(i):
      from mpi4py import MPI

      size = MPI.COMM_WORLD.Get_size()
      rank = MPI.COMM_WORLD.Get_rank()
      return i, size, rank


  with Executor(backend="slurm_submission") as exe:
      fs = exe.submit(calc, 3, resource_dict={"cores": 2})
      print(fs.result())
  ```
  In this case the [Python simple queuing system adapter (pysqa)](https://pysqa.readthedocs.io) is used to submit the
  `calc()` function to the [SLURM](https://slurm.schedmd.com) job scheduler and request an allocation with two CPU cores
  for the execution of the function - [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html). In the background the [sbatch](https://slurm.schedmd.com/sbatch.html)
  command is used to request the allocation to execute the Python function.

  Within a given [SLURM](https://slurm.schedmd.com) allocation executorlib can also be used to assign a subset of the
  available computing resources to execute a given Python function. In terms of the [SLURM](https://slurm.schedmd.com)
  commands, this functionality internally uses the [srun](https://slurm.schedmd.com/srun.html) command to receive a subset
  of the resources of a given queuing system allocation.
  ```python
  from executorlib import Executor


  def calc(i):
      from mpi4py import MPI

      size = MPI.COMM_WORLD.Get_size()
      rank = MPI.COMM_WORLD.Get_rank()
      return i, size, rank


  with Executor(backend="slurm_allocation") as exe:
      fs = exe.submit(calc, 3, resource_dict={"cores": 2})
      print(fs.result())
  ```
  In addition, to support for [SLURM](https://slurm.schedmd.com) executorlib also provides support for the hierarchical
  [flux](http://flux-framework.org) job scheduler. The [flux](http://flux-framework.org) job scheduler is developed at
  [Larwence Livermore National Laboratory](https://computing.llnl.gov/projects/flux-building-framework-resource-management)
  to address the needs for the up-coming generation of Exascale computers. Still even on traditional HPC clusters the
  hierarchical approach of the [flux](http://flux-framework.org) is beneficial to distribute hundreds of tasks within a
  given allocation. Even when [SLURM](https://slurm.schedmd.com) is used as primary job scheduler of your HPC, it is
  recommended to use [SLURM with flux](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#slurm-with-flux)
  as hierarchical job scheduler within the allocations.


  * [Installation](https://executorlib.readthedocs.io/en/latest/installation.html)
    * [Minimal](https://executorlib.readthedocs.io/en/latest/installation.html#minimal)
    * [MPI Support](https://executorlib.readthedocs.io/en/latest/installation.html#mpi-support)
    * [Caching](https://executorlib.readthedocs.io/en/latest/installation.html#caching)
    * [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-submission-mode)
    * [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/installation.html#hpc-allocation-mode)
    * [Visualisation](https://executorlib.readthedocs.io/en/latest/installation.html#visualisation)
    * [For Developers](https://executorlib.readthedocs.io/en/latest/installation.html#for-developers)
  * [Local Mode](https://executorlib.readthedocs.io/en/latest/1-local.html)
    * [Basic Functionality](https://executorlib.readthedocs.io/en/latest/1-local.html#basic-functionality)
    * [Parallel Functions](https://executorlib.readthedocs.io/en/latest/1-local.html#parallel-functions)
    * [Performance Optimization](https://executorlib.readthedocs.io/en/latest/1-local.html#performance-optimization)
  * [HPC Submission Mode](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html)
    * [SLURM](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html#slurm)
    * [Flux](https://executorlib.readthedocs.io/en/latest/2-hpc-submission.html#flux)
  * [HPC Allocation Mode](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html)
    * [SLURM](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#slurm)
    * [SLURM with Flux](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#slurm-with-flux)
    * [Flux](https://executorlib.readthedocs.io/en/latest/3-hpc-allocation.html#flux)
  * [Trouble Shooting](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html)
    * [Filesystem Usage](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#filesystem-usage)
    * [Firewall Issues](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#firewall-issues)
    * [Message Passing Interface](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#message-passing-interface)
    * [Python Version](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#python-version)
    * [Resource Dictionary](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#resource-dictionary)
    * [SSH Connection](https://executorlib.readthedocs.io/en/latest/trouble_shooting.html#ssh-connection)
  * [Developer](https://executorlib.readthedocs.io/en/latest/4-developer.html)
    * [Communication](https://executorlib.readthedocs.io/en/latest/4-developer.html#communication)
    * [External Executables](https://executorlib.readthedocs.io/en/latest/4-developer.html#external-executables)
    * [License](https://executorlib.readthedocs.io/en/latest/4-developer.html#license)
    * [Modules](https://executorlib.readthedocs.io/en/latest/4-developer.html#modules)
  * [Interface](https://executorlib.readthedocs.io/en/latest/api.html)

rpm_license:
  BSD 3-Clause License  Copyright (c) 2022, Jan Janssen All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * 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.  * 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 HOLDER 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: a5899d1ae8af944dbd44b391a5665224b7d02048a23d17f10a459ac6345c40ca
name: python3-gebpy
arch: noarch
version: 1.0.2
epoch: 0
release: 1
url: https://github.com/MABeeskow/GebPy
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gebpy-1.0.2-1.src.rpm
location_href: Packages/python3-gebpy-1.0.2-1.noarch.rpm
checksum_type: sha256
summary:
  GebPy is a Python-based, open source tool for the generation of geological data of minerals, rocks and complete lithological sequences. The data can be generated randomly or with respect to user-defined constraints, for example a specific element concentration within minerals and rocks or the order of units within a complete lithological profile.

description:
  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL%20v3-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)

  <a href="https://github.com/MABeeskow/GebPy">
    <img src="https://raw.githubusercontent.com/MABeeskow/GebPy/master/documents/readme_images/readme_header.png" width="67%">
  </a>

  developed by Maximilian Alexander Beeskow

  GebPy is an open-source, Python-based tool for the synthetic generation of geological data with focus on minerals, rocks and stratigraphy. The main assumption of GepPy is that all rock properties are determined by the mineral assemblage besides structural features. GebPy can be used for educational purposes, for example by the generation of mineralogical data that could be then further investigated in specific diagrams or in well log analysis courses after creating different stratigraphic sequences.\
  GebPy is a one-man project and can still contain some technical bugs or some wrong assumptions, but it is driven by a huge motivation and has the goal to improve the knowledge and understanding of different geological aspects that are (actually) focused on mineralogy, rocks and stratigraphy.



  Actually, GebPy can only be installed by cloning this repository. An alternative solution will be found in the future.



  Coming soon ...



  Coming soon ...



  Coming soon ...



  Coming soon ...



  Coming soon ...



  Coming soon ...


pkgId: 40f94a22a5409a0aca0638bbf3ea7ae2a4a29324c09ee6600bd454f4bac5e348
name: python3-geouned
arch: noarch
version: 1.5.1
epoch: 0
release: 1
url: https://github.com/GEOUNED-org
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-geouned-1.5.1-1.src.rpm
location_href: Packages/python3-geouned-1.5.1-1.noarch.rpm
checksum_type: sha256
summary:
  Conversion tool from CAD to CGS/CGS to CAD for Monte Carlo particle transport codes (OpenMC, Phits, Serpent, MCNP)

description:
  [![CI testing](https://github.com/GEOUNED-org/GEOUNED/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/GEOUNED-org/GEOUNED/actions/workflows/ci.yml)
  [![Upload Python Package](https://github.com/GEOUNED-org/GEOUNED/actions/workflows/python-publish.yml/badge.svg)](https://github.com/GEOUNED-org/GEOUNED/actions/workflows/python-publish.yml)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/psf/black)
  [![documentation release](https://github.com/GEOUNED-org/GEOUNED/actions/workflows/documentation_release.yml/badge.svg)](https://github.com/GEOUNED-org/GEOUNED/actions/workflows/documentation_release.yml)
  [![PyPI](https://img.shields.io/pypi/v/geouned?&label=PyPI)](https://pypi.org/project/geouned/)

  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/geouned/badges/version.svg)](https://anaconda.org/conda-forge/geouned)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/geouned/badges/platforms.svg)](https://anaconda.org/conda-forge/geouned)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/geouned/badges/downloads.svg)](https://anaconda.org/conda-forge/geouned)



  A tool to convert from CAD to CSG & CSG to CAD for Monte Carlo transport codes (MCNP & OpenMC).
  This repository contains the implementation of the algorithm presented in the paper [GEOUNED: A new conversion tool from CAD to Monte Carlo geometry](https://doi.org/10.1016/j.net.2024.01.052).

  See the [online documentation](https://geouned-org.github.io/GEOUNED/index.html) for installation, usage and API reference.



  ```
  @article{CATALAN2024,
    author = {J.P. Catalán and P. Sauvan and J. García and J. Alguacil and F. Ogando and J. Sanz},
    title = {GEOUNED: A new conversion tool from CAD to Monte Carlo geometry},
    journal = {Nuclear Engineering and Technology},
    year = {2024},
    issn = {1738-5733},
    doi = {https://doi.org/10.1016/j.net.2024.01.052}
  }
  ```

rpm_license:
  EUROPEAN UNION PUBLIC LICENCE v. 1.2 EUPL © the European Union 2007, 2016  This European Union Public Licence (the ‘EUPL’) applies to the Work (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).  The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Work:  Licensed under the EUPL  or has expressed by any other means his willingness to license under the EUPL.  1. Definitions  In this Licence, the following terms have the following meaning:  - ‘The Licence’: this Licence.  - ‘The Original Work’: the work or software distributed or communicated by the Licensor under this Licence, available as Source Code and also as Executable Code as the case may be.  - ‘Derivative Works’: the works or software that could be created by the Licensee, based upon the Original Work or modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in the country mentioned in Article 15.  - ‘The Work’: the Original Work or its Derivative Works.  - ‘The Source Code’: the human-readable form of the Work which is the most convenient for people to study and modify.  - ‘The Executable Code’: any code which has generally been compiled and which is meant to be interpreted by a computer as a program.  - ‘The Licensor’: the natural or legal person that distributes or communicates the Work under the Licence.  - ‘Contributor(s)’: any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work.  - ‘The Licensee’ or ‘You’: any natural or legal person who makes any usage of the Work under the terms of the Licence.  - ‘Distribution’ or ‘Communication’: any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential functionalities at the disposal of any other natural or legal person.  2. Scope of the rights granted by the Licence  The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for the duration of copyright vested in the Original Work:  - use the Work in any circumstance and for all usage, - reproduce the Work, - modify the Work, and make Derivative Works based upon the Work, - communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work, - distribute the Work or copies thereof, - lend and rent the Work or copies thereof, - sublicense rights in the Work or copies thereof.  Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.  In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.  The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.  3. Communication of the Source Code  The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute or communicate the Work.  4. Limitations on copyright  Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations thereto.  5. Obligations of the Licensee  The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:  Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.  Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless the Original Work is expressly distributed only under this version of the Licence — for example by communicating ‘EUPL v. 1.2 only’. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.  Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, ‘Compatible Licence’ refers to the licences listed in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.  Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute or communicate the Work.  Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the copyright notice.  6. Chain of Authorship  The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.  Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.  Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.  7. Disclaimer of Warranty  The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work and may therefore contain defects or ‘bugs’ inherent to this type of development.  For the above reason, the Work is provided under the Licence on an ‘as is’ basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.  This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.  8. Disclaimer of Liability  Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.  9. Additional agreements  While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by the fact You have accepted any warranty or additional liability.  10. Acceptance of the Licence  The provisions of this Licence can be accepted by clicking on an icon ‘I agree’ placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.  Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution or Communication by You of the Work or copies thereof.  11. Information to the public  In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.  12. Termination of the Licence  The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence.  Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.  13. Miscellaneous  Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work.  If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid and enforceable.  The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. New versions of the Licence will be published with a unique version number.  All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take advantage of the linguistic version of their choice.  14. Jurisdiction  Without prejudice to specific agreement between parties,  - any litigation resulting from the interpretation of this License, arising between the European Union institutions, bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union,  - any litigation arising between other parties and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.  15. Applicable Law  Without prejudice to specific agreement between parties,  - this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, resides or has his registered office,  - this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside a European Union Member State.  Appendix  ‘Compatible Licences’ according to Article 5 EUPL are:  - GNU General Public License (GPL) v. 2, v. 3 - GNU Affero General Public License (AGPL) v. 3 - Open Software License (OSL) v. 2.1, v. 3.0 - Eclipse Public License (EPL) v. 1.0 - CeCILL v. 2.0, v. 2.1 - Mozilla Public Licence (MPL) v. 2 - GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3 - Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software - European Union Public Licence (EUPL) v. 1.1, v. 1.2 - Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+).  The European Commission may update this Appendix to later versions of the above licences without producing a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the covered Source Code from exclusive appropriation.  All other changes or additions to this Appendix require the production of a new EUPL version.


pkgId: 655f7fc99db4cb51c5f9262094e5770de5278ab094ed6edff93bbbb5b8a484ad
name: python3-gptree-cli
arch: noarch
version: 1.0.0
epoch: 0
release: 1
url: https://pypi.org/project/gptree-cli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-gptree-cli-1.0.0-1.src.rpm
location_href: Packages/python3-gptree-cli-1.0.0-1.noarch.rpm
checksum_type: sha256
summary:
  A CLI tool to provide LLM context for coding projects by combining project files into a single text file with directory tree structure.

description:
  When working with Large Language Models (LLMs) to continue or debug your coding projects, providing the right context is key. `gptree` simplifies this by:
  1. Generating a clear **directory tree structure** of your project.
  2. Combining the **contents of relevant files** into a single output text file.
  3. Allowing you to **select files interactively** to fine-tune which files are included.


pkgId: bad867773b01336ce7f569422b80d649da1828504bc573aabf5360cd223adc51
name: python3-hcli-hc
arch: noarch
version: 0.4.0
epoch: 0
release: 1
url: https://github.com/cometaj2/hcli_hc
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-hcli-hc-0.4.0-1.src.rpm
location_href: Packages/python3-hcli-hc-0.4.0-1.noarch.rpm
checksum_type: sha256
summary:
  HCLI hc is a pypi wrapper that contains an HCLI sample application (hc); hc can can act both as a gcode streamer (e.g. for OpenBuilds Blackbox controller v1.1g) and CNC interface. In other words, this HCLI acts in the same capacity as the OpenBuilds CONTROL software or OpenBuilds Interface CNC Touch hardware to help control a GRBL v1.1g controlled CNC.


pkgId: e2e5b117b02698ddb7d6a89f38533c201a897a966bd6feb8226ee07bab60691b
name: python3-humiris-ai
arch: noarch
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/joeai-tech-org/humiris-pip-package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-humiris-ai-1.0.0-1.src.rpm
location_href: Packages/python3-humiris-ai-1.0.0-1.noarch.rpm
checksum_type: sha256
summary:
  Humiris is a library that allows developers to easily integrate AI capabilities into their applications.

description:
  Please ensure you have Python (version 3.6 or higher) installed before proceeding.





  You can install Humiris using either npm or yarn:

  ```bash

  npm install humiris-ai


  yarn add humiris-ai

  ```













  For more detailed information, please refer to the [Humiris Development Documentation](https://docs.humiris.ai/development).


pkgId: 92433d7a6213c2a189756116e7d88d895d2b6bf9388797c9f9794d46c7148d7a
name: python3-iamdata
arch: noarch
version: 0.1.202412141
epoch: 0
release: 1
url: https://github.com/cloud-copilot/iam-data-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iamdata-0.1.202412141-1.src.rpm
location_href: Packages/python3-iamdata-0.1.202412141-1.noarch.rpm
checksum_type: sha256
summary:
  IAM data for AWS actions, resources, and conditions based on IAM policy documents. Checked for updates daily.

description:
  This is a simple package for utilizing AWS IAM data for Services, Actions, Resources, and Condition Keys. Data is embedded in the python package.

  New data is checked against the AWS IAM documentation and updated daily if there are changes.


  ```bash
  pip install iam-data
  ```


  ```python
  from iamdata import IAMData

  iam_data = IAMData()
  print(f"Data Version {iam_data.data_version()} updated at {iam_data.data_updated_at()}")
  for service_key in iam_data.services.get_service_keys():
      service_name = iam_data.services.get_service_name(service_key)
      print(f"Getting Actions for {service_name}")
      for action in iam_data.actions.get_actions_for_service(service_key):
          action_details = iam_data.actions.get_action_details(service_key, action)
          print(f"{service_key}:{action} => {action_details}")
  ```



  * `services.get_service_keys()` - Returns a list of all service keys such as 's3', 'ec2', etc.
  * `services.get_service_name(service_key)` - Returns the service name for a given service key.
  * `services.service_exists(service_key)` - Returns True if the service key exists.


  * `actions.get_actions_for_service(service_key)` - Returns an array of all actions for a given service key.
  * `actions.get_action_details(service_key, action_key)` - Returns an object with the action details such as `description`, `resourceTypes`, and `conditionKeys`.
  * `actions.action_exists(service_key, action_key)` - Returns true if the action exists.


  * `resources.get_resource_types_for_service(service_key)` - Returns an array of all resource types for a given service key.
  * `resources.get_resource_type_details(service_key, resource_type_key)` - Returns an object with the resource type details such as `description`, `arnFormat`, and `conditionKeys`.
  * `resources.resource_type_exists(service_key, resource_type_key)` - Returns true if the resource type exists.


  * `conditions.get_condition_keys_for_service(service_key)` - Returns an array of all condition keys for a given service key.
  * `conditions.get_condition_key_details(service_key, condition_key)` - Returns an object with the condition key details such as `description`, `conditionValueTypes`, and `conditionOperators`.
  * `conditions.condition_key_exists(service_key, condition_key)` - Returns true if the condition key exists.


  The version is number is formatted as `major.minor.updatedAt`. The updatedAt is the date the data was last updated in the format `YYYYMMDDX` where `X` is a counter to enable publishing more than once per day if necessary. For example version `0.1.202408291` has data updated on August 29th, 2024.

  The version can be accessed using the `data_version()` method.

  There is also `date_updated_at()` which returns the date the data was last updated.


pkgId: 51bc19d6c29deed0a7a1355facbe7a4e282f2d8fa3fd6cd4d6d173f8a08ac04e
name: python3-iloveapi
arch: noarch
version: 0.1.4
epoch: 0
release: 1
url: https://pypi.org/project/iloveapi/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-iloveapi-0.1.4-1.src.rpm
location_href: Packages/python3-iloveapi-0.1.4-1.noarch.rpm
checksum_type: sha256
summary:
  Python api client made for iLoveIMG & iLovePDF based on iLoveAPI (https://www.iloveapi.com/docs/api-reference).

description:
  Python api client made for iLoveIMG & iLovePDF based on iLoveAPI (https://www.iloveapi.com/docs/api-reference).



  - Fully typed code
  - Asyncio support
  - REST API & workflow API encapsulation



  ```shell
  pip install iloveapi
  ```



  Simply compress image:

  ```python
  from iloveapi import ILoveApi

  client = ILoveApi(
      public_key="<project_public_******>",
      secret_key="<secret_key_******>",
  )
  task = client.create_task("compressimage")
  task.process_files("p1.png")
  task.download("output.png")
  ```

  Multiple images:

  ```python
  task = client.create_task("compressimage")
  task.process_files(
      "p1.png",
      ("custom_name.png", "p2.png"),
      ("custom_name.png", b"..PNG..."),
      {
          "file": b"..PNG...",
          "filename": "custom_name.png",
          "rotate": 2,  # add image parameter
          "password": "xxx",  # for PDF
      }
  )
  task.download("output.zip")  # zip format
  ```

  Async support:

  ```python
  task = await client.create_task_async("compressimage")
  await task.process_files_async("p1.png")
  await task.download_async("output.png")
  ```

  Directly call REST API:

  ```python
  response = client.rest.start("compressimage")  # getting httpx response
  response = await client.rest.start_async("compressimage")  # async
  ```



  - [ ] Typed parameter for all processing tools
  - [ ] Command-line interface



  Image / PDF processing tools usually focus on results rather than JSON data, as data type validation is not important to the user.


pkgId: 6027e434447fa27f4ef15bf138f31e02d37b5412e31dfc33433dc09fcd42e14e
name: python3-ipsurv
arch: noarch
version: 1.1.1
epoch: 0
release: 1
url: https://github.com/deer-hunt/ipsurv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ipsurv-1.1.1-1.src.rpm
location_href: Packages/python3-ipsurv-1.1.1-1.noarch.rpm
checksum_type: sha256
summary:
  "IpSurv" is a command-line program for surveying IP addresses, host information, and more. Also "IpSurv" is extensible program by Python.

description:
  <div>
  <img width="165" height="165" src="https://raw.githubusercontent.com/deer-hunt/ipsurv/main/docs/images/ipsurv-logo.png" align="left" />

  ```IpSurv``` is a command-line program for surveying IP addresses, host information, and more. Also ```IpSurv``` is extensible program by Python.

  <div>

  <a href="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests.yml"><img alt="CI - Test" src="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests.yml/badge.svg"></a>
  <a href="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests-windows.yml"><img alt="CI - Test" src="https://github.com/deer-hunt/ipsurv/actions/workflows/unit-tests-windows.yml/badge.svg"></a>
  <a href="https://github.com/deer-hunt/ipsurv/actions/workflows/lint.yml"><img alt="GitHub Actions build status (Lint)" src="https://github.com/deer-hunt/ipsurv/workflows/Lint/badge.svg"></a>
  <a href="https://codecov.io/gh/deer-hunt/ipsurv"><img alt="Coverage" src="https://codecov.io/github/deer-hunt/ipsurv/coverage.svg?branch=main"></a>
  <img alt="PyPI - Status" src="https://img.shields.io/pypi/status/ipsurv">
  <a href="https://github.com/deer-hunt/ipsurv/blob/main/LICENSE.md"><img alt="License - MIT" src="https://img.shields.io/pypi/l/ipsurv.svg"></a>
  <a href="https://pypi.org/project/ipsurv/"><img alt="Newest PyPI version" src="https://img.shields.io/pypi/v/ipsurv.svg"></a>
  <a href="https://pypi.org/project/ipsurv/"><img alt="Number of PyPI downloads" src="https://img.shields.io/pypi/dm/ipsurv.svg"></a>
  <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/deer-hunt/ipsurv">
  <a href="https://pypi.org/project/ipsurv"><img alt="Supported Versions" src="https://img.shields.io/pypi/pyversions/ipsurv.svg"></a>
  <a href="https://deer-hunt.github.io/ipsurv/" alt="IpSurv's documentation site"><img src="https://img.shields.io/badge/stable%20docs-github.io-brightgreen?style=flat&color=%2373DC8C&label=Docs"/></a>
  <a href="https://app.fossa.com/projects/git%2Bgithub.com%2Fdeer-hunt%2Fipsurv?ref=badge_shield" alt="FOSSA Status"><img src="https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdeer-hunt%2Fipsurv.svg?type=shield"/></a>

  </div>
  </div>

  <p>&nbsp;</p>

  <img src="https://raw.githubusercontent.com/deer-hunt/ipsurv/main/docs/images/ipsurv.gif" alt="ipsurv visual image" width="100%" />



  ```bash
  $ pip install ipsurv
  or
  $ pip3 install ipsurv
  ```



  - ```python``` and ```pip``` command
  - Python 3.0 or later version.

  > If you'd like to use in Python 2.7, you can refactor to Python 2.7 code easily. See "development_debug.md".



  IpSurv's documentation site is [https://deer-hunt.github.io/ipsurv/](https://deer-hunt.github.io/ipsurv/).




  **Specify Target using Argument**

  ```bash
  $ ipsurv 192.168.1.10
  $ ipsurv 192.168.1.10 192.168.1.11
  $ ipsurv test-example-sample-ipsurv.com --add_ip
  $ ipsurv x.x.x.x --format=geo
  ```

  **Specify Target using PIPE**

  ```bash
  $ cat ips.txt|ipsurv
  $ cat apache.log|ipsurv --add_ip
  ```

  **Example result**

  ```bash
  8.8.8.8:53,8.8.8.0,US,ICMP_OK,TCP_OK,UDP_OK
  ```



  ```IpSurv``` have two Survey-mode. Those are "Survey IPs" and "Survey Self".

  | Survey-mode              | Description              |
  |-------------------|------------------------|
  | **Survey IPs**     | Primary mode. Surveying IP or Host or URL.     |
  | **Survey Self**    | Surveying self IP.     |

  **Survey Self e.g.**

  ```bash
  $ ipsurv self
  Ip: 144.160.*.*
  Hostname:
  Organization: AS797 AT&T Services, Inc.
  Country: US
  City: San Jose
  Region: California
  Postal: 95103
  Geo: 37.3394,-121.8950
  Timezone: America/Los_Angeles
  LocalIp: 10.0.2.5
  LocalDns: ['8.8.8.8', '8.8.4.4']
  ```



  - Grouping by IP or Subnet.
  - Skip duplicate by the group.
  - Autodetect IP in line. Trying to resolve the name automatically.
  - Autodetect delimiter-char.
  - Customize output format. There are many format.
  - Output JSON format.
  - Show headers.
  - Check ICMP, TCP, UDP, HTTP.
  - Set timeout.
  - Load env variable. And changing arguments and internal configures.
  - Use GeoIP2 via IpSurv optionally.



  ```IpSurv``` have many options. Please read [Command arguments(.md) reference](https://github.com/deer-hunt/ipsurv/blob/main/docs/command_arguments.md).

  **Options**

  ```
  [-h] [--verbose {0,1,2,3}] [--debug] [--log LOG]
  [--disable_env] [--resolve RESOLVE] [--identify_int]
  [--autodetect AUTODETECT] [--begin BEGIN] [--end END]
  [--collect COLLECT] [--all_collect] [--timeout TIMEOUT]
  [--group GROUP] [--skip_duplicate {0,1,2}] [--range RANGE]
  [--format FORMAT] [--no_original] [--sequence] [--add_ip]
  [--ident] [--enclose ENCLOSE] [--delimiter DELIMITER]
  [--alt_delimiter ALT_DELIMITER] [--headers {0,1,2,3}]
  [--json {0,1,2}] [--json_list] [--exhaustive] [--icmp ICMP]
  [--tcp TCP] [--udp UDP] [--http {0,1,2}] [--json_all]
  [--geoip_only] [--version]
  [target [target ...]]
  ```

  **Example options**

  ```bash
  $ cat ips.txt|ipsurv --group=24
  $ cat ips.txt|ipsurv --group=network
  $ cat ips.txt|ipsurv --format=country
  $ cat ips.txt|ipsurv --format=hostname
  $ cat ips.txt|ipsurv --format="{country},{name}"
  $ cat ips.txt|ipsurv --format="{country},{ip_int},{handle},{port43}"
  $ cat /var/log/httpd/access_log|ipsurv --ident --no_original

  $ cat ips.txt|ipsurv --group=255.255.255.0
  $ cat ips.txt|ipsurv --delimiter="\t"
  $ cat ips.txt|ipsurv --format="{group}\t{ip_int}\t{country}\t{handle}\t{port43}"
  $ cat ips.txt|ipsurv --format="{country},{ip_int},{handle},{port43},{icmp},{port},{tcp}" --group=network --icmp=1 --tcp=1 --timeout=2
  ```



  **Show headers**

  ```bash
  $ cat ./example_data/government.txt|ipsurv --headers=1 --format="{status},{group},{country},{name},{cidr},{http},{http_h2}" --group=network --http=2
  original,status,group,country,name,cidr,http,http_h2
  www.whitehouse.gov,OK,192.0.64.1,US,AUTOMATTIC,192.0.64.0/18,HTTP_OK,HTTP2
  www.state.gov,OK,3.165.0.1,US,AMAZON-CF,3.165.0.0/16,HTTP_OK,HTTP2
  www.treasury.gov,OK,23.32.0.1,US,AKAMAI,23.32.0.0/11,HTTP_OK,HTTP2
  www.gov.uk,OK,151.101.0.1,US,SKYCA-3,151.101.0.0/16,HTTP_OK,HTTP2
  www.gouvernement.fr,OK,217.70.184.1,FR,GANDIFR-NET4,217.70.184.0/24,HTTP_OK,HTTP1
  www.diplomatie.gouv.fr,OK,77.128.0.1,FR,FR-SFR-20100831,77.128.0.0/11,HTTP_OK,HTTP1
  www.economie.gouv.fr,OK,141.101.88.1,EU,CLOUDFLARE-EU,141.101.88.0/21,HTTP_OK,HTTP2
  www.bundesregierung.de,OK,185.173.230.1,DE,BABIEL-NET-230,185.173.230.0/24,HTTP_OK,HTTP2
  ```

  **Add line-number**

  ```bash
  $ cat ./example_data/government.txt|ipsurv --sequence --add_ip
  1,www.whitehouse.gov,192.0.66.168,OK,US,AUTOMATTIC,192.0.64.0,192.0.127.255
  2,www.state.gov,3.165.39.61,OK,US,AMAZON-CF,3.165.0.0,3.165.255.255
  3,www.treasury.gov,23.50.118.187,OK,US,AKAMAI,23.32.0.0,23.67.255.255
  4,www.gov.uk,151.101.192.144,OK,US,SKYCA-3,151.101.0.0,151.101.255.255
  ```

  **Output by JSON**

  ```bash
  $ ipsurv wikipedia.org --format=default --json=2 --add_ip
  {
    "original": "wikipedia.org",
    "ip": "103.102.166.224",
    "status": "OK",
    "group": "",
    "country": "US",
    "name": "WIKIMEDIA-AP",
    "network_start": "103.102.166.0",
    "network_end": "103.102.166.255"
  }
  ```

  **Output detailed data by JSON**

  ```bash
  $ ipsurv wikipedia.org --json_all    # `--json_all` is equivalent to `--json=2 --exhaustive`
  $ ipsurv wikipedia.org --format=default --json=2 --exhaustive
  {
    "success": true,
    "status": "OK",
    "requests": [
      "RDAP"
    ],
    "errors": [],
    "sequence": 1,
    "original": "wikipedia.org",
    "target": "103.102.166.224",
    "ip": "103.102.166.224",
    "ip_int": 1734780640,
    "port": null,
    "group_int": 0,
    "group": "",
    "group_found": false,
    "group_status": "-",
    "country": "US",
    "name": "WIKIMEDIA-AP",
    "network_start": "103.102.166.0",
    "network_end": "103.102.166.255",
    "ip_hex": "67.66.A6.E0",
    "ip_reversed": "224.166.102.103",
    "ip_type": "PUBLIC",
  ~~~~~~~~~~~~~
    "org": "Wikimedia Foundation, Inc.",
    "address": "1 Montgomery Street Suite 1600",
    "description": "Wikimedia Foundation, Inc.",
    "target.raw": "wikipedia.org",
    "target.identifier": "103.102.166.224",
    "target.identifier_int": 1734780640,
    "target.identified": true,
    "target.ip": "103.102.166.224",
    "target.url": null,
    "target.fqdn": "wikipedia.org",
    "target.port": null,
    "target.status": "EXIST"
  }
  ```

  More examples are [here](https://deer-hunt.github.io/ipsurv/pages/command_examples.html).




  You can customize "Output Format" by ```--format``` option as follows. There are ```parameter - {}``` and ```profile - <>``` in ```--format```.
  For more information, please read [--format description](https://deer-hunt.github.io/ipsurv/pages/command_arguments.html#format).

  ```
  $ ipsurv github.io --format=heavy            # Profile
  $ ipsurv github.io --format=simple           # Profile

  $ ipsurv 8.8.8.8 --format="{status},{ip},{country},{address}"   # Paramaters
  $ ipsurv 8.8.8.8 --format="{status}\t{ip}\t{hostname}"         # Paramaters, TAB char

  $ ipsurv cloudflare.com --format="{ip},<address>,<system>"      # Paramaters + Profile
  $ ipsurv wikipedia.org --format="<address>,{hostname},{ip_type}"     # Profile + Paramaters
  ```




  ```IpSurv``` support [GeoIP2](https://github.com/maxmind/GeoIP2-python) optionally. If ```GeoIP2``` module is installed and there are ```mmdb``` files, You can use GeoIP2 features via ```IpSurv```.
  When using the GeoIP2 module, network communication does not occur, which enables faster processing.

  Please refer to the [Using GeoIP2](https://deer-hunt.github.io/ipsurv/pages/using_geoip2.html) documentation in detail.

  **Examples**

  ```
  $ ipsurv 8.8.8.8 --geoip_only
  8.8.8.8,NA,North America,US,United States,America/Chicago,AS15169,37.751;-97.822
  ```

  ```
  $ ipsurv www.wikipedia.org --format="{country},{geo}" --collect=geoip --headers=1
  original,country,geo
  www.wikipedia.org,US,37.751;-97.822

  $ ipsurv 8.8.8.8 --format="{continent},{continent_name},{country},{geo}" --collect="geoip" --headers=1
  original,continent,continent_name,country,geo
  8.8.8.8,NA,North America,US,37.751;-97.822
  ```

  > `IpSuv` support customizing GeoIP2 data path by `IPSURV_CONF` env. Please read [here](https://deer-hunt.github.io/ipsurv/pages/command_arguments.html#environment-variable-ipsurv-conf) about `IPSURV_CONF`.




  The following documents exist in ```IpSurv```. You can read documents in [Documentation site](https://deer-hunt.github.io/ipsurv/).

  | Title                       | Path                                        |
  |-------------------------------|---------------------------------------------|
  | **Command arguments**    | [command_arguments.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/command_arguments.md) |
  | **Command examples**               | [command_examples.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/command_examples.md)   |
  | **Program architecture and Classes** | [program_architecture_classes.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/program_architecture_classes.md) |
  | **Customizing and Examples**       | [customize_examples.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/customize_examples.md) |
  | **Development and Debugging**          | [development_debug.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/development_debug.md)   |
  | **About Using GeoIP2** | [using_geoip2.md](https://github.com/deer-hunt/ipsurv/blob/main/docs/using_geoip2.md)  |
  | **IpSurv's Major Modules and Classes** | [github.io / Modules and Classes reference](https://deer-hunt.github.io/ipsurv/py-modindex.html)  |




  | Directory        | Description                                         |
  |-----------------------|-----------------------------------------------------|
  | `.github`            | GitHub Actions files          |
  | `docs`               | Documentation files                                 |
  | `example_data`       | Sample data files for testing                       |
  | `examples`           | Example programs                 |
  | `ipsurv`             | Main package/Sources                            |
  | `tests`              | Test files                     |




  In verbose mode, outputting internal data and behaviors in detail.

  ```bash
  $ ipsurv ***** --verbose=2    #INFO
  $ ipsurv ***** --verbose=3    #DEBUG

  $ ipsurv ***** --debug     #DEBUG  This option is equivalent to "--verbose=3"
  ```



  ```IpSurv``` is implemented as customizable program architecture. ```IpSurv``` provide extending features and several classes.
  And you can use IpSurv's internal classes in your program. Please read ```program_architecture_classes.md```.

  **Classes for major customization**

  | Classes    | Description            |
  |----------------------|----------------------------------------------|
  | **Pipeline**   | Pipeline class provide catching and customizing the data in each processing. ```./examples/pipeline_customize.py```         |
  | **ObjectFactory**   | ObjectFactory class provide customizing classes and creating original classes. ```./examples/object_factory.py```      |
  | **Serializer, LineSerializer, JsonSerializer**   | Serializer class provide displaying data and transforming data for presentation. ```./examples/object_factory_original_headers.py```      |




  - [dnspython](https://github.com/rthalley/dnspython)
  - [geoip2](https://github.com/maxmind/GeoIP2-python) [Optional]


pkgId: b76a5c6d5c176e5a8260a921b0e50eaf4a31442ef7de9620c5cce2f9eb4e3df4
name: python3-jaf
arch: noarch
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/queelius/jaf
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jaf-0.1.0-1.src.rpm
location_href: Packages/python3-jaf-0.1.0-1.noarch.rpm
checksum_type: sha256
summary:
  JSON Array Filter (jaf) is a versatile filter for JSON arrays. It is a domain-specific language (DSL) that allows you to filter JSON arrays using a simple, yet powerful syntax. Programmaticcally, the AST can be used to filter JSON arrays in a more flexible way.

description:
  `jaf` is a versatile filtering system designed to sift through JSON arrays.
  It allows users to filter JSON arrays based on complex conditions using a
  simple and intuitive query language. The query language is designed to be
  easy to use and understand, while still being powerful enough to handle
  complex filtering tasks.



  We refer to the available operators as `builtins`. These are the functions that
  are available to the user to use in their queries. The `builtins` are functions
  that are used to compare values, perform operations, or combine other functions
  to create complex queries. The `builtins` are the core of the filtering system
  and are used to create queries that can filter JSON arrays based on the
  specified conditions.

  Predicates conanically end with a `?`, e.g., `eq?` (eauals) and `lt?` (less-than).
  General operators do not canocially end with a `?`, e.g., `lower-case` and `or`.
  The predicates are used to compare values, while the operators are used to combine
  predicates or perform other operations that make the desired comparison possible
  or the desired result achievable.

  > *Note*: We do not use operators like `==` or `>`, but instead use `eq?` and
  > `gt?`. The primary reason for this choice is that we provide a command-line
  > tool, and if we used `>` it would be interpreted as a redirection operator
  > by the shell.

  For example, the `lower-case` operator is used to convert a string to lowercase before
  comparison, so that the comparison is case-insensitive. Here is an example
  query that uses the `lower-case` operator:

  ```python
  ['and', ['lower-case', ['path', 'language']], ['eq?', 'python']]
  ```

  This query will filter repositories where the `language` field is equal to
  `"python"`, regardless of the case of the letters.

  > *Note*: Depending on the `builtins`, the query language can be Turing complete.
  > e.g., it would be trivial to add a `lambda` builtin that allows users to define
  > their own functions. However, this is not a safe practice, as it would allow
  > users to execute arbitrary code. Therefore, we have chosen to limit the default
  > `builtins` to a safe set of functions that are useful for filtering JSON arrays.
  > If you need additional functionality, you can always extend or provide your own
  > set of `builtins` to include the functions you need. As a limiting case, a
  > `lambda` builtin could be added to the `builtins` to allow users to define their
  > own functions.



  Queries are represented using an Abstract Syntax Tree (AST) based on nested
  lists, where each list takes the form of `[<expressio>, <arg1>, <arg2>,...]`.

  We also provide a Domain-Specific Language (DSL) that allows users to craft
  queries using an intuitive infix notation. The DSL is converted into the AST
  before being evaluated. Here is the EBNF for the query language:

  ```ebnf
  %import common.WS
  %import common.ESCAPED_STRING
  %import common.SIGNED_NUMBER
  %ignore WS

  start: expr

  expr: bool_expr

  ?bool_expr: or_expr

  ?or_expr: and_expr
          | or_expr OR and_expr -> or_operation

  ?and_expr: primary
          | and_expr AND primary -> and_operation

  ?primary: operand
         | "(" bool_expr ")"

  ?operand: condition
         | function_call
         | path
         | bare_path
         | value

  condition: operand operator operand

  operator: IDENTIFIER

  function_call: "(" IDENTIFIER operand+ ")"

  path: ":" path_component ("." path_component)*

  bare_path: path_component ("." path_component)*

  path_component: IDENTIFIER
               | STAR
               | DOUBLESTAR

  STAR: "*"
  DOUBLESTAR: "**"

  value: ESCAPED_STRING
       | NUMBER
       | BOOLEAN

  BOOLEAN: "True" | "False"
  NUMBER: SIGNED_NUMBER

  IDENTIFIER: /[a-zA-Z][a-zA-Z0-9_\-\?]*/

  OR: "OR"
  AND: "AND"
  ```

  For example, consider the following query AST:

  ```python
  ['and',
      ['eq?', ['lower-case', ['path', 'language']], 'python'],
      ['gt?', ['path', 'stars'], 100],
      ['eq?', ['path','owner.name'], ['path': 'user.name']]]
  ```

  It has an equivalent DSL given by:

  ```text
  (lower-case :language) eq? "python" AND :stars gt? 100 AND :owner.name eq? :user.name
  ```

  We see that we have a special notation for `path` commands: we prefix the field
  name with a colon: `:`, such as `:language` and `:owner.name`. This is to distinguish
  field names from other strings in the query. The `path`command is used to
  access the value of a field in the JSON array. For example, `:owner.name` will
  access the value of the `name` field in the `owner` object where as `owner.name`
  will be interpreted as a string.

  Paths can also include two kinds of wildcards, `*` and `**`. The wildcard `*`
  matches any fieldname, e.g., `a.*.b.c` will match `a.d.b.c.a` (it will return `{'c': 'a'}`.
  The wildcard `**` will match any fieldname at any depth after the specified path,
  e.g., `a.**.c` will match `a.b.c.a` (it will also return `{'c': 'a'}`. You can use
  as many wildcards as you wish in a single query. If *any* of the objects denoted by
  a wildcard path satisfy the query, the object satisfies the query.

  The DSL is converted into the AST (see the above EBNF) before being evaluated.
  This query AST is evaluated against each element of the JSON array, and if it
  returns `True`, the corresponding index into the JSON array for that element is
  added to the result. This is how we filter the JSON array. Alternatively, since
  queries can also specify general functions, the result may be a value rather
  than a Boolean, e.g., `['lower-case', 'Python']` will return `'python`.



  Both have their own advantages and can be used interchangeably based on the
  user's preference. The AST is:

  - programmatic
  - easily manipulated
  - can be generated from a DSL
  - easily serialized for storage or transmission
  - allows for operators to be queries, facilitating some meta-programming

  The DSL is:

  - More human-readable, e.g. infix notation for logical operators
  - Easier to write and understand
  - Compact



  You can install `jaf` via PyPI:

  ```bash
  pip install `jaf`
  ```

  Or install directly from the source:

  ```bash
  git clone https://github.com/queelius/jaf.git
  cd jaf
  pip install .
  ```



  Suppose we have a list of repositories in the following format:

  ```python
  repos = [
      {
          'id': 1,
          'name': 'DataScienceRepo',
          'language': 'Python',
          'stars': 150,
          'forks': 30,
          'description': 'A repository for data science projects.',
          'owner': {
              'name': 'alice',
              'active': True
          }
      },
      
  ]
  ```



  Filter repositories where the lower-case of `language` is `"python"`,
  `owner.active` is `True`, and `stars` are greater than `100`:

  ```python
  query = ['and',
      ['eq?',
          ['lower-case', ['path', 'language'], 'Python']],
          ['path', 'owner.active'],
          ['gt?', ['path', 'stars'], 100]]

  filtered = jaf(sample_repos, query_ast)
  print("Filtered Repositories:")
  pprint(filtered)

  ```



  The equivalent query using the DSL:

  ```python
  query = '(lower-case :language) eq? "python" AND :owner.active AND :stars gt? 100'
  filtered = jaf(repos, query)
  print("Filtered Repositories:")
  print(filtered)

  ```



  Combine multiple conditions with logical operators.

  ```python
  query = ':language neq? "R" AND (:stars gt? 100 OR :forks gt? 50)'
  filtered = jaf(repos, query)
  print("Filtered Repositories:")
  ```



  Catch and handle filtering errors gracefully.

  ```python
  try:
      invalid_query = 'language unknown "Python"'
      jaf(repos, invalid_query)
  except FilterError as e:
      print(f"Error: {e}")
  ```



  Contributions are welcome! Please open an issue or submit a pull request for any enhancements or bug fixes.



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


pkgId: 8733049fa9392cec2cc38120140996278e887775f36413dc5de5ef016d398b44
name: python3-jsonargparse
arch: noarch
version: 4.35.0
epoch: 0
release: 1
url: https://pypi.org/project/jsonargparse/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-jsonargparse-4.35.0-1.src.rpm
location_href: Packages/python3-jsonargparse-4.35.0-1.noarch.rpm
checksum_type: sha256
summary:
  Implement minimal boilerplate CLIs derived from type hints and parse from command line, config files and environment variables.

description:
  Docs: https://jsonargparse.readthedocs.io/ | Source: https://github.com/omni-us/jsonargparse/
  ``jsonargparse`` is a library for creating command-line interfaces (CLIs) and
  making Python apps easily configurable. It is a well-maintained project with
  frequent releases, adhering to high standards of development: semantic
  versioning, deprecation periods, changelog, automated testing, and full test
  coverage.
  Although ``jsonargparse`` might not be widely recognized yet, it already boasts
  a `substantial user base
  <https://github.com/omni-us/jsonargparse/network/dependents>`__. Most notably,
  it serves as the framework behind pytorch-lightning's `LightningCLI
  <https://lightning.ai/docs/pytorch/stable/cli/lightning_cli.html>`__.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2019-present, Mauricio Villegas <mauricio@omnius.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: e010de4b5716bd4976f3fd2c2d403778db8fded40e7cbaef127d1e50505b562e
name: python3-kcolorconverter
arch: noarch
version: 0.0.1
epoch: 0
release: 1
url: https://github.com/kokaito-git/kcolorconverter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-kcolorconverter-0.0.1-1.src.rpm
location_href: Packages/python3-kcolorconverter-0.0.1-1.noarch.rpm
checksum_type: sha256
summary:
  A utility library for converting colors between formats like RGB, RGBA, HEX6, and HEX8. Provides flexible handling of color representations for Python applications.


pkgId: 9e3f7c24189135f6048569b002840f02f16f708cb93c9394901df565277ca8a8
name: python3-ladybug-geometry
arch: noarch
version: 1.33.13
epoch: 0
release: 1
url: https://github.com/ladybug-tools/ladybug-geometry
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ladybug-geometry-1.33.13-1.src.rpm
location_href: Packages/python3-ladybug-geometry-1.33.13-1.noarch.rpm
checksum_type: sha256
summary:
  Library housing basic geometry objects and computation methods needed for the Ladybug Tools core libraries.

description:
  ![Ladybug](http://www.ladybug.tools/assets/img/ladybug.png)

  [![Build Status](https://github.com/ladybug-tools/ladybug-geometry/workflows/CI/badge.svg)](https://github.com/ladybug-tools/ladybug-geometry/actions)
  [![Coverage Status](https://coveralls.io/repos/github/ladybug-tools/ladybug-geometry/badge.svg?branch=master)](https://coveralls.io/github/ladybug-tools/ladybug-geometry?branch=master)

  [![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/downloads/release/python-370/) [![Python 2.7](https://img.shields.io/badge/python-2.7-green.svg)](https://www.python.org/downloads/release/python-270/) [![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)



  Ladybug geometry is a Python library that houses geometry objects and geometry
  computations methods used throughout the Ladybug Tools core libraries.

  The library is designed to work with a wide range of Python environments and
  it returns consistent results between them (cPython 2 and 3, IronPython 2).



  `pip install -U ladybug-geometry`





  - Perform Vector Math (Dot, Cross, Angle, Normalize)
  - Calculate Bounding Box for any Geometry (Min, Max, Center)
  - Subdivide Lines and Arcs
  - Compute Perimeter and Area of Planar Geometry
  - Check Concavity and Clockwise Ordering of 2D Geometry
  - Triangulate Planar Geometry
  - Compute Mesh Face Areas, Centroids, and Normals
  - Move Any Geometry
  - Rotate Any Geometry Around an Axis (or in the XY plane)
  - Mirror (Reflect) Any Geometry Over a Plane
  - Scale Any Geometry from a Base Point
  - Check if a 2D Point Inside 2D Polygon
  - Compute [Pole of Inaccessibility](https://en.wikipedia.org/wiki/Pole_of_inaccessibility) for any 2D Polygon
  - Check the Relationship Between 2D Polygons within a Tolerance (inside, outside, overlap)
  - Group 2D Polygons According to Overlaps
  - Perform 2D Polygon Boolean Operations (Union, Intersection, Difference)
  - Intersect Colinear 2D Polygon Segments with one Another (for matching lengths)
  - Join Line Segments into Polylines
  - Calculate 3D Face Plane and Normal from Vertices
  - Compute 3D Face Intersection with a Ray or Line
  - Generate a Quad Mesh Grid from a 3D Face
  - Generate Sub-faces Based on Ratio with a Face (used for window generation)
  - Generate Contours and Contour Fins from a Face (used to generate louvers, fins and overhangs)
  - Split, Union, or Intersect 3D Coplanar Faces with one Another (for matching areas)
  - Solve Adjacencies by Matching 3D Face Geometries
  - Join 3D Faces into 3D Polyfaces
  - Check if a 3D PolyFace is a Closed Solid
  - Ensure All Faces of a Solid 3D PolyFace Point Outwards
  - Compute the Volume of a Closed 3D Polyface
  - Check if a Point is Inside a Closed 3D Polyface



  - Conversion of Curved 3D Surfaces to Planar 3D Faces
  - Fancier Meshing (eg. gridded meshing that completely fills the base surface)
  - Solid Boolean Unions (this should not be needed for anything in Ladybug Tools)



  This library was built by combining capabilities of several different open-source
  (MIT Licensed) projects, establishing a set of standardized geometry objects that
  allowed them all to talk to one another, and adding several other capabilities
  with new code. We as a community owe a huge amount of thanks to the open source projects
  that provided many of the starting capabilities of this package and we are indebted
  to the developers who made their work available under an MIT license for the betterment
  of geometry computation everywhere. Where possible, you will find detailed lists of
  references in the docstrings of this package's source code. A summary of the key
  sources that were used to build this library are as follows:

  - [euclid](https://pypi.org/project/euclid/)
  - [earcut](https://github.com/mapbox/earcut) and [earcut-python](https://github.com/joshuaskelly/earcut-python)
  - [polybooljs](https://github.com/velipso/polybooljs) and [pypolybool](https://github.com/KaivnD/pypolybool)
  - [polylabel](https://github.com/Twista/python-polylabel)
  - [pySTL](https://github.com/proverbialsunrise/pySTL)
  - A countless number of [StackOverflow](https://stackoverflow.com/) experts who answered various geometry questions
  - A countless number of [Wikipedia](https://www.wikipedia.org/) authors who described various geometry algorithms



  We initially debated whether the burden of geometry computation should be placed largely
  on the CAD environments in which Ladybug Tools operates or whether it should be included
  in a dedicated core Python library like this one.

  As we developed the core libraries, it became clear that there are large advantages
  to having it in the core including:

  1. Standardized compatibility of geometry between different CAD plugins (eg. Rhino, Revit), simulation engines (eg. E+, Radiance), and file formats (eg. gbXML, GEM).
  2. The ability to perform geometry operations from the core library CLI without the need for CAD software.
  3. Improved performance (since a dedicated library could be tailored to the use cases of Ladybug Tools).
  4. Reliability and maintain-ability in the face of changes to CAD environments and changing Python conventions.

  Items 1 and 4 above proved to be particularly important and so the decision was made
  that the Ladybug Tools core libraries would have its own geometry library that was
  distinct from CAD plugins.

  Before committing to write our own library, we looked into using or tweaking other
  comprehensive open source geometry libraries for the core including:

  - [Rhino3dm](https://github.com/mcneel/rhino3dm)
  - [Blender API (bpy)](https://docs.blender.org/api/current/)
  - [Boost Geometry](https://www.boost.org/doc/libs/1_78_0/libs/geometry/doc/html/index.html)
  - [Topologic](https://topologic.app/Software/)

  However, Rhino3dm lacks basic geometry computation. The Blender library had many capabilities
  but it only works in Python3 and this could break certain CAD workflows that rely on
  IronPython. Boost Geometry (the geometry library used by the OpenStudio SDK) also had a
  lot of functionality but it clearly has C dependencies, making it unusable from IronPython.
  Topologic also appeared to have C dependencies, though the most relevant issue was
  that its dual license could create challenges for certain use cases of Ladybug Tools.

  After considering the situation further, we realized that many of the capabilities that
  we needed could be achieved by building off the work of various open source MIT-licensed
  projects as long as we committed to using planar geometry. Since all of the geometry
  ultimately going to the engines (Radiance, E+) is planar, we made the decision that
  the core libraries will primarily support planar objects with no NURBS support and
  very limited support for Arcs, Circles, Spheres, Cylinders and Cones.

  Thus this repository was born!



  1. Clone this repo locally
  ```console
  git clone git@github.com:ladybug-tools/ladybug-geometry.git



  git clone https://github.com/ladybug-tools/ladybug-geometry.git
  ```

  2. Install dependencies:
  ```console
  cd ladybug-geometry
  pip install -r dev-requirements.txt
  pip install -r requirements.txt
  ```

  3. Run Tests:
  ```console
  python -m pytests tests/
  ```

  4. Generate Documentation:
  ```console
  sphinx-apidoc -f -e -d 4 -o ./docs ./ladybug_geometry
  sphinx-build -b html ./docs ./docs/_build/docs
  ```


pkgId: 05d06769b8fed1b335e2ac165c9fc1a38c1e3302d861bc954dec71d5a7b58357
name: python3-ldjcourse
arch: noarch
version: 0.0.8.6
epoch: 0
release: 1
url: https://pypi.org/project/ldjcourse/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ldjcourse-0.0.8.6-1.src.rpm
location_href: Packages/python3-ldjcourse-0.0.8.6-1.noarch.rpm
checksum_type: sha256
summary:
  本安装包由元蓝先生为教学专门构建，提供教学所需的工具和资源。元蓝先生活跃于B站，分享编程、数据分析和人工智能相关教学内容。链接：https://space.bilibili.com/3546564903569609


pkgId: 76ddd112ecab340f7252176401d3c955ab3fde8aa4f7c868ab9530ec1cd0bc31
name: python3-lesya
arch: noarch
version: 0.0.8
epoch: 0
release: 1
url: https://github.com/ustynov-py-dev/lesya.git
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-lesya-0.0.8-1.src.rpm
location_href: Packages/python3-lesya-0.0.8-1.noarch.rpm
checksum_type: sha256
summary:
  Python package to form Ukrainian names cases : 'Леся Українка' -- 'Лесі Українки' , 'Лесі Українці', 'Лесею Українкою' ... etc.

description:
  Lesya is a simple Python package for declining Ukrainian personal names into Ukrainian grammatical cases (_відмінки_): NOMINATIVE, GENITIVE, DATIVE, ACCUSATIVE, INSTRUMENTAL, PREPOSITIONAL, and VOCATIVE (_називний, родовий, давальний, знахідний, орудний, місцевий, кличний_).



  The most common usage is to convert a name into all cases:

  ```python
  from lesya import Lesya

  person = Lesya('Леся Українка')
  print(person.nominative) # Леся Українка
  print(person.genitive) # Лесі Українки
  print(person.dative) # Лесі Українці
  print(person.accusative) # Лесю Українку
  print(person.instrumental) # Лесею Українкою
  print(person.prepositional) # Лесі Українці
  print(person.vocative) # Лесе Українко
  ```

  When printing the `Lesya` object, you will get just nominative case:

  ```python
  person = Lesya('Дмитро Андрійович Устинов')
  print(person) # Дмитро Андрійович Устинов
  ```


  You can also get a name in a specific case with square brackets:

  ```python
  from lesya import Lesya
  from lesya import CaseUA

  person = Lesya('Тарас Григорович Шевченко')
  print(person[CaseUA.DATIVE]) # Тарасу Григоровичу Шевченку
  print(person[CaseUA.PREPOSITIONAL]) # Тарасові Григоровичу Шевченкові
  print(person['орудний']) # Тарасом Григоровичем Шевченком
  ```



  Lesya works well with double last names:

  ```python
  from lesya import Lesya

  person = Lesya('Іван Семенович Нечуй-Левицький')
  print(person.forms)

  {
      'називний': 'Іван Семенович Нечуй-Левицький',
      'родовий': 'Івана Семеновича Нечуя-Левицького',
      'давальний': 'Івану Семеновичу Нечуєві-Левицькому',
      'знахідний': 'Івана Семеновича Нечуя-Левицького',
      'орудний': 'Іваном Семеновичем Нечуєм-Левицьким',
      'місцевий': 'Іванові Семеновичу Нечуєві-Левицькому',
      'кличний': 'Іване Семеновичу Нечую-Левицький'
  }
  ```



  You can get all cases at once using the forms attribute. It returns a dictionary where the keys are case names (in lowercase Ukrainian), and the values are the corresponding declined names.



  Lesya supports foreign names. However, since it does not use an ML model to automatically detect a person's gender, it works better if you explicitly provide the gender:

  ```python
  from lesya import Lesya
  from lesya import CaseUA
  from lesya import Gender

  person = Lesya('Джозеф Байден', gender='male')
  print(person[CaseUA.DATIVE]) # Джозефу Байдену
  print(person[CaseUA.PREPOSITIONAL]) # Джозефові Байденові

  person = Lesya('Камала Гаріс', gender=Gender.FEMALE)
  print(person[CaseUA.DATIVE]) # Камалі Гаріс
  print(person[CaseUA.PREPOSITIONAL]) # Камалі Гаріс
  ```

rpm_license:
  Copyright (c) 2024 Dmytro Ustynov  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: 781d54190fbe4beea4c46bbcd4e216e712e37d21fa8ea0f189a2a1c9d5d11a0f
name: python3-licofage
arch: aarch64
version: 0.9
epoch: 0
release: 1
url: https://pypi.org/project/licofage/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-licofage-0.9-1.src.rpm
location_href: Packages/python3-licofage-0.9-1.aarch64.rpm
checksum_type: sha256
summary:
  Generate deterministic finite automata associated to linear equations expressed in the numeration system associated to a given substitution.

description:
  licofage is a tool designed to enhance the accessiblity of the scientific paper *Addition in Dumont-Thomas Numeration Systems in Theory and Practice*. The authors of the paper are O. Carton, JM. Couvreur, M. Delacourt and N. Ollinger.

  The implentation is a prototype of a method for generating deterministic finite automata associated with linear equations expressed in the numeration system associated with a given substitution.

  Once the installation of the package is complete, the `licofage` command-line tool may be invoked.

  The command `licofage -h` provides comprehensive invocation coverage.


pkgId: 1ba210eba763326d31401d1ea1fc0bc10ae1d89a6f38d7b35fa9f08943be75a2
name: python3-litestar-msgspec
arch: aarch64
version: 0.19.0
epoch: 0
release: 1
url: https://jcristharif.com/msgspec/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-litestar-msgspec-0.19.0-1.src.rpm
location_href: Packages/python3-litestar-msgspec-0.19.0-1.aarch64.rpm
checksum_type: sha256
summary:
  A fast serialization and validation library, with builtin support for JSON, MessagePack, YAML, and TOML.

description:
  `msgspec` may be used for serialization alone, as a faster JSON or
  MessagePack library. For the greatest benefit though, we recommend using
  `msgspec` to handle the full serialization & validation workflow:
  **Define** your message schemas using standard Python type annotations.
  ```python
  >>> import msgspec
  >>> class User(msgspec.Struct):
  ```
  **Encode** messages as JSON, or one of the many other supported protocols.
  ```python
  >>> alice = User("alice", groups={"admin", "engineering"})
  >>> alice
  User(name='alice', groups={"admin", "engineering"}, email=None)
  >>> msg = msgspec.json.encode(alice)
  >>> msg
  b'{"name":"alice","groups":["admin","engineering"],"email":null}'
  ```
  **Decode** messages back into Python objects, with optional schema validation.
  ```python
  >>> msgspec.json.decode(msg, type=User)
  User(name='alice', groups={"admin", "engineering"}, email=None)
  >>> msgspec.json.decode(b'{"name":"bob","groups":[123]}', type=User)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  msgspec.ValidationError: Expected `str`, got `int` - at `$.groups[0]`
  ```
  `msgspec` is designed to be as performant as possible, while retaining some of
  the nicities of validation libraries like
  [pydantic](https://pydantic-docs.helpmanual.io/). For supported types,
  encoding/decoding a message with `msgspec` can be
  [~10-80x faster than alternative libraries](https://jcristharif.com/msgspec/benchmarks.html).
  <p align="center">
    <a href="https://jcristharif.com/msgspec/benchmarks.html">
      <img src="https://raw.githubusercontent.com/jcrist/msgspec/main/docs/source/_static/bench-validation.svg">
    </a>
  </p>
  See [the documentation](https://jcristharif.com/msgspec/) for more information.

  New BSD. See the
  [License File](https://github.com/jcrist/msgspec/blob/main/LICENSE).


pkgId: 3b27191fed1604e8d7a6a8f538c41af48c2367d5e8f945ff195ab2823250fa37
name: python3-logicbank
arch: noarch
version: 1.20.10
epoch: 0
release: 1
url: https://github.com/valhuber/logicbank
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-logicbank-1.20.10-1.src.rpm
location_href: Packages/python3-logicbank-1.20.10-1.noarch.rpm
checksum_type: sha256
summary:
  Declare multi-table rules for SQLAlchemy update logic -- 40X more concise, Python for extensibility.

description:
  Logic Bank governs SQLAlchemy
  update transaction logic - multi-table derivations, constraints,
  and actions such as sending mail or messages. Logic consists of both:

  * **Rules - 40X** more concise
  using a spreadsheet-like paradigm, and

  * **Python - control and extensibility,**
  using standard tools and techniques

  > The example described below is a _typical_ example of multi-table logic.
  >
  > You may find it helpful to begin with [this Tutorial, using a basic example](../../wiki/Tutorial).
  >
  >
  > **Update - Jan 26, 2021:** You can use LogicBank for your own _existing_ projects.  For _new_ projects, the recommended approach is [**ApiLogicServer**](https://github.com/valhuber/ApiLogicServer#readme) - create a complete logic-enabled JSON:API for your database, and a admin app, with 1 command.

  This readme contains:

  1. [Background](#background)
      * [Why](#why---simple-cocktail-napkin-spec-explodes-into-massive-legacy-code) - problems addressed
      * [What](#what---declare-spreadsheet-like-rules---40x-more-concise) - what are spreadsheet-like rules
      * [How](#how---usage-and-operation-overview) - usage / operation overview
      * [Logic Execution](#logic-execution-add-order---watch-react-chain) - sample transaction execution, reuse and scalability
      * [Instant Web App](#an-agile-perspective) - built using [Flask App Builder Quickstart](https://github.com/valhuber/fab-quick-start/wiki)
  1. [Install Instructions](#installation) - of Python and Logic Bank, with verify and run instructions
  1. [Project Information](#project-information)






  If you've coded backend database logic - multi-table derivations and constraints -
  you know how much work it is, and how tedious.  Whether you code it in
  triggers and stored procedures, in ORM events, or UI controllers, it's a lot:
  typically nearly half the effort for a database project.

  It's also incredibly repetitive - you often get the feeling you're doing the same thing over and over.

  And you're right.  It's because backend logic follows patterns of "what" is supposed to happen.
  And your code is the "how".  Suddenly, a simple cocktail napkin specification explodes into a massive amount of legacy code:

  <figure><img src="https://github.com/valhuber/LogicBank/blob/main/images/overview/rules-vs-code.png?raw=true"></figure>

  Logic Bank was designed to make the cocktail napkin spec _executable_.


  Logic Bank introduces rules that are 40X more concise than legacy code.
  The 5 rules below (lines 40-49) express the same logic as 200 lines of code [**(see them here)**](examples/nw/logic/legacy).  That's because rules are all about "what"
  -- spreadsheet-like expressions that automate the tedious "how":

  <figure><img src="https://github.com/valhuber/LogicBank/blob/main/images/overview/cocktail-logic-bank.png?raw=true"></figure>


  Logic Bank is fully integrated with Python:
  * **Declare** rules in Python as shown above (more details in How, below)
  * **Extend** rules with Python (rule on line 51 invokes the Python function on line 32)
  * **Manage** logic using your existing IDE (PyCharm, VSCode etc for code completion, debugging, etc),
  and source control tools and procedures


  40X is... _large_ - do these results hold in practice?
  See [here](../../wiki#technology-evaluation) for
  additional background, and real world experience.



  <figure><img src="https://github.com/valhuber/LogicBank/blob/main/images/architecture.png?raw=true"></figure>
  Logic Bank operates as shown above:

   1. **Declare and Activate** (see example above):

      a. Create a ```declare_logic``` function (above, line 12),
      and declare your rules using ```Rule.``` (e.g., with IDE code completion)

      b. After opening your database, call ```activate```
      to register your rules, and establish Logic Bank as
      a listener for SQLAlchemy ```before_flush``` events


   2. Your application operates as usual: makes calls on `SQLAlchemy` for inserts, updates and deletes
      and issues `session.commit()`

      - By bundling transaction logic into SQLAlchemy data access, your logic
    is automatically shared, whether for hand-written code (Flask apps, APIs)


   3. The **Logic Bank** engine handles SQLAlchemy `before_flush` events on
  `Mapped Tables`, so executes when you issue ```session.commit()```


   4. The logic engine operates much like a spreadsheet:
      - **watch** for changes at the attribute level
      - **react** by running rules that referenced changed attributes, which can
      - **chain** to still other attributes that refer to
  _those_ changes.  Note these might be in different tables,
  providing automation for _multi-table logic_

  Logic does not apply to updates outside SQLAlchemy,
  nor to SQLAlchemy batch updates or unmapped sql updates.

  Let's see how logic operates on a typical, multi-table transaction.



  <figure><img src="https://github.com/valhuber/LogicBank/blob/main/images/check-credit.png?raw=true"></figure>


  The `add_order` example illustrates how
  __Watch / React / Chain__ operates to
  check the Credit Limit as each OrderDetail is inserted:

  1.  The `OrderDetail.UnitPrice` (copy, line 49) references Product, so inserts cause it to be copied

  2.  `Amount` (formula, line 48) watches `UnitPrice`, so its new value recomputes `Amount`

  3.  `AmountTotal` (sum, line 46) watches `Amount`, so `AmountTotal` is adjusted (more on adjustment, below)

  4.  `Balance` (sum, line 43) watches `AmountTotal`, so it is adjusted

  5.  And the Credit Limit constraint (line 40) is checked (exceptions are raised if constraints are violated, and the transaction is rolled back)

  All of the dependency management to see which attributes have changed,
  logic ordering, the SQL commands to read and adjust rows, and the chaining
  are fully automated by the engine, based solely on the rules above.


  Just as a spreadsheet reacts
  to inserts, updates and deletes to a summed column,
  rules automate _adding_, _deleting_ and _updating_ orders.
  This is how 5 rules represent the same logic as 200 lines of code.

  Check out more examples:
  * [**Ship Order**](../../wiki/Ship-Order) illustrates *cascade*, another form of multi-table logic
  * [**Banking**](../../wiki/Sample-Project---Banking) is a complex transaction using the command pattern


  Scalability requires more than clustering - SQLs must be pruned
  and optimized.  For example, the balance rule:
  * is **pruned** if only a non-referenced column is altered (e.g., Shipping Address)
  * is **optimized** into a 1-row _adjustment_ update instead of an
  expensive SQL aggregate

  For more on how logic automates and optimizes multi-table transactions,
  [click here](../../wiki#scalability-automatic-pruning-and-optimization).



  The core tenant of agile is

      Working software, driving collaboration, for rapid iterations

  Here's how rules can help.


  The examples above illustrate how just a few rules can replace
  [pages of code](examples/nw/logic/legacy).



  Rules are _self-ordering_ - they recognize their interdependencies,
  and order their execution and database access (pruning, adjustments etc)
  accordingly.  This means:

  * order is independent - you can state the rules in any order
  and get the same result

  * maintenance is simple - just make changes, additions and deletions,
  the engine will reorganize execution order and database access, automatically



  First, follow the instructions to verify / install Python, then install Logic Bank.



  The first section below verifies whether your Python environment is current.
  The following section explains how to install a current Python environment.


  Ensure you have these pre-reqs:
  ```
  python --version


  pip --version


  pyenv --version

  ```

  If you are missing any, install them as described here.  Skip this step if your pre-reqs are fine.

  To install Python:

  * Python3.8

     * Run the windows installer
        * Be sure to specify "add Python to Path"
     * On mac/Unix, consider [using homebrew](https://brew.sh/), as described
  [here](https://opensource.com/article/19/5/python-3-default-mac#what-to-do)

  * virtualenv - see [here](https://www.google.com/url?q=https%3A%2F%2Fpackaging.python.org%2Fguides%2Finstalling-using-pip-and-virtual-environments%2F%23creating-a-virtual-environment&sa=D&sntz=1&usg=AFQjCNEu-ZbYfqRMjNQ0D0DqU1mhFpDYmw)  (e.g.,  `pip install virtualenv`)
     * on PC, see [these instructions](https://pypi.org/project/pyenv-win/)

  * An IDE - optional - any will do (I've used [PyCharm](https://www.jetbrains.com/pycharm/download) and [VSCode](https://code.visualstudio.com), install notes [here](https://github.com/valhuber/fab-quick-start/wiki/IDE-Setup)), though different install / generate / run instructions apply for running programs.

  Issues?  [Try here](https://github.com/valhuber/fab-quick-start/wiki/Mac-Python-Install-Issues).



  This procedure installs the Logic Bank source code, including
  examples you can explore.

  > To use Logic Bank in your own project: `pip install LogicBank`

  In your IDE or Command Line:

  ```

  git clone https://github.com/valhuber/LogicBank.git
  cd LogicBank

  virtualenv venv

  source venv/bin/activate
  pip install -r requirements.txt
  ```
  > **Warning -** if you just download the zip, *be sure* to remove the hyphen from the name.

  > **Warning -** if you use an IDE, be sure to activate the virtual environment, and verify you are running a proper version of Python.




  Run the `nw/tests` programs under your IDE or the
  command line; start with `test_add_order` and `test_upd_order_shipped,`
  and see the [walk-throughs here](../../wiki/home#logic-execution-watch-react-chain).
  The tests use ```unittest``` - you can run them as follows:

  ```
  cd examples/nw/tests
  python -m unittest test_add_order.py
  python test_add_order.py  # or, run it like this

  python -m unittest discover -p "test*.py"  # run all tests
  ```

  > Note: the console **log** depicts logic execution
  >
  > Log lines are long - consider copying them to a text
  > editor to view with / without word wrap
  >
  > Or, run in an IDE - they look [like this](../../wiki/home#debugging-standard-debugger-logic-logging).





  First, run the [**10 minute Tutorial**](../../wiki/Tutorial).
  You will see how to create, run and debug a rule in a simple, running example.



  Then, check out the [**Examples**](../../wiki/Examples) - note the **navigation bar** on the right.  Key samples:
  * [**Ship Order**](../../wiki/Ship-Order) illustrates *cascade*, another form of multi-table logic
  * [**Allocation**](../../wiki/Sample-Project---Allocation) illustrates *extensibility*,
  providing a reusable pattern for a *provider* to allocate
  to a set of *recipients*
  * [**Banking**](../../wiki/Sample-Project---Banking) is a complex transaction using the command pattern
  * [**Referential Integrity**](../../wiki/Referential-Integrity) illustrates referential integrity support


  A good way to proceed is to
  * Clear the log
  * Run the test
  * Review the log, and the rules that drove the processing



  There a few articles that provide some orientation to Logic Bank:
  * [Extensible Rules](https://dzone.com/articles/logic-bank-now-extensible-drive-95-automation-even) - defining new rule types, using Python
  * [Declarative](https://dzone.com/articles/agile-design-automation-how-are-rules-different-fr) - exploring _multi-statement_ declarative technology
  * [Automate Business Logic With Logic Bank](https://dzone.com/articles/automate-business-logic-with-logic-bank) - general introduction, discussions of extensibility, manageability and scalability
  * [Agile Design Automation With Logic Bank](https://dzone.com/articles/logical-data-indendence) - focuses on automation, design flexibility and agile iterations



  The `Logic Bank Examples` [(setup instructions here)](../../wiki/Sample-Project---Setup)
  contains the same examples, but _not_ the `logic_bank` engine source code.
  It uses the logic engine via `pip install`, as you would for your own projects:

  ```
  pip install logicbank
  ```
  > This is **not required here**, and requires the same
  > pre-reqs noted above







  [Revisions](https://github.com/valhuber/LogicBank/wiki/Summary,-Update-History) are described here.



  <figure><img src="https://github.com/valhuber/LogicBank/blob/main/images/logic-bank-project.png?raw=true"></figure>

  Logic Bank consists of:

  * Several test database systems - `nw,`  `banking`,
    `referential_integrity` and `payment_allocation`;
  these contain

      * [Databases](examples/nw/db) sqlite (no install required) and models

      * [Test folders](examples/nw/tests) that run key transactions - just run the scripts
  (note the logs)

      * [Logic](examples/nw/logic) - rules (and for `nw`,
      the manual `legacy` code for contrast to rules)

  * The `nw` sample illustrates comparisons of Business logic, both
  [by code](examples/nw/logic/legacy) and by rules (shown above).

  * The `logic_bank` engine source code




  To explore:

  * Click [here](../../wiki/Explore-Logic-Bank)
      for install / operations procedures

  * Click [here](../../wiki/Logic-Walkthrough) for a
      short overview of internal logic execution


  There are many to thank:
  * Tyler Band, for testing and the Banking example
  * Max Tardiveau, for testing
  * Nishanth Shyamsundar, for PC testing
  * Michael Holleran, for collaboration
  * Mike Bayer, for suggestions on leveraging Python typing and remarkable responsiveness
  * Achim Götz, for reporting an issue in FAB Quick Start use of Logic Base
  * Gloria, for many reviews... and golden patience


pkgId: 7242a6e2780a85ad7adc58fa43ea463a586b1872f3bebd1c0b4abbcfa51ad529
name: python3-magi-cli-pypi
arch: noarch
version: 1.0.2
epoch: 0
release: 1
url: https://github.com/bobbyhiddn/Magi_CLI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-magi-cli-pypi-1.0.2-1.src.rpm
location_href: Packages/python3-magi-cli-pypi-1.0.2-1.noarch.rpm
checksum_type: sha256
summary:
  Magi_CLI is a command line interface for those who desire software development to feel more like magic.

description:
  ![banner](MAGI_Keys.png)

  > "Any sufficiently advanced technology is indistinguishable from magic."
  > *― Arthur C. Clarke*

  Embrace the arcane with Magi CLI, a spellcasting-inspired command line interface (CLI) tool that fuses the mystical arts with practical utility. Unravel the secrets of the cosmos and command your operating system with the wisdom of the ancient magi.



  Magi CLI is forged in Python, channeling the enigmatic power of the Click library. It offers an array of spells (commands) that manipulate the filesystem, manage files, and automate tasks. Designed to be extendable, Magi CLI allows you to add new spells as your knowledge of the hidden arts expands. While platform agnostic, it performs best with a bash terminal like Git Bash.




  Your magical workspace contains:
  - `.tome/`: Storage for spell bundles
  - `.orb/`: Local spell cache
  - `.graveyard/`: Temporary storage for deleted files
  - `.runes/`: GUI elements for spell execution


  The root command serving as the universal execution command. It displays all available spells and `.spell` files in your tome when run without arguments. Currently supports:
  - Python scripts (.py)
  - Shell scripts (.sh)
  - Spell bundles (.spell)



  - **Effectiveness**: Spells must work reliably. Half-functioning spells won't be included in release versions.
  - **Flavorfulness**: Spells should feel magical, requiring only essential memorization unless additional features can be added in a thematic way.
  - **Modularity**: Each spell must work both as `cast spell target` and as a standalone script (`python path/to/spell.py target`).
  - **Innovation**: Spells should not duplicate standard UNIX commands. We're crafting new magic, not recreating existing tools.
  - **Fun**: Keep the magical essence alive with thematic messages and interactions!




  - **Fireball** (`fb`): Transmute a file or directory into ashes, sending it to the '.graveyard' realm
  - **Banish** (`bn`): Move files to a temporary exile realm
  - **Divine** (`dv`): Display detailed file/directory information


  - **Necromancy** (`nc`): Initialize the .graveyard for file preservation
  - **Raise_Dead** (`rd`): Restore files from the .graveyard


  - **Spellcraft** (`sc`): Create new spells and spell bundles
  - **Ponder** (`pd`): Explore and manage available spells. Connect to the Chamber for additional community spells.

  Additional spells are available through the Magi Chamber (`magi-chamber.fly.dev`), accessible via the `ponder` spell.



  Spellcraft (`sc`) is a powerful tool for creating new spells. It supports three main types of spell creation:


  Create spells that combine multiple commands:
  ```bash

  cast sc 3 backup_spell
  ```
  The wizard will prompt you for:
  - Spell description
  - Three commands to be executed in sequence


  Convert existing Python or Shell scripts into spells:
  ```bash

  cast sc path/to/script.py spell_name


  cast sc path/to/script.sh spell_name
  ```


  Create complex spells with multiple files and resources using YAML configuration:

  ```yaml

  name: my_spell
  description: A powerful new spell
  type: bundled
  shell_type: python
  entry_point: spell/main.py
  dependencies:
    python:
      - requests>=2.0.0

  code: |
    import click

    @click.command()
    def main():
        """Your spell's magic here."""
        click.echo("Spell cast successfully!")

  artifacts:
    - path: data/config.json
      content: |
        {
          "settings": "value"
        }
  ```

  Create the bundled spell:
  ```bash
  cast sc spell.yaml
  ```




  ```bash
  pip install magi-cli-pypi
  ```


  ```bash
  git clone https://github.com/bobbyhiddn/Magi_CLI.git
  cd Magi_CLI
  pip install .
  ```



  ```mermaid
  stateDiagram-v2
      state "cast" as entry

      state "Command Handling" as commands {
          SpellParser
          CommandRegistry
      }

      state "Executable Types" as types {
          state ".py files" as py
          state ".sh files" as sh
          state ".spell bundles" as bundle
      }

      state "Spellcraft System" as craft {
          state "SpellBundle" as sb {
              LoadConfig
              CreateBundle
          }

          state "Sigildry" as sig {
              GenerateHash
              GenerateSVG
              VerifySigil
          }
      }

      state "~/.sanctum" as sanctum {
          .tome
          .orb
          .graveyard
      }

      entry --> commands
      commands --> types
      bundle --> craft
      craft --> sanctum
      types --> sanctum
  ```


  - Spells are verified using sigils (cryptographic signatures)
  - Dependencies are installed in isolated environments
  - Spell bundles are checked for integrity before execution


  See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.


  MIT License


  Created and maintained by Micah Longmire (@bobbyhiddn)


pkgId: 69679f4765fa5c3129b8a74879bd60e92547ca7df0ddefa5e258ce542bf0a033
name: python3-max
arch: noarch
version: 0.0.1
epoch: 0
release: 1
url: https://pypi.org/project/max/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-max-0.0.1-1.src.rpm
location_href: Packages/python3-max-0.0.1-1.noarch.rpm
checksum_type: sha256
summary:
  Temporary placeholder package future releases of the Modular MAX SDK on PyPI which is currently only avalaible as a conda package.

description:
  Notice: This package is temporary placeholder for future releases of the Modular
  MAX SDK on PyPI. Today MAX is currently avalaible as a conda package.

  Learn more about MAX at: <https://www.modular.com/max>



  ![Modular GitHub Logo](https://modular-assets.s3.amazonaws.com/images/modular_github_logo_bg.png)

  The Modular Accelerated Xecution ([MAX](https://www.modular.com/max)) platform
  is an integrated suite of AI libraries, tools, and technologies that unifies
  commonly fragmented AI deployment workflows. MAX accelerates time to market
  for the latest innovations by giving AI developers a single toolchain that
  unlocks full programmability, unparalleled performance, and seamless hardware portability.

  ![Modular Architecture Diagram](https://modular-assets.s3.amazonaws.com/images/modular_architecture_diagram_bg.png)

  [See here to get started with MAX](https://docs.modular.com/max/get-started)
  and when you want to report issues or request features,
  [please create a GitHub issue here](https://github.com/modularml/max/issues/new/choose).

  The [Discord](https://discord.gg/modular) community is the best place to share
  your experiences and chat with the team and other community members.


pkgId: 6008c211a4ca524344bdfba30f5b2f2a8121f8c9a4440393c69b2d6f74471ee4
name: python3-metrx
arch: noarch
version: 0.0.0
epoch: 0
release: 1
url: https://pypi.org/project/metrx/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-metrx-0.0.0-1.src.rpm
location_href: Packages/python3-metrx-0.0.0-1.noarch.rpm
checksum_type: sha256
summary:
  "A library containing a collection of distance and similarity measures to compare time series data. Coming soon!"


pkgId: 349f5c0b744c34d3f2a582970b161e2e90bb97ef5f0cbac88ea74e0c5174e609
name: python3-mlba
arch: noarch
version: 2.0.2
epoch: 0
release: 1
url: https://github.com/gedeck/mlba-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlba-2.0.2-1.src.rpm
location_href: Packages/python3-mlba-2.0.2-1.noarch.rpm
checksum_type: sha256
summary:
  Utility functions for 'Machine Learning for Business Analytics: Concepts, Techniques, and Applications in Python' (2nd edition)

description:
  [![PyPI](https://badge.fury.io/py/mlba.svg)](https://pypi.org/project/mlba/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/mlba)](https://pypi.org/project/mlba/)
  ![Python](https://github.com/gedeck/mlba-python/actions/workflows/build.yml/badge.svg)



  Collection of utility functions used in the book

  > _Machine Mining for Business Analytics: Concepts, Techniques, and Applications in Python_ (Second Edition)
  > Galit Shmueli, Peter C. Bruce, Peter Gedeck, and Nitin R. Patel
  > (c) 2025 John Wiley & Sons, Inc.

  Code for the book and the used datasets are available on https://www.dataminingbook.com/book/python-edition.



  Use `pip` to install the `mlba` package from pypi (https://pypi.org/project/mlba/).
  ```
  pip install mlba
  ```
  Should this not work, for example when you are behind a firewall, download the package from pypi and install from file, e.g.
  ```
  pip install mlba-2.0.tar.gz
  ```


pkgId: 50c6f62243df63418cff55a02c98e749ef8ebd1773b71124b5731fbccd7af8e0
name: python3-mlipdockers
arch: noarch
version: 0.0.5
epoch: 0
release: 1
description: Install: `pip install mlipdockers`
url: https://github.com/HouGroup/ys_mlipdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-mlipdockers-0.0.5-1.src.rpm
location_href: Packages/python3-mlipdockers-0.0.5-1.noarch.rpm
checksum_type: sha256
summary:
  Request to docker containers in which the python enviroments for different machine learning potential usages are implemented. Using this package, one can get the predicted potential energy for any structure using any MLIP without needing to change python environments.


