# packages

pkgId: 5e39b169eb67b09bf40dbfee76e651c0539aafb36369874b22d367e8d25806e7
name: python-superqt-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for superqt
url: https://pypi.org/project/superqt/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-superqt-0.7.0-1.src.rpm
location_href: Packages/python-superqt-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/pypi/l/superqt.svg?color=green)](https://github.com/pyapp-kit/superqt/raw/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/superqt.svg?color=green)](https://pypi.org/project/superqt)
  [![Python
  Version](https://img.shields.io/pypi/pyversions/superqt.svg?color=green)](https://python.org)
  [![Test](https://github.com/pyapp-kit/superqt/actions/workflows/test_and_deploy.yml/badge.svg)](https://github.com/pyapp-kit/superqt/actions/workflows/test_and_deploy.yml)
  [![codecov](https://codecov.io/gh/pyapp-kit/superqt/branch/main/graph/badge.svg?token=dcsjgl1sOi)](https://codecov.io/gh/pyapp-kit/superqt)



  This repository aims to provide high-quality community-contributed Qt widgets and components for PyQt & PySide
  that are not provided in the native QtWidgets module.

  Components are tested on:

  - macOS, Windows, & Linux
  - Python 3.9 and above
  - PyQt5 (5.11 and above) & PyQt6
  - PySide2 (5.11 and above) & PySide6



  Documentation is available at https://pyapp-kit.github.io/superqt/



  superqt provides a variety of widgets that are not included in the native QtWidgets module, including multihandle (range) sliders, comboboxes, and more.

  See the [widgets documentation](https://pyapp-kit.github.io/superqt/widgets) for a full list of widgets.

  - [Range Slider](https://pyapp-kit.github.io/superqt/widgets/qrangeslider/) (multi-handle slider)

  <img src="https://raw.githubusercontent.com/pyapp-kit/superqt/main/docs/images/demo_darwin10.png" alt="range sliders" width=680>

  <img src="https://raw.githubusercontent.com/pyapp-kit/superqt/main/docs/images/labeled_qslider.png" alt="range sliders" width=680>

  <img src="https://raw.githubusercontent.com/pyapp-kit/superqt/main/docs/images/labeled_range.png" alt="range sliders" width=680>



  superqt includes a number of utilities for working with Qt, including:

  - tools and decorators for working with threads in qt.
  - `superqt.fonticon` for generating icons from font files (such as [Material Design Icons](https://materialdesignicons.com/) and [Font Awesome](https://fontawesome.com/))

  See the [utilities documentation](https://pyapp-kit.github.io/superqt/utilities/) for a full list of utilities.



  We welcome contributions!

  Please see the [Contributing Guide](CONTRIBUTING.md)


pkgId: 97ac08d87bfc38b9b903c5f0af2088580279ae52acff022f4b9b2b63129b91b0
name: python-supersonic-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for supersonic
url: https://pypi.org/project/supersonic/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-supersonic-0.1.0-1.src.rpm
location_href: Packages/python-supersonic-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Rock-solid GitHub PR automation for modern applications. Supersonic provides a high-level API for programmatically creating and managing Pull Requests, designed specifically for AI and SaaS applications that need to propose changes to user repositories.



  - [Why Supersonic?](#why-supersonic)
  - [Features](#features)
  - [Installation](#installation)
  - [Quick Start](#quick-start)
    - [Easiest Start](#easiest-start)
    - [Update Single File](#update-single-file)
    - [Update Multiple Files](#update-multiple-files)
    - [Using the CLI (experimental)](#using-the-cli-experimental)
  - [Pull Request Configuration](#pull-request-configuration)
    - [Basic Usage](#basic-usage)
    - [Using PRConfig](#using-prconfig)
    - [Enterprise Usage](#enterprise-usage)
  - [Configuration](#configuration)
    - [Full Configuration Options](#full-configuration-options)
    - [Environment Variables](#environment-variables)
  - [Use Cases](#use-cases)
    - [AI-Powered Code Improvements](#ai-powered-code-improvements)
    - [Automated Documentation Updates](#automated-documentation-updates)
    - [Configuration Management](#configuration-management)
  - [Development](#development)
    - [Setup](#setup)
    - [Code Style](#code-style)
  - [License](#license)




  Modern AI and SaaS applications often need to propose changes to user repositories—whether it's AI-suggested improvements, automated documentation updates, or configuration changes. However, creating Pull Requests programmatically through the GitHub API can be complex and error-prone.

  Supersonic solves this:

  - **Simple, High-Level API**: Create PRs with a single function call, using files or plain text content
  - **Safe Defaults**: All changes are created as PRs, allowing users to review before merging
  - **Enterprise Ready**: Full support for GitHub Enterprise and custom base URLs
  - **Async by Default**: Built for high-performance services that need to handle multiple PR creations
  - **Excessively customizable**: Full control over PR creation, set draft mode, reviewers, labels, etc.
  - **Best for apps, useful for scripts too**: Plug it into your SaaS app and delight your users. Or automate internal workflows.

  Common use cases:
  - AI applications suggesting code improvements
  - Documentation generators keeping docs in sync with code
  - Configuration management tools proposing config updates
  - Any service that needs to propose changes to user repositories

  We use this at [Cased](https://cased.com) to support our DevOps automations.



  ```bash

  uv pip install supersonic


  git clone https://github.com/cased/supersonic
  cd supersonic
  uv venv
  source .venv/bin/activate
  uv pip install -r requirements-dev.txt
  uv pip install -e .
  ```





  First an idea of what Supersonic can do.

  Say you just want to create a PR to update a file—here's the simplest way:

  ```python
  from supersonic import Supersonic

  supersonic = Supersonic("your-github-token")


  pr_url = await supersonic.create_pr_from_content(
      repo="user/repo",
      content="print('hello world')",
      path="hello.py"
  )

  print(f"Created PR: {pr_url}")
  ```


  `supersonic` will automatically create a branch, create a PR with changes to the upstream file called `hello.py`,
  and return the PR URL. In this case, it will also automatically generate a simple title and description for the PR.
  You'll probably want more customization, or to use files instead of strings to generate the PR—so read on.



  Sometimes you just want to update a single file and create a PR for it. You can either provide the content directly as a string,
  or point to a local file that contains the changes:

  ```python

  pr_url = await supersonic.create_pr_from_content(
      repo="user/repo",
      content="print('hello')",
      path="src/hello.py",
      title="Add hello script",  # Optional
      description="Adds a simple hello world script",  # Optional
      draft=False,  # Optional, create as draft PR
      labels=["enhancement"],  # Optional labels
      reviewers=["username"]  # Optional reviewers
  )


  pr_url = await supersonic.create_pr_from_file(
      repo="user/repo",
      local_file_path="local/config.json",
      upstream_path="config/settings.json",
      title="Update configuration",  # Optional
      base_branch="develop"  # Optional, customize target branch
  )
  ```



  Need to update several files at once? Maybe you're updating configuration files across multiple services,
  or generating documentation for multiple endpoints? The `update_files` method lets you batch changes together. In `files`, pass a dictionary of upstream file paths as keys, and content strings as values:

  ```python

  pr_url = await supersonic.create_pr_from_files(
      repo="user/repo",
      files={
          "config/settings.json": '{"debug": true}',
          "README.md": "# Updated Docs\n\nNew content here"
      },
      title="Update configuration and docs",  # Optional
      description="""
      This PR includes two changes:
      1. Updated debug settings
      2. Refreshed documentation
      """,  # Optional
      labels=["config", "docs"],  # Optional
      reviewers=["tech-lead", "docs-team"]  # Optional
  )
  ```



  All the same functionality is available through the command line interface, which is experimental.
  This is great for scripts or when you want to quickly create PRs without writing code:

  ```bash

  supersonic --token ghp_xxx update-content user/repo "print('hello')" src/hello.py \
    --title "Add hello script" \
    --description "Adds a hello world script" \
    --reviewers username1,username2


  supersonic --token ghp_xxx update user/repo config.json config/settings.json \
    --title "Update configuration" \
    --labels config,automated


  supersonic --token ghp_xxx update-files user/repo \
    -f '{"debug": true}' config/settings.json \
    -f "# Title" README.md \
    --title "Update configs and docs" \
    --draft  # Create as draft PR
  ```





  ```python

  pr_url = await supersonic.update_content(
      repo="user/repo",
      content="print('hello')",
      path="src/hello.py",
      title="Add hello script",
      description="Adds a hello world script",
      base_branch="main",
      draft=False,
      labels=["enhancement"],
      reviewers=["username"]
  )
  ```



  For more control and reusability, use the PRConfig class:

  ```python
  from supersonic import PRConfig

  config = PRConfig(
      title="Update configuration",  # Optional, defaults to "Automated changes"
      description="""
      This PR updates the configuration file with new settings.

      Changes:
      - Updated API endpoints
      - Added new feature flags
      """,  # Optional, supports markdown
      base_branch="main",
      draft=False,
      labels=["automated"],
      reviewers=["user1", "user2"],
      team_reviewers=["team1"],
      merge_strategy="squash",  # "merge", "squash", or "rebase"
      delete_branch_on_merge=True,
      auto_merge=False
  )

  pr_url = await supersonic.create_pr(
      repo="user/repo",
      changes={"config.json": new_config_content},
      config=config
  )
  ```



  ```python
  supersonic = Supersonic({
      "github_token": "your-token",
      "base_url": "https://github.your-company.com/api/v3",
      "app_name": "your-tool",
      "default_pr_config": {
          "base_branch": "main",
          "draft": False,
          "labels": ["automated"],
          "merge_strategy": "squash",
          "delete_branch_on_merge": True
      }
  })
  ```





  You can optionally use a configuration dictionary when creating a `Supersonic` instance.
  Only the GitHub token is required, and there are many options.

  ```python
  config = {
      
      "github_token": "your-token",

      
      "base_url": "https://api.github.com",  # For GitHub Enterprise
      "app_name": "your-app-name",

      
      "default_pr_config": {
          "title": "Automated Update",  # Optional
          "description": "Changes proposed by Supersonic",  # Optional
          "base_branch": "main",
          "draft": False,
          "labels": ["automated"],
          "reviewers": [],
          "team_reviewers": [],
          "auto_merge": False,
          "merge_strategy": "squash",
          "delete_branch_on_merge": True
      }
  }

  supersonic = Supersonic(config)
  ```



  Supersonic looks for these environment variables:
  - `GITHUB_TOKEN`: GitHub API token





  Perfect for AI applications that suggest code improvements. Supersonic makes it easy to turn AI suggestions into pull requests:

  ```python
  async def handle_improvement_request(repo: str, file_path: str, user_prompt: str):
      
      improved_code = await ai.improve_code(user_prompt)

      
      supersonic = Supersonic(config)
      pr_url = await supersonic.update_content(
          repo=repo,
          content=improved_code,
          path=file_path,
          title=f"AI: {user_prompt[:50]}...",
          description="""
          AI-suggested improvements based on code analysis.
          Please review the changes carefully.
          """,
          draft=True,  # Let users review AI changes
          labels=["ai-improvement"],
          reviewers=["tech-lead"]
      )
      return pr_url
  ```



  Keep documentation in sync with code changes:

  ```python
  async def update_api_docs(repo: str, api_changes: Dict[str, Any]):
      
      docs = {
          "docs/api/endpoints.md": generate_endpoint_docs(api_changes),
          "docs/api/types.md": generate_type_docs(api_changes),
          "README.md": update_quickstart(api_changes)
      }

      
      supersonic = Supersonic(config)
      pr_url = await supersonic.update_files(
          repo=repo,
          files=docs,
          title="Update API documentation",
          description="""
          

          Automatically generated documentation updates based on API changes.
          """,
          labels=["documentation"],
          reviewers=["docs-team"],
          team_reviewers=["api-team"]
      )
      return pr_url
  ```



  Manage customer configurations through PRs:

  ```python
  async def update_customer_config(customer_id: str, new_settings: Dict):
      repo = f"customers/{customer_id}/config"
      config_json = json.dumps(new_settings, indent=2)

      supersonic = Supersonic(config)
      pr_url = await supersonic.update_content(
          repo=repo,
          content=config_json,
          path="settings.json",
          title="Update customer configuration",
          description=f"""
          Configuration updates for customer {customer_id}

          Changes:
          {format_changes(new_settings)}
          """,
          reviewers=[f"@{customer_id}-admin"],  # Auto-assign customer admin
          labels=["config-change"],
          auto_merge=True,  # Enable auto-merge if tests pass
          merge_strategy="squash"
      )
      return pr_url
  ```





  ```bash

  git clone https://github.com/cased/supersonic
  cd supersonic


  uv venv


  uv pip install -r requirements-dev.txt
  uv pip install -e .


  uv run pytest
  ```



  We use:
  - `ruff` for linting and formatting
  - `mypy` for type checking

  All run in GitHub Actions on every PR.



  MIT License - see [LICENSE](LICENSE) file for details.


pkgId: 7fe227d3ea0e9c53edf01c11028aafceb86c1c76aae91a901b2fa781851e950f
name: python-supervisely-help
arch: noarch
version: 6.73.255
epoch: 0
release: 1
summary: Development documents and examples for supervisely
url: https://github.com/supervisely/supervisely
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-supervisely-6.73.255-1.src.rpm
location_href: Packages/python-supervisely-help-6.73.255-1.noarch.rpm
checksum_type: sha256
description:
  **Website**: [https://supervise.ly](https://supervise.ly/)
  **Supervisely Ecosystem**: [https://ecosystem.supervise.ly](https://ecosystem.supervise.ly/)
  **Dev Documentation**: [https://developer.supervisely.com](https://developer.supervisely.com/)
  **Source Code of SDK for Python**: [https://github.com/supervisely/supervisely](https://github.com/supervisely/supervisely)
  **Supervisely Ecosystem on GitHub**: [https://github.com/supervisely-ecosystem](https://github.com/supervisely-ecosystem)


pkgId: 762f64e53e595597bcb38de71f08cc44e6f49a359a1e6dd2c5565a46af83fd82
name: python-supervision-help
arch: noarch
version: 0.25.1
epoch: 0
release: 1
summary: Development documents and examples for supervision
url: https://github.com/roboflow/supervision
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-supervision-0.25.1-1.src.rpm
location_href: Packages/python-supervision-help-0.25.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a align="center" href="" target="https://supervision.roboflow.com">
        <img
          width="100%"
          src="https://media.roboflow.com/open-source/supervision/rf-supervision-banner.png?updatedAt=1678995927529"
        >
      </a>
    </p>

  <br>

  [notebooks](https://github.com/roboflow/notebooks) | [inference](https://github.com/roboflow/inference) | [autodistill](https://github.com/autodistill/autodistill) | [maestro](https://github.com/roboflow/multimodal-maestro)

  <br>

  [![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision)
  [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision)
  [![snyk](https://snyk.io/advisor/python/supervision/badge.svg)](https://snyk.io/advisor/python/supervision)
  [![license](https://img.shields.io/pypi/l/supervision)](https://github.com/roboflow/supervision/blob/main/LICENSE.md)
  [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision)
  [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow/supervision/blob/main/demo.ipynb)
  [![gradio](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/Roboflow/Annotators)
  [![discord](https://img.shields.io/discord/1159501506232451173?logo=discord&label=discord&labelColor=fff&color=5865f2&link=https%3A%2F%2Fdiscord.gg%2FGbfgXGJ8Bk)](https://discord.gg/GbfgXGJ8Bk)
  [![built-with-material-for-mkdocs](https://img.shields.io/badge/Material_for_MkDocs-526CFE?logo=MaterialForMkDocs&logoColor=white)](https://squidfunk.github.io/mkdocs-material/)

    <div align="center">
      <a href="https://trendshift.io/repositories/124"  target="_blank"><img src="https://trendshift.io/api/badge/repositories/124" alt="roboflow%2Fsupervision | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
    </div>

  </div>



  **We write your reusable computer vision tools.** Whether you need to load your dataset from your hard drive, draw detections on an image or video, or count how many detections are in a zone. You can count on us! 🤝



  Pip install the supervision package in a
  [**Python>=3.8**](https://www.python.org/) environment.

  ```bash
  pip install supervision
  ```

  Read more about conda, mamba, and installing from source in our [guide](https://roboflow.github.io/supervision/).





  Supervision was designed to be model agnostic. Just plug in any classification, detection, or segmentation model. For your convenience, we have created [connectors](https://supervision.roboflow.com/latest/detection/core/#detections) for the most popular libraries like Ultralytics, Transformers, or MMDetection.

  ```python
  import cv2
  import supervision as sv
  from ultralytics import YOLO

  image = cv2.imread(...)
  model = YOLO("yolov8s.pt")
  result = model(image)[0]
  detections = sv.Detections.from_ultralytics(result)

  len(detections)

  ```

  <details>
  <summary>👉 more model connectors</summary>

  - inference

    Running with [Inference](https://github.com/roboflow/inference) requires a [Roboflow API KEY](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key).

    ```python
    import cv2
    import supervision as sv
    from inference import get_model

    image = cv2.imread(...)
    model = get_model(model_id="yolov8s-640", api_key=<ROBOFLOW API KEY>)
    result = model.infer(image)[0]
    detections = sv.Detections.from_inference(result)

    len(detections)
    
    ```

  </details>



  Supervision offers a wide range of highly customizable [annotators](https://supervision.roboflow.com/latest/detection/annotators/), allowing you to compose the perfect visualization for your use case.

  ```python
  import cv2
  import supervision as sv

  image = cv2.imread(...)
  detections = sv.Detections(...)

  box_annotator = sv.BoxAnnotator()
  annotated_frame = box_annotator.annotate(
    scene=image.copy(),
    detections=detections)
  ```

  https://github.com/roboflow/supervision/assets/26109316/691e219c-0565-4403-9218-ab5644f39bce



  Supervision provides a set of [utils](https://supervision.roboflow.com/latest/datasets/core/) that allow you to load, split, merge, and save datasets in one of the supported formats.

  ```python
  import supervision as sv
  from roboflow import Roboflow

  project = Roboflow().workspace(<WORKSPACE_ID>).project(<PROJECT_ID>)
  dataset = project.version(<PROJECT_VERSION>).download("coco")

  ds = sv.DetectionDataset.from_coco(
      images_directory_path=f"{dataset.location}/train",
      annotations_path=f"{dataset.location}/train/_annotations.coco.json",
  )

  path, image, annotation = ds[0]
      

  for path, image, annotation in ds:
      
  ```

  <details close>
  <summary>👉 more dataset utils</summary>

  - load

    ```python
    dataset = sv.DetectionDataset.from_yolo(
        images_directory_path=...,
        annotations_directory_path=...,
        data_yaml_path=...
    )

    dataset = sv.DetectionDataset.from_pascal_voc(
        images_directory_path=...,
        annotations_directory_path=...
    )

    dataset = sv.DetectionDataset.from_coco(
        images_directory_path=...,
        annotations_path=...
    )
    ```

  - split

    ```python
    train_dataset, test_dataset = dataset.split(split_ratio=0.7)
    test_dataset, valid_dataset = test_dataset.split(split_ratio=0.5)

    len(train_dataset), len(test_dataset), len(valid_dataset)
    
    ```

  - merge

    ```python
    ds_1 = sv.DetectionDataset(...)
    len(ds_1)
    
    ds_1.classes
    

    ds_2 = sv.DetectionDataset(...)
    len(ds_2)
    
    ds_2.classes
    

    ds_merged = sv.DetectionDataset.merge([ds_1, ds_2])
    len(ds_merged)
    
    ds_merged.classes
    
    ```

  - save

    ```python
    dataset.as_yolo(
        images_directory_path=...,
        annotations_directory_path=...,
        data_yaml_path=...
    )

    dataset.as_pascal_voc(
        images_directory_path=...,
        annotations_directory_path=...
    )

    dataset.as_coco(
        images_directory_path=...,
        annotations_path=...
    )
    ```

  - convert

    ```python
    sv.DetectionDataset.from_yolo(
        images_directory_path=...,
        annotations_directory_path=...,
        data_yaml_path=...
    ).as_pascal_voc(
        images_directory_path=...,
        annotations_directory_path=...
    )
    ```

  </details>



  Want to learn how to use Supervision? Explore our [how-to guides](https://supervision.roboflow.com/develop/how_to/detect_and_annotate/), [end-to-end examples](https://github.com/roboflow/supervision/tree/develop/examples), [cheatsheet](https://roboflow.github.io/cheatsheet-supervision/), and [cookbooks](https://supervision.roboflow.com/develop/cookbooks/)!

  <br/>

  <p align="left">
  <a href="https://youtu.be/hAWpsIuem10" title="Dwell Time Analysis with Computer Vision | Real-Time Stream Processing"><img src="https://github.com/SkalskiP/SkalskiP/assets/26109316/a742823d-c158-407d-b30f-063a5d11b4e1" alt="Dwell Time Analysis with Computer Vision | Real-Time Stream Processing" width="300px" align="left" /></a>
  <a href="https://youtu.be/hAWpsIuem10" title="Dwell Time Analysis with Computer Vision | Real-Time Stream Processing"><strong>Dwell Time Analysis with Computer Vision | Real-Time Stream Processing</strong></a>
  <div><strong>Created: 5 Apr 2024</strong></div>
  <br/>Learn how to use computer vision to analyze wait times and optimize processes. This tutorial covers object detection, tracking, and calculating time spent in designated zones. Use these techniques to improve customer experience in retail, traffic management, or other scenarios.</p>

  <br/>

  <p align="left">
  <a href="https://youtu.be/uWP6UjDeZvY" title="Speed Estimation & Vehicle Tracking | Computer Vision | Open Source"><img src="https://github.com/SkalskiP/SkalskiP/assets/26109316/61a444c8-b135-48ce-b979-2a5ab47c5a91" alt="Speed Estimation & Vehicle Tracking | Computer Vision | Open Source" width="300px" align="left" /></a>
  <a href="https://youtu.be/uWP6UjDeZvY" title="Speed Estimation & Vehicle Tracking | Computer Vision | Open Source"><strong>Speed Estimation & Vehicle Tracking | Computer Vision | Open Source</strong></a>
  <div><strong>Created: 11 Jan 2024</strong></div>
  <br/>Learn how to track and estimate the speed of vehicles using YOLO, ByteTrack, and Roboflow Inference. This comprehensive tutorial covers object detection, multi-object tracking, filtering detections, perspective transformation, speed estimation, visualization improvements, and more.</p>



  Did you build something cool using supervision? [Let us know!](https://github.com/roboflow/supervision/discussions/categories/built-with-supervision)

  https://user-images.githubusercontent.com/26109316/207858600-ee862b22-0353-440b-ad85-caa0c4777904.mp4

  https://github.com/roboflow/supervision/assets/26109316/c9436828-9fbf-4c25-ae8c-60e9c81b3900

  https://github.com/roboflow/supervision/assets/26109316/3ac6982f-4943-4108-9b7f-51787ef1a69f



  Visit our [documentation](https://roboflow.github.io/supervision) page to learn how supervision can help you build computer vision applications faster and more reliably.



  We love your input! Please see our [contributing guide](https://github.com/roboflow/supervision/blob/main/CONTRIBUTING.md) to get started. Thank you 🙏 to all our contributors!

  <p align="center">
      <a href="https://github.com/roboflow/supervision/graphs/contributors">
        <img src="https://contrib.rocks/image?repo=roboflow/supervision" />
      </a>
  </p>

  <br>

  <div align="center">

  <div align="center">
        <a href="https://youtube.com/roboflow">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/youtube.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949634652"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/roboflow-app.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949746649"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://www.linkedin.com/company/roboflow-ai/">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/linkedin.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949633691"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://docs.roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/knowledge.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949634511"
              width="3%"
            />
        </a>
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://discuss.roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/forum.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949633584"
              width="3%"
            />
        <img src="https://raw.githubusercontent.com/ultralytics/assets/main/social/logo-transparent.png" width="3%"/>
        <a href="https://blog.roboflow.com">
            <img
              src="https://media.roboflow.com/notebooks/template/icons/purple/blog.png?ik-sdk-version=javascript-1.4.3&updatedAt=1672949633605"
              width="3%"
            />
        </a>
        </a>
    </div>
  </div>


pkgId: 860e989ec887d7c4fe6e27e4633189a70b35857d699c2c35e65a3e56502232e7
name: python-supervisor-react-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for supervisor-react
url: https://github.com/jouve/supervisor-react
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-supervisor-react-0.7.0-1.src.rpm
location_href: Packages/python-supervisor-react-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  A web interface for supervisor made with React.
  ```
  usage: supervisor-react [-h] [-d] [-p PORT] [-s SUPERVISOR] [-v]
  optional arguments:
    -h, --help            show this help message and exit
    -d, --debug
    -p PORT, --port PORT
    -s SUPERVISOR, --supervisor SUPERVISOR
    -v, --verbose
  ```
  ![Capture3](https://user-images.githubusercontent.com/1096799/111763988-06333c80-88a3-11eb-9cef-1112ca3d4570.PNG)


pkgId: 2d7b6fba1a1468a976687f909a475380ab80b855def815bcd82e0fbcc4a0ee8b
name: python-surf-archiver-help
arch: noarch
version: 0.1.1a4
epoch: 0
release: 1
summary: Development documents and examples for surf-archiver
url: https://pypi.org/project/surf-archiver/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surf-archiver-0.1.1a4-1.src.rpm
location_href: Packages/python-surf-archiver-help-0.1.1a4-1.noarch.rpm
checksum_type: sha256
description:
  The `surf-archiver` tool consists of two components:
  1) a CLI tool
  2) a remote client which can execute CLI installed on a remote machine

  The CLI tool copies daily data from S3 supported storage, bundling it into a per
  experiment per day tar archives. Once completed it emits a message via RabbitMQ. The
  intended use case is for the CLI tool to installed on the Surf Data Archive and remotely
  triggered daily.


  The tool copies data based on the S3 key. It is assumed that the keys have the following
  structure:
  ```
  <SRC BUCKET>/<images|videos>/<EXPERIMENT-ID>/YYYYMMDD/*.tar
  ```

  The resulting archive will be created at:
  ```
  <DATA DIR>/<images|videos>/<EXPERIMENT-ID>/YYYY-MM-DD.tar
  ```



  The CLI tool can be installed via [pipx](https://github.com/pypa/pipx).


  In order to run the tool needs some configuration. It can be configured by via a yaml
  file:

  ```yaml
  bucket:             # S3 bucket data is pulled from
  target_dir:         # Target directory data is stored in
  connction_url:      # RabbitMQ connection url
  exchange_name:      # RabbitMQ Exchange name
  log_file:           # log file path
  ```

  By default the tool will look for this configuration in the `${HOME}/.surf-archiver`.
  The tool will additionally look for these parameters in the shell environment. If they
  are defined here, they need to be prefixed by `surf_archiver_`.


  In addition to the above, the following environment variables need to be set in order to
  connect to S3.
  ```bash
  AWS_SECRET_KEY_ID=
  AWS_ACCESS_KEY_ID=
  AWS_ENDPOINT_URL=
  ```


pkgId: c92465af2819e343609a42e34678ef1249b934f963a6e6ec4cb199731c91cc3e
name: python-surface-ion-help
arch: noarch
version: 1.0.6
epoch: 0
release: 1
summary: Development documents and examples for surface-ion
url: https://github.com/underforestaaa/Sion
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surface-ion-1.0.6-1.src.rpm
location_href: Packages/python-surface-ion-help-1.0.6-1.noarch.rpm
checksum_type: sha256
description:
  Python package for simulation and analysis of ion crystals in surface electrode traps.



  To use *Sion*, the following packages are required to be installed from source and tested:
  - [pylion package](https://bitbucket.org/dtrypogeorgos/pylion/src/master/): LAMMPS wrapper for ion dynamics simulation. This package requires installation of LAMMPS software with the specific version. It will work well with the latest LAMMPS version, if in source file *pylion.py* at line 51 you change "lmp_serial" to "lmp".
  - [electrode package](https://github.com/nist-ionstorage/electrode): Python package for convenient definition and analysis of surface electrode traps.
  !Note: for correct execution of these packages, numpy<=1.21.0 is required.

  The newest version may be installed via pip:
  <code>pip install surface-ion</code>




  *Sion* works with surface traps, defined through the *electrode* package. The simulation of ion dynamics is carried through the *pylion* environment.
  All functions, presented in *Sion* are described in example notebooks. Main file *sion.py* contains docs for each function.

  To publish the results, obtained with *Sion*, we kindly ask you to cite the following article:
  1. [Surface trap with adjustable ion couplings for scalable and parallel gates](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.109.022605)

  Free software: MIT license



  *   Simulation of ion motion in arbitrary polygon and point electrode surface trap.
  *   Optimization and simulation of arbitrary ion shuttling in polygon traps.
  *   Calculation of normal modes for general case of 1D, 2D, 3D mixed species ion crystals with arbitrary set of ions' secular frequencies.
  *   Calculation of anharmonic Mathieu modes of ion crystals in surface traps.
  *   Stability analysis of asymmetric planar traps.
  *   Optimization of DC voltage set of a planar trap to match the desired secular frequency and radial mode rotation angle in given positions.
  *   Convenient trap design. Layout may be imported from GDS file or created by defining the arbitrary electrode shape boundary.



  *  'build/lib/sion.py': contains all the main functions.

  *  'examples': examples showing different features of *Sion*.

  *  'tests': verifications and tests of *Sion* work.



  *  The following error may occur from trying to execute simulation two times without restarting the kernel. It is specific to IPython IDEs (Jupyter, spyder). The error source is in pylion package, and will be resolved by restarting the kernel.

  <code>SimulationError: There are identical 'uids'. Although this is allowed in some  cases, 'lammps' is probably not going to like it.</code>


pkgId: e322ca3c9a749d5366147ba955ba43059106767426713746ffaeb119e8842216
name: python-surface-sim-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for surface-sim
url: https://pypi.org/project/surface-sim/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surface-sim-0.5.0-1.src.rpm
location_href: Packages/python-surface-sim-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  ![example workflow](https://github.com/MarcSerraPeralta/surface-sim/actions/workflows/ci_pipeline.yaml/badge.svg)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  ![PyPI](https://img.shields.io/pypi/v/surface-sim?label=pypi%20package)


  This package is a wrapper around Stim that aims to help the construction of QEC-code circuits easier. The package implements model classes that help with inserting ciruit-level noise models. It uses a code layout that helps with qubit labeling, indexing and connectivity. Finally, there are a number of circuits for the rotated surface code that are implemented in the package.

  For more information see the documentation in `docs/`.



  This package is available in PyPI, thus it can be installed using
  ```
  pip install surface-sim
  ```

  or alternatively, it can be installed from source using
  ```
  git clone git@github.com:MarcSerraPeralta/surface-sim.git
  pip install surface-sim/
  ```



  ```
  from surface_sim.layouts import rot_surface_code
  from surface_sim.models import CircuitNoiseModel
  from surface_sim.setup import CircuitNoiseSetup
  from surface_sim import Detectors
  from surface_sim.experiments.rot_surface_code_css import memory_experiment


  layout = rot_surface_code(distance=3)

  qubit_inds = layout.qubit_inds()
  anc_qubits = layout.get_qubits(role="anc")
  data_qubits = layout.get_qubits(role="data")

  setup = CircuitNoiseSetup()

  model = CircuitNoiseModel(setup, qubit_inds)

  detectors = Detectors(anc_qubits, frame="pre-gate")


  NUM_ROUNDS = 10
  DATA_INIT = {q: 0 for q in data_qubits}
  ROT_BASIS = True # X basis
  MEAS_RESET = True # reset after ancilla measurements
  PROB = 1e-5

  setup.set_var_param("prob", PROB)
  stim_circuit = memory_experiment(model, layout, detectors, NUM_ROUNDS, DATA_INIT, ROT_BASIS, MEAS_RESET)
  ```

  For more information and examples about `surface-sim`, please read the `docs/`.

rpm_license:
  MIT License  Copyright (c) 2023 MarcSerraPeralta  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: 305e707740bfffbea0afd9ff089c72eb6a891636d978595eb47a7a14f3c23066
name: python-surfaice-assistant-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for surfaice-assistant
url: https://pypi.org/project/surfaice-assistant/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surfaice-assistant-0.2.3-1.src.rpm
location_href: Packages/python-surfaice-assistant-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  The file `processor_2.py` is a temporary file used in the current branch and will be renamed to `processor.py`. Please be aware that any references to `processor_2.py` should be updated to `processor.py` once the renaming is complete.




  To install this package directly from Git using Poetry, add the following to your `pyproject.toml`:

  ```toml
  [tool.poetry.dependencies]
  surfaice-assistance = { git = "https://github.com/gdml/surfaice-assistant.git", branch = "feature/s42t207_add-ai-models-choice" }
  ```
  or locally:

  ```toml
  [tool.poetry.dependencies]
  surfaice-assistant = { path = "path/to/surfaice-assistant"}
  ```



  ```python
  from surfaice_assistance.processor2 import AssistantProcessor

  class YourClass:
      ...

      @property
      def assistant_processor(self) -> AssistantProcessor:
          return AssistantProcessor(api_key=self.api_key, provider=self.provider.value)
      ...

      def create_assistant(self) -> AssistantCreateResponse:
          return self.assistant_processor.create_assistant(
              name="Your Assistant Name",
              description="Your Assistant Description",
              instructions="Your Assistant Instructions",
              model="gpt-4o",
              tools=list[dict],
          )

      def get_assistant(self) -> AssistantGetResponse:
          return self.assistant_processor.get_assistant(
              assistant_id="your_assistant_id",
          )

      def update_assistant(self) -> AssistantUpdateResponse:
          return self.assistant_processor.update_assistant(
              assistant_id="your_assistant_id",
              name="Your Assistant Name",
              description="Your Assistant Description",
              instructions="Your Assistant Instructions",
              model="gpt-4o",
              tools=list[dict],
          )

      

  ```



  When adding a new assistant implementation to the system, follow these steps:

  1. Create a new implementation class that inherits from `AssistantInterface`:
     - Create a new file in the `implementations/` directory
     - Implement all abstract methods from `AssistantInterface`
     - Follow the response models pattern using Pydantic models
     - Add import to `__all__` in `implementations/__init__.py`

  2. Register the implementation in `processor_2.py`:
     ```python
     from implementations.your_provider import YourProviderImpl

     processor_implementations: dict[str, Union[Type[OpenAIAssistantImpl], Type[YourProviderImpl], Any]] = {
         OPENAI: OpenAIAssistantImpl,
         "your_provider": YourProviderImpl,  # Add your implementation here
     }
     ```

  3. Define a constant for your provider name at the top of `processor_2.py`:
     ```python
     YOUR_PROVIDER = "your_provider"
     ```

  4. Ensure your implementation:
     - Uses the standard response models from `abstract_provider.assistant`
     - Handles retries and error cases consistently
     - Includes proper logging
     - Has appropriate type hints
     - Follows the existing pattern for async methods



  Your implementation class must:

  1. Inherit from `AssistantInterface`
  2. Implement all abstract methods defined in the interface
  3. Use the standard response models:
     - AssistantCreateResponse
     - AssistantGetResponse
     - ThreadGetResponse
     - MessageCreateResponse
     - etc.


  ```python
  from abstract_provider import AssistantInterface
  from abstract_provider.assistant import (
      AssistantCreateResponse,
      AssistantGetResponse,

  )
  class YourProviderImpl(AssistantInterface):
      def init(self, api_key: str) -> None:
      
          pass
      async def create_assistant(
          self,
          name: str,
          description: str,
          instructions: str,
          model: str,
          tools: list[dict],
          max_retries: int = 5,
          ) -> AssistantCreateResponse:
          pass
  ```


  See the OpenAI implementation (`implementations/openai_provider.py`) for a complete example of how to structure your implementation.



  - Use Pydantic models for response models
  - Follow the response models pattern using Pydantic models
  - Add the response models to the `implementations.your_provider` module
  - Add the type of your models to unions in `abstract_provider.assistant` models
  - Example:
      ```python
      from pydantic import BaseModel
      class YourResponseModel(BaseModel):
          
          success: bool
          your_field: Optional[YourType] = None
          error: Optional[str] = None
      ```


pkgId: bc1c56590aa56c13d072a6b42c1693713c33f52816e8aaaf9eade05b1384c274
name: python-surfhub-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for surfhub
url: https://github.com/nqbao/surfhub
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surfhub-0.0.2-1.src.rpm
location_href: Packages/python-surfhub-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A python library for surfing and crawling website.

  This library provides two basic components for you to run google search and getting result

  * Seprer is a API to provide structured data from Google search. There are many serper providers such as ValueSerp, Serper, etc
  * Scraper is an API to extract HTML from website. You can run it on your own laptop, but it is better to use providers such as Zyte, or Browserless

  To start, you can visit [Serper](https://serper.dev) to get a free account.

  ```
  import surhub.serp as serp

  s = serp.get_serp("serper", api_key="yourkey")
  print(s.serp("hello world").items)
  ```

  Supported SERP provider:
    * [ValueSerp](https://valueserp.com/)
    * Google Custom Search
    * [Serper](https://serper.dev/)

  TODO: [SerpAPI](https://serpapi.com/), DuckDuckGo


  Example to use scrapper

  ```
  import surfhub.scrapper as scapper

  s = serp.get_scrapper("browserless", api_key="yourkey")
  s.scrape("https://webscraper.io/test-sites/e-commerce/allinone")
  ```

  Supported Scrapper provider
    * Local (run on your laptop) with proxy support
    * Browserless
    * Zyte
    * Crawlspace

  TODO: ScrappingBee


pkgId: ba99b197cb543a28a4ecda92da99f10713ae3e5bd0b003d0553d8d57e6329e4a
name: python-surfkit-help
arch: noarch
version: 0.1.290
epoch: 0
release: 1
summary: Development documents and examples for surfkit
url: https://pypi.org/project/surfkit/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surfkit-0.1.290-1.src.rpm
location_href: Packages/python-surfkit-help-0.1.290-1.noarch.rpm
checksum_type: sha256
description:
  <!-- PROJECT LOGO -->
  <br />
  <p align="center">
    <!-- <a href="https://github.com/agentsea/skillpacks">
      <img src="https://project-logo.png" alt="Logo" width="80">
    </a> -->

    <h1 align="center">Surfkit</h1>

    <p align="center">
      A toolkit for building and sharing AI agents that operate on devices
      <br />
      <a href="https://docs.hub.agentsea.ai/introduction"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <a href="https://youtu.be/exoOUUwFRB8">View Demo</a>
      ·
      <a href="https://github.com/agentsea/surfkit/issues">Report Bug</a>
      ·
      <a href="https://github.com/agentsea/surfkit/issues">Request Feature</a>
    </p>
    <br>
  </p>



  - **Build** multimodal agents that can operate on devices
  - **Share** agents with the community
  - **Run** agents and devices locally or in the cloud
  - **Manage** agent tasks at scale
  - **Track** and observe agent actions



  https://github.com/agentsea/surfkit/assets/5533189/98b7714d-9692-4369-8fbf-88aff61e741c



  ```sh
  pip install surfkit
  ```





  - Docker
  - Python >= 3.10
  - MacOS or Linux



  Use an agent to solve a task

  ```python
  from surfkit import solve

  task = solve(
      "Search for the most common variety of french duck",
      agent_type="pbarker/SurfPizza",
      device_type="desktop",
    )

  task.wait_for_done()

  result = task.result
  ```





  Find available agents on the Hub

  ```
  surfkit find
  ```

  Create a new agent

  ```
  surfkit create agent -t pbarker/SurfPizza -n agent01
  ```

  List running agents

  ```
  surfkit list agents
  ```



  Create an Ubuntu desktop for our agent to use.

  ```
  surfkit create device --provider docker -n desktop01
  ```

  List running devices

  ```
  surfkit list devices
  ```



  Use the agent to solve a task on the device

  ```
  surfkit solve "Search for the most common variety of french duck" \
    --agent agent01 \
    --device desktop01
  ```



  View our [documentation](https://docs.hub.agentsea.ai) for more in depth information.





  Initialize a new project

  ```sh
  surfkit new
  ```

  Build a docker container for the agent

  ```sh
  surfkit build
  ```



  Create an agent locally

  ```sh
  surfkit create agent --name foo -t pbarker/SurfPizza
  ```

  Create an agent on kubernetes

  ```sh
  surfkit create agent --runtime kube -t pbarker/SurfPizza
  ```

  List running agents

  ```sh
  surfkit list agents
  ```

  Get details about a specific agent

  ```sh
  surfkit get agent foo
  ```

  Fetch logs for a specific agent

  ```sh
  surfkit logs foo
  ```

  Delete an agent

  ```sh
  surfkit delete agent foo
  ```



  Create a device

  ```sh
  surfkit create device --type desktop --provicer gce --name bar
  ```

  List devices

  ```sh
  surfkit list devices
  ```

  View device in UI

  ```sh
  surfkit view bar
  ```

  Delete a device

  ```sh
  surfkit delete device bar
  ```



  Create a tracker

  ```sh
  surfkit create tracker
  ```

  List trackers

  ```sh
  surfkit list trackers
  ```

  Delete a tracker

  ```sh
  surfkit delete tracker foo
  ```



  Solve a task with an existing setup

  ```sh
  surfkit solve "search for common french ducks" --agent foo --device bar
  ```

  Solve a task creating the agent ad hoc

  ```sh
  surfkit solve "search for alpaca sweaters" \
  --device bar --agent-file ./agent.yaml
  ```

  List tasks

  ```sh
  surfkit list tasks
  ```



  Login to the hub

  ```sh
  surfkit login
  ```

  Publish the agent

  ```sh
  surfkit publish
  ```

  List published agent types

  ```sh
  surfkit find
  ```



  Skillpacks is integrated with:

  - [MLLM](https://github.com/agentsea/mllm) A prompt management, routing, and schema validation library for multimodal LLMs
  - [Taskara](https://github.com/agentsea/taskara) A task management library for AI agents
  - [Skillpacks](https://github.com/agentsea/skillpacks) A library to fine tune AI agents on tasks.
  - [Threadmem](https://github.com/agentsea/threadmem) A thread management library for AI agents



  Come join us on [Discord](https://discord.gg/hhaq7XYPS6).



  Add the following function to your `~/.zshrc` (or similar)

  ```sh
  function sk() {
    local project_dir="/path/to/surfkit/repo"
    local venv_dir="$project_dir/.venv"
    local ssh_auth_sock="$SSH_AUTH_SOCK"
    local ssh_agent_pid="$SSH_AGENT_PID"

    export SSH_AUTH_SOCK="$ssh_auth_sock"
    export SSH_AGENT_PID="$ssh_agent_pid"

    
    export PATH="$venv_dir/bin:$PATH"

    
    surfkit "$@"
  }
  ```

  Replacing `/path/to/surfkit/repo` with the absolute path to your local repo.

  Then calling `sk` will execute the working code in your repo from any location.


pkgId: 9c9bd123a81fab80b78c006c282f1822fcb01bccaf5371441aa8c5ac9524a00b
name: python-surya-ocr-help
arch: noarch
version: 0.8.1
epoch: 0
release: 1
summary: Development documents and examples for surya-ocr
url: https://github.com/VikParuchuri/surya
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-surya-ocr-0.8.1-1.src.rpm
location_href: Packages/python-surya-ocr-help-0.8.1-1.noarch.rpm
checksum_type: sha256
description:
  Surya is a document OCR toolkit that does:

  - OCR in 90+ languages that benchmarks favorably vs cloud services
  - Line-level text detection in any language
  - Layout analysis (table, image, header, etc detection)
  - Reading order detection
  - Table recognition (detecting rows/columns)

  It works on a range of documents (see [usage](#usage) and [benchmarks](#benchmarks) for more details).


  |                            Detection                             |                                   OCR                                   |
  |:----------------------------------------------------------------:|:-----------------------------------------------------------------------:|
  |  <img src="static/images/excerpt.png" width="500px"/>  |  <img src="static/images/excerpt_text.png" width="500px"/> |

  |                               Layout                               |                               Reading Order                                |
  |:------------------------------------------------------------------:|:--------------------------------------------------------------------------:|
  | <img src="static/images/excerpt_layout.png" width="500px"/> | <img src="static/images/excerpt_reading.jpg" width="500px"/> |

  |                       Table Recognition                       |     |
  |:-------------------------------------------------------------:|:----------------:|
  | <img src="static/images/scanned_tablerec.png" width="500px"/> | <img width="500px"/> |


  Surya is named for the [Hindu sun god](https://en.wikipedia.org/wiki/Surya), who has universal vision.



  [Discord](https://discord.gg//KuZwXNGnfH) is where we discuss future development.



  | Name             |              Detection              |                                      OCR |                                     Layout |                                       Order |                                    Table Rec |
  |------------------|:-----------------------------------:|-----------------------------------------:|-------------------------------------------:|--------------------------------------------:|---------------------------------------------:|
  | Japanese         | [Image](static/images/japanese.jpg) | [Image](static/images/japanese_text.jpg) | [Image](static/images/japanese_layout.jpg) | [Image](static/images/japanese_reading.jpg) | [Image](static/images/japanese_tablerec.png) |
  | Chinese          | [Image](static/images/chinese.jpg)  |  [Image](static/images/chinese_text.jpg) |  [Image](static/images/chinese_layout.jpg) |  [Image](static/images/chinese_reading.jpg) |                                              |
  | Hindi            |  [Image](static/images/hindi.jpg)   |    [Image](static/images/hindi_text.jpg) |    [Image](static/images/hindi_layout.jpg) |    [Image](static/images/hindi_reading.jpg) |                                              |
  | Arabic           |  [Image](static/images/arabic.jpg)  |   [Image](static/images/arabic_text.jpg) |   [Image](static/images/arabic_layout.jpg) |   [Image](static/images/arabic_reading.jpg) |                                              |
  | Chinese + Hindi  | [Image](static/images/chi_hind.jpg) | [Image](static/images/chi_hind_text.jpg) | [Image](static/images/chi_hind_layout.jpg) | [Image](static/images/chi_hind_reading.jpg) |                                              |
  | Presentation     |   [Image](static/images/pres.png)   |     [Image](static/images/pres_text.jpg) |     [Image](static/images/pres_layout.jpg) |     [Image](static/images/pres_reading.jpg) |     [Image](static/images/pres_tablerec.png) |
  | Scientific Paper |  [Image](static/images/paper.jpg)   |    [Image](static/images/paper_text.jpg) |    [Image](static/images/paper_layout.jpg) |    [Image](static/images/paper_reading.jpg) |    [Image](static/images/paper_tablerec.png) |
  | Scanned Document | [Image](static/images/scanned.png)  |  [Image](static/images/scanned_text.jpg) |  [Image](static/images/scanned_layout.jpg) |  [Image](static/images/scanned_reading.jpg) |  [Image](static/images/scanned_tablerec.png) |
  | New York Times   |   [Image](static/images/nyt.jpg)    |      [Image](static/images/nyt_text.jpg) |      [Image](static/images/nyt_layout.jpg) |        [Image](static/images/nyt_order.jpg) |                                              |
  | Scanned Form     |  [Image](static/images/funsd.png)   |    [Image](static/images/funsd_text.jpg) |    [Image](static/images/funsd_layout.jpg) |    [Image](static/images/funsd_reading.jpg) | [Image](static/images/scanned_tablerec2.png) |
  | Textbook         | [Image](static/images/textbook.jpg) | [Image](static/images/textbook_text.jpg) | [Image](static/images/textbook_layout.jpg) |   [Image](static/images/textbook_order.jpg) |                                              |



  There is a hosted API for all surya models available [here](https://www.datalab.to/):

  - Works with PDF, images, word docs, and powerpoints
  - Consistent speed, with no latency spikes
  - High reliability and uptime



  I want surya to be as widely accessible as possible, while still funding my development/training costs. Research and personal usage is always okay, but there are some restrictions on commercial usage.

  The weights for the models are licensed `cc-by-nc-sa-4.0`, but I will waive that for any organization under $5M USD in gross revenue in the most recent 12-month period AND under $5M in lifetime VC/angel funding raised. You also must not be competitive with the [Datalab API](https://www.datalab.to/).  If you want to remove the GPL license requirements (dual-license) and/or use the weights commercially over the revenue limit, check out the options [here](https://www.datalab.to).



  You'll need python 3.10+ and PyTorch. You may need to install the CPU version of torch first if you're not using a Mac or a GPU machine.  See [here](https://pytorch.org/get-started/locally/) for more details.

  Install with:

  ```shell
  pip install surya-ocr
  ```

  Model weights will automatically download the first time you run surya.



  - Inspect the settings in `surya/settings.py`.  You can override any settings with environment variables.
  - Your torch device will be automatically detected, but you can override this.  For example, `TORCH_DEVICE=cuda`.



  I've included a streamlit app that lets you interactively try Surya on images or PDF files.  Run it with:

  ```shell
  pip install streamlit
  surya_gui
  ```



  This command will write out a json file with the detected text and bboxes:

  ```shell
  surya_ocr DATA_PATH
  ```

  - `DATA_PATH` can be an image, pdf, or folder of images/pdfs
  - `--langs` is an optional (but recommended) argument that specifies the language(s) to use for OCR.  You can comma separate multiple languages. Use the language name or two-letter ISO code from [here](https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes).  Surya supports the 90+ languages found in `surya/languages.py`.
  - `--lang_file` if you want to use a different language for different PDFs/images, you can optionally specify languages in a file.  The format is a JSON dict with the keys being filenames and the values as a list, like `{"file1.pdf": ["en", "hi"], "file2.pdf": ["en"]}`.
  - `--images` will save images of the pages and detected text lines (optional)
  - `--results_dir` specifies the directory to save results to instead of the default
  - `--max` specifies the maximum number of pages to process if you don't want to process everything
  - `--start_page` specifies the page number to start processing from

  The `results.json` file will contain a json dictionary where the keys are the input filenames without extensions.  Each value will be a list of dictionaries, one per page of the input document.  Each page dictionary contains:

  - `text_lines` - the detected text and bounding boxes for each line
    - `text` - the text in the line
    - `confidence` - the confidence of the model in the detected text (0-1)
    - `polygon` - the polygon for the text line in (x1, y1), (x2, y2), (x3, y3), (x4, y4) format.  The points are in clockwise order from the top left.
    - `bbox` - the axis-aligned rectangle for the text line in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.
  - `languages` - the languages specified for the page
  - `page` - the page number in the file
  - `image_bbox` - the bbox for the image in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.  All line bboxes will be contained within this bbox.

  **Performance tips**

  Setting the `RECOGNITION_BATCH_SIZE` env var properly will make a big difference when using a GPU.  Each batch item will use `40MB` of VRAM, so very high batch sizes are possible.  The default is a batch size `512`, which will use about 20GB of VRAM.  Depending on your CPU core count, it may help, too - the default CPU batch size is `32`.



  ```python
  from PIL import Image
  from surya.ocr import run_ocr
  from surya.model.detection.model import load_model as load_det_model, load_processor as load_det_processor
  from surya.model.recognition.model import load_model as load_rec_model
  from surya.model.recognition.processor import load_processor as load_rec_processor

  image = Image.open(IMAGE_PATH)
  langs = ["en"] # Replace with your languages - optional but recommended
  det_processor, det_model = load_det_processor(), load_det_model()
  rec_model, rec_processor = load_rec_model(), load_rec_processor()

  predictions = run_ocr([image], [langs], det_model, det_processor, rec_model, rec_processor)
  ```



  The following models have support for compilation. You will need to set the following environment variables to enable compilation:

  - Recognition: `COMPILE_RECOGNITION=true`
  - Detection: `COMPILE_DETECTOR=true`
  - Layout: `COMPILE_LAYOUT=true`
  - Table recognition: `COMPILE_TABLE_REC=true`

  Alternatively, you can also set `COMPILE_ALL=true` which will compile all models.

  Here are the speedups on an A10 GPU:

  | Model             | Time per page (s) | Compiled time per page (s) | Speedup (%) |
  | ----------------- | ----------------- | -------------------------- | ----------- |
  | Recognition       | 0.657556          | 0.56265                    | 14.43314334 |
  | Detection         | 0.108808          | 0.10521                    | 3.306742151 |
  | Layout            | 0.27319           | 0.27063                    | 0.93707676  |
  | Table recognition | 0.0219            | 0.01938                    | 11.50684932 |




  This command will write out a json file with the detected bboxes.

  ```shell
  surya_detect DATA_PATH
  ```

  - `DATA_PATH` can be an image, pdf, or folder of images/pdfs
  - `--images` will save images of the pages and detected text lines (optional)
  - `--max` specifies the maximum number of pages to process if you don't want to process everything
  - `--results_dir` specifies the directory to save results to instead of the default

  The `results.json` file will contain a json dictionary where the keys are the input filenames without extensions.  Each value will be a list of dictionaries, one per page of the input document.  Each page dictionary contains:

  - `bboxes` - detected bounding boxes for text
    - `bbox` - the axis-aligned rectangle for the text line in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.
    - `polygon` - the polygon for the text line in (x1, y1), (x2, y2), (x3, y3), (x4, y4) format.  The points are in clockwise order from the top left.
    - `confidence` - the confidence of the model in the detected text (0-1)
  - `vertical_lines` - vertical lines detected in the document
    - `bbox` - the axis-aligned line coordinates.
  - `page` - the page number in the file
  - `image_bbox` - the bbox for the image in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.  All line bboxes will be contained within this bbox.

  **Performance tips**

  Setting the `DETECTOR_BATCH_SIZE` env var properly will make a big difference when using a GPU.  Each batch item will use `440MB` of VRAM, so very high batch sizes are possible.  The default is a batch size `36`, which will use about 16GB of VRAM.  Depending on your CPU core count, it might help, too - the default CPU batch size is `6`.



  ```python
  from PIL import Image
  from surya.detection import batch_text_detection
  from surya.model.detection.model import load_model, load_processor

  image = Image.open(IMAGE_PATH)
  model, processor = load_model(), load_processor()


  predictions = batch_text_detection([image], model, processor)
  ```



  This command will write out a json file with the detected layout and reading order.

  ```shell
  surya_layout DATA_PATH
  ```

  - `DATA_PATH` can be an image, pdf, or folder of images/pdfs
  - `--images` will save images of the pages and detected text lines (optional)
  - `--max` specifies the maximum number of pages to process if you don't want to process everything
  - `--results_dir` specifies the directory to save results to instead of the default

  The `results.json` file will contain a json dictionary where the keys are the input filenames without extensions.  Each value will be a list of dictionaries, one per page of the input document.  Each page dictionary contains:

  - `bboxes` - detected bounding boxes for text
    - `bbox` - the axis-aligned rectangle for the text line in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.
    - `polygon` - the polygon for the text line in (x1, y1), (x2, y2), (x3, y3), (x4, y4) format.  The points are in clockwise order from the top left.
    - `position` - the reading order of the box.
    - `label` - the label for the bbox.  One of `Caption`, `Footnote`, `Formula`, `List-item`, `Page-footer`, `Page-header`, `Picture`, `Figure`, `Section-header`, `Table`, `Form`, `Table-of-contents`, `Handwriting`, `Text`, `Text-inline-math`.
    - `top_k` - the top-k other potential labels for the box.  A dictionary with labels as keys and confidences as values.
  - `page` - the page number in the file
  - `image_bbox` - the bbox for the image in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.  All line bboxes will be contained within this bbox.

  **Performance tips**

  Setting the `LAYOUT_BATCH_SIZE` env var properly will make a big difference when using a GPU.  Each batch item will use `220MB` of VRAM, so very high batch sizes are possible.  The default is a batch size `32`, which will use about 7GB of VRAM.  Depending on your CPU core count, it might help, too - the default CPU batch size is `4`.



  ```python
  from PIL import Image
  from surya.detection import batch_text_detection
  from surya.layout import batch_layout_detection
  from surya.model.detection.model import load_model as load_det_model, load_processor as load_det_processor
  from surya.model.layout.model import load_model as load_layout_model
  from surya.model.layout.processor import load_processor as load_layout_processor

  image = Image.open(IMAGE_PATH)
  model = load_layout_model()
  processor = load_layout_processor()
  det_model = load_det_model()
  det_processor = load_det_processor()


  line_predictions = batch_text_detection([image], det_model, det_processor)
  layout_predictions = batch_layout_detection([image], model, processor, line_predictions)
  ```



  This command will write out a json file with the detected table cells and row/column ids, along with row/column bounding boxes.  If you want to get a formatted markdown table, check out the [tabled](https://www.github.com/VikParuchuri/tabled) repo.

  ```shell
  surya_table DATA_PATH
  ```

  - `DATA_PATH` can be an image, pdf, or folder of images/pdfs
  - `--images` will save images of the pages and detected table cells + rows and columns (optional)
  - `--max` specifies the maximum number of pages to process if you don't want to process everything
  - `--results_dir` specifies the directory to save results to instead of the default
  - `--detect_boxes` specifies if cells should be detected.  By default, they're pulled out of the PDF, but this is not always possible.
  - `--skip_table_detection` tells table recognition not to detect tables first.  Use this if your image is already cropped to a table.

  The `results.json` file will contain a json dictionary where the keys are the input filenames without extensions.  Each value will be a list of dictionaries, one per page of the input document.  Each page dictionary contains:

  - `rows` - detected table rows
    - `bbox` - the bounding box of the table row
    - `row_id` - the id of the row
  - `cols` - detected table columns
    - `bbox` - the bounding box of the table column
    - `col_id`- the id of the column
  - `cells` - detected table cells
    - `bbox` - the axis-aligned rectangle for the text line in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.
    - `text` - if text could be pulled out of the pdf, the text of this cell.
  - `page` - the page number in the file
  - `table_idx` - the index of the table on the page (sorted in vertical order)
  - `image_bbox` - the bbox for the image in (x1, y1, x2, y2) format.  (x1, y1) is the top left corner, and (x2, y2) is the bottom right corner.  All line bboxes will be contained within this bbox.

  **Performance tips**

  Setting the `TABLE_REC_BATCH_SIZE` env var properly will make a big difference when using a GPU.  Each batch item will use `150MB` of VRAM, so very high batch sizes are possible.  The default is a batch size `64`, which will use about 10GB of VRAM.  Depending on your CPU core count, it might help, too - the default CPU batch size is `8`.



  See `table_recognition.py` for a code sample.  Table recognition depends on extracting cells, so it is a little more involved to setup than other model types.



  - This is specialized for document OCR.  It will likely not work on photos or other images.
  - It is for printed text, not handwriting (though it may work on some handwriting).
  - The text detection model has trained itself to ignore advertisements.
  - You can find language support for OCR in `surya/languages.py`.  Text detection, layout analysis, and reading order will work with any language.



  If OCR isn't working properly:

  - Try increasing resolution of the image so the text is bigger.  If the resolution is already very high, try decreasing it to no more than a `2048px` width.
  - Preprocessing the image (binarizing, deskewing, etc) can help with very old/blurry images.
  - You can adjust `DETECTOR_BLANK_THRESHOLD` and `DETECTOR_TEXT_THRESHOLD` if you don't get good results.  `DETECTOR_BLANK_THRESHOLD` controls the space between lines - any prediction below this number will be considered blank space.  `DETECTOR_TEXT_THRESHOLD` controls how text is joined - any number above this is considered text.  `DETECTOR_TEXT_THRESHOLD` should always be higher than `DETECTOR_BLANK_THRESHOLD`, and both should be in the 0-1 range.  Looking at the heatmap from the debug output of the detector can tell you how to adjust these (if you see faint things that look like boxes, lower the thresholds, and if you see bboxes being joined together, raise the thresholds).



  If you want to develop surya, you can install it manually:

  - `git clone https://github.com/VikParuchuri/surya.git`
  - `cd surya`
  - `poetry install` - installs main and dev dependencies
  - `poetry shell` - activates the virtual environment





  ![Benchmark chart tesseract](static/images/benchmark_rec_chart.png)

  | Model     | Time per page (s) | Avg similarity (⬆) |
  |-----------|-------------------|--------------------|
  | surya     | .62               | 0.97               |
  | tesseract | .45               | 0.88               |

  [Full language results](static/images/rec_acc_table.png)

  Tesseract is CPU-based, and surya is CPU or GPU.  I tried to cost-match the resources used, so I used a 1xA6000 (48GB VRAM) for surya, and 28 CPU cores for Tesseract (same price on Lambda Labs/DigitalOcean).



  I benchmarked OCR against Google Cloud vision since it has similar language coverage to Surya.

  ![Benchmark chart google cloud](static/images/gcloud_rec_bench.png)

  [Full language results](static/images/gcloud_full_langs.png)

  **Methodology**

  I measured normalized sentence similarity (0-1, higher is better) based on a set of real-world and synthetic pdfs.  I sampled PDFs from common crawl, then filtered out the ones with bad OCR.  I couldn't find PDFs for some languages, so I also generated simple synthetic PDFs for those.

  I used the reference line bboxes from the PDFs with both tesseract and surya, to just evaluate the OCR quality.

  For Google Cloud, I aligned the output from Google Cloud with the ground truth.  I had to skip RTL languages since they didn't align well.



  ![Benchmark chart](static/images/benchmark_chart_small.png)

  | Model     | Time (s)   | Time per page (s)   | precision   |   recall |
  |-----------|------------|---------------------|-------------|----------|
  | surya     | 50.2099    | 0.196133            | 0.821061    | 0.956556 |
  | tesseract | 74.4546    | 0.290838            | 0.631498    | 0.997694 |


  Tesseract is CPU-based, and surya is CPU or GPU.  I ran the benchmarks on a system with an A10 GPU, and a 32 core CPU.  This was the resource usage:

  - tesseract - 32 CPU cores, or 8 workers using 4 cores each
  - surya - 36 batch size, for 16GB VRAM usage

  **Methodology**

  Surya predicts line-level bboxes, while tesseract and others predict word-level or character-level.  It's hard to find 100% correct datasets with line-level annotations. Merging bboxes can be noisy, so I chose not to use IoU as the metric for evaluation.

  I instead used coverage, which calculates:

  - Precision - how well the predicted bboxes cover ground truth bboxes
  - Recall - how well ground truth bboxes cover predicted bboxes

  First calculate coverage for each bbox, then add a small penalty for double coverage, since we want the detection to have non-overlapping bboxes.  Anything with a coverage of 0.5 or higher is considered a match.

  Then we calculate precision and recall for the whole dataset.



  | Layout Type   |   precision |   recall |
  |---------------|-------------|----------|
  | Image         |     0.91265 |  0.93976 |
  | List          |     0.80849 |  0.86792 |
  | Table         |     0.84957 |  0.96104 |
  | Text          |     0.93019 |  0.94571 |
  | Title         |     0.92102 |  0.95404 |

  Time per image - .13 seconds on GPU (A10).

  **Methodology**

  I benchmarked the layout analysis on [Publaynet](https://github.com/ibm-aur-nlp/PubLayNet), which was not in the training data.  I had to align publaynet labels with the surya layout labels.  I was then able to find coverage for each layout type:

  - Precision - how well the predicted bboxes cover ground truth bboxes
  - Recall - how well ground truth bboxes cover predicted bboxes



  88% mean accuracy, and .4 seconds per image on an A10 GPU.  See methodology for notes - this benchmark is not perfect measure of accuracy, and is more useful as a sanity check.

  **Methodology**

  I benchmarked the reading order on the layout dataset from [here](https://www.icst.pku.edu.cn/cpdp/sjzy/), which was not in the training data.  Unfortunately, this dataset is fairly noisy, and not all the labels are correct.  It was very hard to find a dataset annotated with reading order and also layout information.  I wanted to avoid using a cloud service for the ground truth.

  The accuracy is computed by finding if each pair of layout boxes is in the correct order, then taking the % that are correct.



  | Model             | Row Intersection | Col Intersection |   Time Per Image |
  |-------------------|------------------|------------------|------------------|
  | Surya             | 0.97             | 0.93             |             0.03 |
  | Table transformer | 0.72             | 0.84             |             0.02 |

  Higher is better for intersection, which the percentage of the actual row/column overlapped by the predictions.

  **Methodology**

  The benchmark uses a subset of [Fintabnet](https://developer.ibm.com/exchanges/data/all/fintabnet/) from IBM.  It has labeled rows and columns.  After table recognition is run, the predicted rows and columns are compared to the ground truth.  There is an additional penalty for predicting too many or too few rows/columns.



  You can benchmark the performance of surya on your machine.

  - Follow the manual install instructions above.
  - `poetry install --group dev` - installs dev dependencies

  **Text line detection**

  This will evaluate tesseract and surya for text line detection across a randomly sampled set of images from [doclaynet](https://huggingface.co/datasets/vikp/doclaynet_bench).

  ```shell
  python benchmark/detection.py --max 256
  ```

  - `--max` controls how many images to process for the benchmark
  - `--debug` will render images and detected bboxes
  - `--pdf_path` will let you specify a pdf to benchmark instead of the default data
  - `--results_dir` will let you specify a directory to save results to instead of the default one

  **Text recognition**

  This will evaluate surya and optionally tesseract on multilingual pdfs from common crawl (with synthetic data for missing languages).

  ```shell
  python benchmark/recognition.py --tesseract
  ```

  - `--max` controls how many images to process for the benchmark
  - `--debug 2` will render images with detected text
  - `--results_dir` will let you specify a directory to save results to instead of the default one
  - `--tesseract` will run the benchmark with tesseract.  You have to run `sudo apt-get install tesseract-ocr-all` to install all tesseract data, and set `TESSDATA_PREFIX` to the path to the tesseract data folder.

  - Set `RECOGNITION_BATCH_SIZE=864` to use the same batch size as the benchmark.
  - Set `RECOGNITION_BENCH_DATASET_NAME=vikp/rec_bench_hist` to use the historical document data for benchmarking.  This data comes from the [tapuscorpus](https://github.com/HTR-United/tapuscorpus).

  **Layout analysis**

  This will evaluate surya on the publaynet dataset.

  ```shell
  python benchmark/layout.py
  ```

  - `--max` controls how many images to process for the benchmark
  - `--debug` will render images with detected text
  - `--results_dir` will let you specify a directory to save results to instead of the default one

  **Reading Order**

  ```shell
  python benchmark/ordering.py
  ```

  - `--max` controls how many images to process for the benchmark
  - `--debug` will render images with detected text
  - `--results_dir` will let you specify a directory to save results to instead of the default one

  **Table Recognition**

  ```shell
  python benchmark/table_recognition.py --max 1024 --tatr
  ```

  - `--max` controls how many images to process for the benchmark
  - `--debug` will render images with detected text
  - `--results_dir` will let you specify a directory to save results to instead of the default one
  - `--tatr` specifies whether to also run table transformer



  Text detection was trained on 4x A6000s for 3 days.  It used a diverse set of images as training data.  It was trained from scratch using a modified efficientvit architecture for semantic segmentation.

  Text recognition was trained on 4x A6000s for 2 weeks.  It was trained using a modified donut model (GQA, MoE layer, UTF-16 decoding, layer config changes).



  This work would not have been possible without amazing open source AI work:

  - [Segformer](https://arxiv.org/pdf/2105.15203.pdf) from NVIDIA
  - [EfficientViT](https://github.com/mit-han-lab/efficientvit) from MIT
  - [timm](https://github.com/huggingface/pytorch-image-models) from Ross Wightman
  - [Donut](https://github.com/clovaai/donut) from Naver
  - [transformers](https://github.com/huggingface/transformers) from huggingface
  - [CRAFT](https://github.com/clovaai/CRAFT-pytorch), a great scene text detection model

  Thank you to everyone who makes open source AI possible.


pkgId: 4e448dec5e2f7904ff1c2eb5045a68ad1aa1e408326c8d39f68fb17be505c460
name: python-svada-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for svada
url: https://pypi.org/project/svada/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-svada-2.2.0-1.src.rpm
location_href: Packages/python-svada-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  `svada` is a general-purpose parser for quickly and efficiently parsing CMSIS SVD files into concise objects for use in various applications.

  Contents:

  * [Building and installing from source]
  * [Contributing]
  	- [Code style]
  	- [Virtual environments]


  [Building and installing from source]: #building-and-installing-from-source

  Make sure that your environment is using the latest `build` package from PyPA,
  then invoke it to build the package from the `setup.cfg` file:

  ```
  python3 -m pip install --user -U build
  python3 -m build
  ```

  This will generate both `tar.gz` and `.whl` artifacts for the current version, either of which can be used for installing from the command line:

  ```
  python3 -m pip install dist/svada-X.Y.Z-py3-none-any.whl
  ```


  [Contributing]: #contributing


  [Code style]: #code-style

  This project uses [black] and [pylint] for aligning source code with PEP standards and keeping to a single, common format across the codebase.
  These can be installed via:

  ```
  python3 -m pip install -r scripts/requirements-test.txt
  ```

  To more easily facilitate this, the repository contains the `scripts/pre-commit` hook script that can be placed in your local `.git/hooks` folder.
  This script will block committed code that fails formatting and linting checks by these programs, ensuring that new contributions align to the policies before being pushed and caught by CI.

  The hook script has options that can be added to `.gitconfig` to further customize the behavior.
  For example, a specific `.pylintrc` file can be used for linting by setting this option locally:

  ```

  [hooks]
  	pylintrc=/home/username/.pylintrc
  ```

  It is required to do this for all developers and contributors of this project to keep source code aligned across files.

  [black]: https://pypi.org/project/black/
  [pylint]: https://pypi.org/project/pylint/


  [Virtual environments]: #virtual-environments

  During development, it is strongly recommended to have this package installed in a separate virtual environment for easily testing local changes without continuous installation and uninstallation.
  You can find the official documentation about virtual environments in Python and how to use them on their [official venv tutorial page][venv-tutorial].

  To use the tool in a virtual environment, do the following:

  1. Create and activate a virtual environment:

  ```
  python3 -m venv my_venv
  ```

  Alternatively, Python3's [virtualenv] package can also create the same virtual environments, and offers some extra features from the built-in [venv].

  2. Create a dynamic installation of the package, running the setup script with the `develop` argument from the repository root:

  ```
  python3 setup.py develop
  ```

  This installs the package using always the latest changes of its source files, including when invoked through its command-line executables.
  `setup.py` automatically grabs build and metadata information from `setup.cfg` and `pyproject.toml`.

  To uninstall the dynamic package version installed with `develop`, re-run the command with the `--uninstall` or `-u` option.

  [venv-tutorial]: https://docs.python.org/3/tutorial/venv.html
  [virtualenv]: https://virtualenv.pypa.io/en/latest/
  [venv]: https://docs.python.org/3/library/venv.html

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


pkgId: e77c13a8f238b2b8fa3a66699b4647b35dbfc5bc8bbf6dd869bc92484888eaf4
name: python-swarmit-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for swarmit
url: https://github.com/DotBots/swarmit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swarmit-0.2.0-1.src.rpm
location_href: Packages/python-swarmit-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
   

   SwarmIT provides a embedded C port for nRF53 as well as Python based services to
   easily build and deploy a robotic swarm infrastructure testbed.
   ARM TrustZone is used to create a sandboxed user environment on each device
   under test, without requiring a control co-processor attached to it.



  - Experiment management: start, stop, monitor and status check
  - Deploy a custom firmware on all or on a subset of robots of a swarm testbed
  - Resilient robot state: even when crashed by buggy user code, the robot can be reprogrammed remotely and wirelessly





  SwarmIT embedded C code can be built using
  [Segger Embedded Studio (SES)](https://www.segger.com/products/development-tools/embedded-studio/).

  To provision a device, follow the following steps:
  1. open [netcore.emProject](device/network_core/netcore.emProject)
  and [bootloader.emProject](device/bootloader/bootloader.emProject) in SES
  2. build and load the netcore application on the nRF53 network core,
  3. build and load the bootloader application on the nRF53 application core.

  The device is now ready.



  The communication between the computer and the swarm devices is performed via a
  gateway board connected via USB to the computer.
  The gateway board is a Nordic nRF53840DK.

  The firmware to run on the gateway can also be compiled and flash using SES.
  The SES project to open is located at [gateway.emProject](gateway/gateway.emProject).

  After flashing the gateway firmware, LED1 on the DK should blink fast during 1s.



  The Python CLI script provides commands for flashing, starting and stopping user
  code on the device, as well as monitoring and checking the status of devices
  in the swarm.

  The Python CLI script connects via a virtual COM port to the gateway connected to
  the computer.

  The Python CLI script is available on PyPI. Install it using:

  ```
  pip install swarmit
  ```

  Default usage:

  ```
  swarmit --help
  Usage: swarmit [OPTIONS] COMMAND [ARGS]...

  Options:
    -p, --port TEXT         Serial port to use to send the bitstream to the
                            gateway. Default: /dev/ttyACM0.
    -b, --baudrate INTEGER  Serial port baudrate. Default: 1000000.
    -d, --devices TEXT      Subset list of devices to interact with, separated
                            with ,
    --help                  Show this message and exit.

  Commands:
    flash
    monitor
    start
    status
    stop
  ```


pkgId: 7d854932443ad949159e34dd91e8246752fb428cbbfa93a492c59a96c8ad5cb9
name: python-swarms-help
arch: noarch
version: 6.6.6
epoch: 0
release: 1
summary: Development documents and examples for swarms
url: https://github.com/kyegomez/swarms
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swarms-6.6.6-1.src.rpm
location_href: Packages/python-swarms-help-6.6.6-1.noarch.rpm
checksum_type: sha256
description:
  - `python3.10` or above!
  - `$ pip install -U swarms` And, don't forget to install swarms!
  - `.env` file with API keys from your providers like `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`
  -  Set an `.env` Variable with your desired workspace dir: `WORKSPACE_DIR="agent_workspace"` or do it in your terminal with `export WORKSPACE_DIR="agent_workspace"`
  -  Finally, `swarms onboarding` to get you started.

  Refer to our documentation for production grade implementation details.
  | Section              | Links                                                                                      |
  |----------------------|--------------------------------------------------------------------------------------------|
  | Installation    | [Installation](https://docs.swarms.world/en/latest/swarms/install/install/)                                                            |
  | Quickstart | [Get Started](https://docs.swarms.world/en/latest/swarms/install/quickstart/)                                                 |
  | Agent Internal Mechanisms | [Agent Architecture](https://docs.swarms.world/en/latest/swarms/framework/agents_explained/)                                                 |
  | Agent API | [Agent API](https://docs.swarms.world/en/latest/swarms/structs/agent/)                                                 |
  | Integrating External Agents Griptape, Autogen, etc | [Integrating External APIs](https://docs.swarms.world/en/latest/swarms/agents/external_party_agents/)                                                 |
  | Creating Agents from YAML | [Creating Agents from YAML](https://docs.swarms.world/en/latest/swarms/agents/create_agents_yaml/)                                                 |
  | Why You Need Swarms | [Why MultiAgent Collaboration is Necessary](https://docs.swarms.world/en/latest/swarms/concept/why/)                                                 |
  | Swarm Architectures Analysis | [Swarm Architectures](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/)                                                 |
  | Choosing the Right Swarm for Your Business Problem¶ | [CLICK HERE](https://docs.swarms.world/en/latest/swarms/concept/swarm_architectures/)                                                 |
  | AgentRearrange Docs| [CLICK HERE](https://docs.swarms.world/en/latest/swarms/structs/agent_rearrange/)                                                 |

  Install the following packages with copy and paste
  ```bash
  $ pip3 install -U swarms swarm-models swarms-memory
  ```

  Now that you have downloaded swarms with `pip3 install -U swarms`, we get access to the `CLI`. Get Onboarded with CLI Now with:
  ```bash
  swarms onboarding
  ```
  You can also run this command for help:
  ```bash
  swarms help
  ```


pkgId: beeffc9afabb6bbf722b94ab0767bef8c0528378d9e9411637ad627abfd8241a
name: python-swekit-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for swekit
url: https://github.com/composiohq/composio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swekit-0.3.2-1.src.rpm
location_href: Packages/python-swekit-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://composio.dev//#gh-dark-mode-only">
      <img src="../docs/imgs/composio_white_font.svg" width="318px" alt="Composio logo" />
    </a>
    <a href="https://composio.dev//#gh-light-mode-only">
      <img src="../docs/imgs/composio_black_font.svg" width="318px" alt="Composio Logo" />
    </a>
  </p>
  <p align="center">
    <a href="https://pypi.org/project/composio-core/">
    <img alt="PyPI" src="https://img.shields.io/pypi/v/composio_core?label=Latest&style=plastic&logo=pypi&color=blue&cacheSeconds=60&logoColor=white">
    </a>
    <a href="https://www.npmjs.com/package/composio-core">
    <img alt="NPM" src="https://img.shields.io/npm/v/composio-core?style=plastic&logo=npm&logoColor=white&label=latest&color=blue&cacheSeconds=60">
    </a>
    <a href="https://pypi.org/project/composio-core/">
    <img alt="Downloads" src="https://img.shields.io/pypi/dm/composio-core?label=Downloads&style=plastic&logo=github&color=blue&cacheSeconds=60">
    </a>

  </p>

  <h2 align="center"><i>
    Production Ready Toolset for AI Agents
  </i></h2>

  <h4 align="center">Build Software engineering Agents fast and easy!
  </h4>
  <div align="center" style="font-size: 40px; font-weight: bold;">
    <a href="https://docs.composio.dev/swekit/introduction" rel="dofollow">SWEKIT Docs »</a>
  </div>

  <hr>
  <div align="center">
  <p >
      <b>✨ Socials >></b>
      <a href="https://dub.composio.dev/JoinHQ">Discord</a> <b>|</b>
      <a href="https://www.youtube.com/@Composio">Youtube</a> <b>|</b>
      <a href="https://twitter.com/composiohq">Twitter</a> <b>|</b>
      <a href="https://www.linkedin.com/company/composio-dev"> Linkedin </a>
  </p>
  <p align="center">
      <b>⛏️ Contribute >></b>
      <a href="https://github.com/composiodev/composio/issues/new?assignees=&labels=type%3A+bug&template=bug_report.yml&title=%F0%9F%90%9B+Bug+Report%3A+">Report Bugs</a> <b>|</b>
      <a href="https://github.com/composiodev/composio/issues/new?assignees=&labels=feature&template=feature_request.yml&title=%F0%9F%9A%80+Feature%3A+">Request Feature</a> <b>|</b>
      <a href="https://github.com/composiodev/composio/blob/master/CONTRIBUTING.md">Contribute</a>
  </p>
  </div>




  - [📋 Table of contents](#-table-of-contents)
  - [Table of Contents](#table-of-contents)
  - [Overview](#overview)
  - [Dependencies](#dependencies)
  - [Getting Started](#getting-started)
    - [Creating a new agent](#creating-a-new-agent)
    - [Workspace Environment](#workspace-environment)
    - [Customising the workspace environment](#customising-the-workspace-environment)
    - [Running the Benchmark](#running-the-benchmark)



  `swekit` is a framework for building SWE agents on by utilising composio tooling ecosystem. SWE Kit allows you to

  - Scaffold agents which works out-of-the-box with choice of your agentic framework, `crewai`, `llamaindex`, etc...
  - Tools to add or optimise your agent's abilities
  - Benchmark your agents against `SWE-bench`



  Before getting started, ensure you have the following set up:

  1. **Installation**:

     ```
     pip install swekit composio-core
     ```

  2. **Install agentic framework of your choice and the Composio plugin for the same**:
     Here we're using `crewai` for the example:

     ```
     pip install crewai composio-crewai
     ```

  3. **GitHub Access Token**:

     The agent requires a github access token to work with your repositories, You can create one at https://github.com/settings/tokens with necessary permissions and export it as an environment variable using `export GITHUB_ACCESS_TOKEN=<your_token>`

  4. **LLM Configuration**:
     You also need to setup API key for the LLM provider you're planning to use. By default the agents scaffolded by `swekit` uses `openai` client, so export `OPENAI_API_KEY` before running your agent





  1. Scaffold your agent using:

     ```
     swekit scaffold <type> -f <framework> -o <path>
     ```

     - `<type>` can be `swe` or `pr_review` depending on the use-case
     - `<framework>` can be `crewai` or `langgraph`. Support for more frameworks coming soon!

     This creates a new agent in `<path>/agent` with four key files:

     - `main.py`: Entry point to run the agent on your issue
     - `agent.py`: Agent definition (edit this to customise behaviour)
     - `prompts.py`: Agent prompts
     - `benchmark.py`: SWE-Bench benchmark runner

  2. Run the agent:
     ```
     cd agent
     python main.py
     ```
     You'll be prompted for the repository name and issue.



  The SWE-agent runs in Docker by default for security and isolation. This sandboxes the agent's operations, protecting against unintended consequences of arbitrary code execution.

  The composio toolset has support for different types of workspaces.

  1. Host - This will run on the host machine.

  ```python
  from composio import ComposioToolSet, WorkspaceType

  toolset = ComposioToolSet(
      workspace_config=WorkspaceType.Host()
  )
  ```

  2. Docker - This will run inside a docker container

  ```python
  from composio import ComposioToolSet, WorkspaceType

  toolset = ComposioToolSet(
      workspace_config=WorkspaceType.Docker()
  )
  ```

  On the docker container you can configure and expose the port for development
  as per your requirements. You can also use `workspace.as_prompt()` method to
  generate a workspace description for setting up your agent.

  ```python
  from composio import ComposioToolSet, WorkspaceType

  toolset = ComposioToolSet(
      workspace_config=WorkspaceType.Docker(
          ports={
              8001: 8001,
          }
      )
  )
  ```

  You can read more about configuring docker ports [here](https://docker-py.readthedocs.io/en/stable/containers.html#docker.models.containers.ContainerCollection.run).

  3. E2B - This will run inside a E2B Sandbox

  ```python
  from composio import ComposioToolSet, WorkspaceType

  toolset = ComposioToolSet(
      workspace_config=WorkspaceType.E2B(),
  )
  ```

  4. FlyIO - This will run inside a FlyIO machine

  ```python
  from composio import ComposioToolSet, WorkspaceType

  toolset = ComposioToolSet(
      workspace_config=WorkspaceType.FlyIO(),
  )
  ```

  FlyIO also allows for configuring ports for development/deployment.

  ```python
  from composio import ComposioToolSet, WorkspaceType

  composio_toolset = ComposioToolSet(
      workspace_config=WorkspaceType.FlyIO(
          image="composio/composio",
          ports=[
              {
                  "ports": [
                      {"port": 443, "handlers": ["tls", "http"]},
                  ],
                  "internal_port": 80,
                  "protocol": "tcp",
              }
          ],
      )
  )
  ```

  You can read more abour configuring network ports on flyio machine [here](https://fly.io/docs/machines/api/machines-resource/#create-a-machine-with-services)




  The workspace environment contains following environment variables by default

  - `COMPOSIO_API_KEY`: The composio API key for interacting with composio API.
  - `COMPOSIO_BASE_URL`: Base URL for composio API server.
  - `GITHUB_ACCESS_TOKEN`: Github access token for the agent.
  - `ACCESS_TOKEN`: Access token for composio tooling server.

  If you want to provide additional environment configuration you can use `environment` argument when creating a workspace configuration.

  ```python
  composio_toolset = ComposioToolSet(
      workspace_config=WorkspaceType.Docker(
          environment={
              "SOME_API_TOKEN": "<SOME_API_TOKEN>",
          }
      )
  )
  ```



  [SWE-Bench](https://www.swebench.com/) is a comprehensive benchmark designed to evaluate the performance of software engineering agents. It comprises a diverse collection of real-world issues from popular Python open-source projects, providing a robust testing environment.

  To run the benchmark:

  1. Ensure Docker is installed and running on your system.
  2. Execute the following command:
     ```
     cd agent
     python benchmark.py --test-split=<test_split>
     ```
     - By default, `python benchmark.py` runs only 1 test instance.
     - Specify a test split ratio to run more tests, e.g., `--test-split=1:300` runs 300 tests.

  To run the benchmarks in `E2B` or `FlyIO` sandbox, you can set the `workspace_env` in the `evaluate` function call in `benchmark.py`


  ```python
  from composio import WorkspaceType

  (...)

      evaluate(
          bench,
          dry_run=False,
          test_range=test_range,
          test_instance_ids=test_instance_ids_list,
          workspace_env=WorkspaceType.E2B
      )
  ```

  To use `E2B` or `FlyIO` sandboxes you'll require API key for respective platforms, to use `E2B` export your API key as `E2B_API_KEY` and to use `FlyIO` export your API token as `FLY_API_TOKEN`.

  **Note**: We utilize [SWE-Bench-Docker](https://github.com/aorwall/SWE-bench-docker) to ensure each test instance runs in an isolated container with its specific environment and Python version.

  To extend the functionality of the SWE agent by adding new tools or extending existing ones, refer to the [Development Guide](DEVELOPMENT.md).


pkgId: 14d730e79be7c8d9055de9a93ffee02bc2a89a446f6240f256e06408252e3995
name: python-swh.alter-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for swh.alter
url: https://gitlab.softwareheritage.org/swh/devel/swh-alter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swh.alter-1.3.0-1.src.rpm
location_href: Packages/python-swh.alter-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  It happens for Software Heritage to record content that either should not
  have been archived or should no longer be archived. ``swh-alter`` holds
  the tools necessary to prune or make inaccessible content from Software
  Heritage archive.


pkgId: 1c597db3fa39840ac819d6d86537570062ab35161b6c570e4fbbc33287519f65
name: python-swh.auth-help
arch: noarch
version: 0.10.0
epoch: 0
release: 1
summary: Development documents and examples for swh.auth
url: https://gitlab.softwareheritage.org/swh/devel/swh-auth
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swh.auth-0.10.0-1.src.rpm
location_href: Packages/python-swh.auth-help-0.10.0-1.noarch.rpm
checksum_type: sha256
description:
  ``swh-auth`` is a set of utility libraries related to user authentication
  in applications and services based on the use of `Keycloak`_ and `OpenID Connect`_.
  `Keycloak`_ is an open source software enabling single sign-on (SSO) with identity
  and access management.
  `OpenID Connect`_ (OIDC) is an authentication layer on top of `OAuth 2.0`_, widely
  used in modern web applications and services.
  ``swh-auth`` notably offers the following features:
  - the ``swh.auth.keycloak.KeycloakOpenIDConnect`` class to ease the
    interaction with a Keycloak server
  - a ``pytest`` plugin with the ``keycloak_oidc`` fixture to mock Keycloak
    responses in unit tests
  - generic backends, views and middlewares to easily plug OpenID Connect authentication
    in any `Django`_ or `Django REST framework`_ application


pkgId: fbdcfb0cf6a474a43cb246939ac9a48f79dd802e80de72f47458f88992193a83
name: python-swh.graph-help
arch: noarch
version: 6.3.0
epoch: 0
release: 1
summary: Development documents and examples for swh.graph
url: https://gitlab.softwareheritage.org/swh/devel/swh-graph
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swh.graph-6.3.0-1.src.rpm
location_href: Packages/python-swh.graph-help-6.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Tooling and services, collectively known as ``swh-graph``, providing fast
  access to the graph representation of the `Software Heritage
  <https://www.softwareheritage.org/>`_
  `archive <https://archive.softwareheritage.org/>`_.  The service is in-memory,
  based on a compressed representation of the Software Heritage Merkle DAG.


pkgId: efaa93edc3c70122da7e1e5f65ea045bb2add0c51129f484b6f8e0fdb5bb54ae
name: python-swift_comet_pipeline-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for swift_comet_pipeline
url: https://pypi.org/project/swift_comet_pipeline/
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-swift_comet_pipeline-0.1.3-1.src.rpm
location_href: Packages/python-swift_comet_pipeline-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A package to analyze UVOT image data of comets from the Swift satellite (https://www.swift.ac.uk/).  A related project at https://github.com/sjoset/swift_portal_downloader automates the acquisition of data appropriate for this pipeline.



  https://www.python-poetry.org


  ```
      conda create --name env_name_here python=3.11
      conda activate env_name_here
  ```




  In the repository's directory:
  ```
      poetry install
  ```


  Configuration is stored in a YAML file with the following entries to start a project:
  ```
      swift_data_path: /path/to/swift/data/
      project_path: /path/to/where/to/save/results
      jpl_horizons_id: String identifying comet that JPL Horizons can use to find comet orbital information
      vectorial_model_quality: String to select the calculation quality of the models used to determine water production: may be low, medium, high, or very_high
      vectorial_model_backend: [sbpy, rust]
  ```
  By default the file **config.yaml** in the current directory is assumed unless specified otherwise on the command line.

  An example config might look like this:

  ```
      swift_data_path: /Users/user/swift_data_downloads/c2013us10
      project_path: /Users/user/analysis_c2013us10
      jpl_horizons_id: C/2013 US10
      vectorial_model_quality: very_high
      vectorial_model_backend: sbpy
  ```


pkgId: 36f1506e657f37a675c539693805e2b3a607cc3c1da919bf13dd07e5bb621fc1
name: python-sxolar-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for sxolar
url: https://github.com/JWKennington/sxolar
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sxolar-0.1.1-1.src.rpm
location_href: Packages/python-sxolar-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![sXolar Logo](sxolar.png)

  [![PyPI version](https://badge.fury.io/py/sxolar.svg)](https://badge.fury.io/py/sxolar)
  ![Build](https://github.com/JWKennington/sxolar/actions/workflows/build.yml/badge.svg)
  [![CodeFactor](https://www.codefactor.io/repository/github/jwkennington/sxolar/badge)](https://www.codefactor.io/repository/github/jwkennington/sxolar)
  [![codecov](https://codecov.io/gh/JWKennington/sxolar/graph/badge.svg?token=s3uaJfzV0q)](https://codecov.io/gh/JWKennington/sxolar)
  [![Documentation Status](https://readthedocs.org/projects/sxolar/badge/?version=latest)](https://sxolar.readthedocs.io/en/latest/?badge=latest)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sxolar)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/sxolar)
  ![PyPI - License](https://img.shields.io/pypi/l/sxolar)



  This repository contains a collection of tools for working with Arxiv. The tools are written in Python and are designed
  to be used in any python application. The tools are designed to be used in place of
  the [Arxiv API](https://arxiv.org/help/api/index), with a simpler interface and more features, including

  - Searching and downloading papers
  - Creating personalized search indices for easy repeated searches
  - Exploring the network of citations between papers

  Ultimately, the goal of this project is to provide a set of tools that can be used to build a personalized search engine
  for academic papers, with the ability to search, download, and explore the network of citations between papers.



  To install the package, you can use pip:

  ```bash
  pip install sxolar
  ```



  Thank you to arXiv for use of its open access interoperability.


pkgId: 9f91727ce3816c985d859068ed09b50984cfb8db33c7effdbfe01edcf52095f9
name: python-sy-ofb-python-sdk-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for sy-ofb-python-sdk
url: https://pypi.org/project/sy-ofb-python-sdk/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sy-ofb-python-sdk-0.2.0-1.src.rpm
location_href: Packages/python-sy-ofb-python-sdk-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  The `ofb-python-sdk` provides a Python interface for interacting with Microsoft's OneDrive. It simplifies the process of authenticating, uploading, downloading, and managing files on OneDrive through a simple and intuitive API. This SDK is particularly useful for developers who need to integrate OneDrive functionalities within their Python applications efficiently.



  - Authentication with OAuth2
  - Upload files to OneDrive (supports both small and large files)
  - Download files from OneDrive
  - Create and manage folders
  - Delete files and folders
  - Handle file conflicts with customizable behavior
  - Rich progress bar integration for file uploads



  Install `ofb-python-sdk` using pip:

  ```bash
  pip install sy-ofb-python-sdk
  ```



  See the [EXAMPLE.md](https://github.com/shing-yu/ofb-python-sdk/blob/main/EXAMPLE.md)



  Contributions are welcome! Please read the [CONTRIBUTING.md](https://github.com/shing-yu/ofb-python-sdk/blob/main/CONTRIBUTING.md) for guidelines on how to contribute to this project.



  This project is licensed under the MIT License - see the [LICENSE](https://github.com/shing-yu/ofb-python-sdk/blob/main/LICENSE) file for details.



  If you need assistance or encounter any bugs, please open an issue on the project's [GitHub issues page](https://github.com/shing-yu/ofb-python-sdk/issues).


pkgId: 847d3ec2b95828b50c0ea0b5a53dab80efe60bf465d1968dccb4b1fcb48cadb4
name: python-symclosestwannier-help
arch: noarch
version: 1.9.3
epoch: 0
release: 1
summary: Development documents and examples for symclosestwannier
url: https://github.com/CMT-MU/SymClosestWannier
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-symclosestwannier-1.9.3-1.src.rpm
location_href: Packages/python-symclosestwannier-help-1.9.3-1.noarch.rpm
checksum_type: sha256
description:
  - **Overview**:
      A Python library to create Symmetry-adapted Closest Wannier (SymCW) tight-binding models based on the Symmetry-Adapted Multipole Basis (SAMB) [1] and the Closest Wannier formalism developed by Taisuke Ozaki [2].

      > [1] Hiroaki Kusunose, Rikuto Oiwa, and Satoru Hayami, Symmetry-adapted modeling for molecules and crystals, Phys. Rev. B 107, 195118 (2023).
      > DOI: https://doi.org/10.1103/PhysRevB.107.195118.<br>
      > [2] Taisuke Ozaki, Closest Wannier functions to a given set of localized orbitals, Phys. Rev. B 110, 125115, (2024).
      > URL: https://arxiv.org/abs/2306.15296v2.

  - **Authors**: Rikuto Oiwa

  - **Installation**: SymClosestWannier can be installed from PyPI using pip on Python >= 3.9:
      ```
      pip install symclosestwannier
      ```
      You can also visit [PyPI](https://pypi.org/project/symclosestwannier/) or [GitHub](https://github.com/CMT-MU/SymClosestWannier/) to download the source.

  - **Citing SymClosestWannier**: If you are using SymClosestWannier in your scientific research, please help our scientific visibility by citing our work:

      > Rikuto Oiwa, Akane Inda, Satoru Hayami, Takuya Nomoto, Ryotaro Arita, and Hiroaki Kusunose, in preparation.<br>
      > DOI: []()

  - **Requirements**:
    - Symmetry-Adapted Multipole Basis (SAMB) for molecular or crystal are optionally generated by [MultiPie](https://github.com/CMT-MU/MultiPie).
    - MultiPie library optionally requires [TeXLive](https://www.tug.org/texlive/) environment to create LaTeX and PDF files.
    - Molecular or crystal structure files are optionally generated by [QtDraw](https://github.com/CMT-MU/QtDraw).

  - **To Do**:
    - add function to read seedname.uHu, seedname.uIu files.
    - add SHC, ME response functions.
    - add lindhard function.


pkgId: 1a500892d902645e469f9f7fe4174aa668a6562212a79a35157a8ccd8252ea2e
name: python-symmetria-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for symmetria
url: https://github.com/VascoSch92/symmetria
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-symmetria-0.3.1-1.src.rpm
location_href: Packages/python-symmetria-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [Quickstart](#quickstart)
  - [Command Line Interface](#command-line-interface)


pkgId: 0a95d3924f77a5ce21dc0b58de9a991a6a40b1b26f1c6d41b276d1be33c0f3b8
name: python-sympt-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for sympt
url: https://pypi.org/project/sympt/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sympt-1.0.0-1.src.rpm
location_href: Packages/python-sympt-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  1. [Overview](#overview)
  2. [Key Features](#key-features)
  3. [Installation](#installation)
  4. [Usage](#usage)
     - [Basic Workflow](#basic-workflow)
     - [Examples](#examples)
  5. [Core Classes](#core-classes)
     - [RDSymbol](#rdsymbol)
     - [RDBasis](#rdbasis)
     - [EffectiveFrame](#effectiveframe)
     - [Block](#block)
  6. [Algorithms](#algorithms)
     - [Schrieffer-Wolff Transformation (SWT)](#schrieffer-wolff-transformation-swt)
     - [Full-Diagonalization (FD)](#full-diagonalization-fd)
     - [Arbitrary Coupling Elimination (ACE)](#arbitrary-coupling-elimination-ace)
     - [Least-Action Multi-Block Transformations](#least-action-multi-block-transformations)
  7. [Advanced Tools](#advanced-tools)
  8. [Contributing](#contributing)

rpm_license:
  MIT License  Copyright (c) 2024 QCode  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: fd10335b35bbf85b7955321c013a8cc14f40b2ca58651c70e5d60d9c59619725
name: python-synapse-help
arch: noarch
version: 2.192.0
epoch: 0
release: 1
summary: Development documents and examples for synapse
url: https://vertex.link
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-synapse-2.192.0-1.src.rpm
location_href: Packages/python-synapse-help-2.192.0-1.noarch.rpm
checksum_type: sha256
description:
  Synapse is a versatile central intelligence system created to support analyst teams in every stage of the intelligence life cycle.
  |codecov|_ |circleci|_ |rtd|_


pkgId: d13334357cb7012ff5f6238ab8e121c490ab852b59b77d45f2113ba9a85d3c74
name: python-synapse-sdk-help
arch: noarch
version: 1.0.0a20
epoch: 0
release: 1
summary: Development documents and examples for synapse-sdk
url: https://pypi.org/project/synapse-sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-synapse-sdk-1.0.0a20-1.src.rpm
location_href: Packages/python-synapse-sdk-help-1.0.0a20-1.noarch.rpm
checksum_type: sha256
description:
  This is the SDK to develop synapse plugins





  ```bash
   $ find . -name "*.py" | xargs xgettext -o messages.pot
  ```


  ```bash
   $ msginit -l ko -i messages.pot -o locale/ko/LC_MESSAGES/messages.po
   $ msginit -l en -i messages.pot -o locale/en/LC_MESSAGES/messages.po
  ```



  ```bash
   $ msgfmt locale/ko/LC_MESSAGES/messages.po -o locale/ko/LC_MESSAGES/messages.mo
   $ msgfmt locale/en/LC_MESSAGES/messages.po -o locale/en/LC_MESSAGES/messages.mo
  ```


pkgId: ae26dc0d18de23916d30c9eafbbfcb27ba2d1eca4be3d84304ba246b5217c302
name: python-synderm-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for synderm
url: https://github.com/manrai/synthetic-derm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-synderm-0.1.2-1.src.rpm
location_href: Packages/python-synderm-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://synthetic-derm.readthedocs.io/en/latest/index.html)
  [![Dataset](https://img.shields.io/badge/dataset-HuggingFace-yellow.svg)](https://huggingface.co/datasets/tbuckley/synthetic-derm-1M)

  Synderm is a package designed to enhance image classification tasks using synthetic data generation. It provides tools to generate high-quality synthetic images using diffusion models, fine-tune these models on your specific datasets, and seamlessly integrate synthetic data into your training pipelines to improve classifier performance.



  - [Features](#features)
  - [Models](#models)
  - [Installation](#installation)
  - [Quick Start](#quick-start)
    - [1. Creating the Dataset](#1-creating-the-dataset)
    - [2. Training the Synthetic Image Generator](#2-training-the-synthetic-image-generator)
    - [3. Generate Synthetic Images](#3-generate-synthetic-images)
    - [4. Augmenting the Classifier with Synthetic Images](#4-augmenting-the-classifier-with-synthetic-images)
  - [Example Scripts](#example-scripts)
  - [Data](#data)
  - [Contributing](#contributing)
  - [License](#license)



  - **Synthetic Data Generation:** Utilize diffusion models to create high-quality synthetic images tailored to your dataset.
  - **Fine-Tuning:** Adapt pre-trained diffusion models to your specific classes using minimal real data.
  - **Dataset Augmentation:** Combine real and synthetic data effortlessly to enhance your training datasets.
  - **Seamless Integration:** Compatible with popular deep learning frameworks like PyTorch and FastAI.
  - **Flexible Configuration:** Easily customize prompts, training parameters, and data splits to fit your project's needs.



  Synderm directly supports the following models for image generation:

  - **Text-to-image:** [`stabilityai/stable-diffusion-2-1-base`](https://huggingface.co/stabilityai/stable-diffusion-2-1-base)
  - **Inpainting/outpainting:** [`runwayml/stable-diffusion-inpainting`](https://huggingface.co/runwayml/stable-diffusion-inpainting)

  Other diffusion models can be used but are currently untested.

  All functions assume that the training and validation datasets return entries with an `image`, `label`, and `id` field. If your dataset does not conform to this structure, please adjust it accordingly (see examples below).


  ```bash

  pip install synderm


  pip install -e .
  ```

  *Ensure you have [PyTorch](https://pytorch.org/) and [FastAI](https://fast.ai/) installed.*





  Synderm requires datasets to return entries with `image`, `label`, and `id` fields. Here's an example of how to create a custom dataset:

  ```python
  from torch.utils.data import Dataset
  from PIL import Image
  from pathlib import Path
  import os

  class SampleDataset(Dataset):
      def __init__(self, dataset_dir, split="train"):
          self.dataset_dir = Path(dataset_dir)
          self.image_paths = []
          self.labels = []
          self.split = split

          
          data_dir = self.dataset_dir / self.split
          for class_name in os.listdir(data_dir):
              class_dir = data_dir / class_name
              if not class_dir.is_dir():
                  continue

              
              for img_name in os.listdir(class_dir):
                  if img_name.lower().endswith('.png'):
                      self.image_paths.append(class_dir / img_name)
                      self.labels.append(class_name)

      def __len__(self):
          return len(self.image_paths)

      def __getitem__(self, idx):
          image_path = self.image_paths[idx]
          label = self.labels[idx]

          
          image = Image.open(image_path).convert('RGB')
          image_name = image_path.stem

          return {"id": image_name, "image": image, "label": label}
  ```



  Fine-tune a diffusion model using your dataset to generate synthetic images:

  ```python
  from synderm.synderm.fine_tune.text_to_image_diffusion import fine_tune_text_to_image

  output_dir = os.path.join(EXPERIMENT_DIR, "dreambooth-outputs")

  fine_tune_text_to_image(
      train_dataset=train_dataset,
      pretrained_model_name_or_path="stabilityai/stable-diffusion-2-1-base",
      instance_prompt="An image of an English Springer",
      validation_prompt_format="An image of an English Springer",
      output_dir=output_dir,
      label_filter="English_springer",
      resolution=512,
      train_batch_size=4,
      gradient_accumulation_steps=1,
      learning_rate=5e-6,
      lr_scheduler="constant",
      
  )
  ```



  Use the fine-tuned diffusion model to generate a set of synthetic images

  ```python
  model_path = os.path.join(EXPERIMENT_DIR, "dreambooth-outputs", "English_springer")
  image_output_path = os.path.join(EXPERIMENT_DIR, "generations")

  generate_synthetic_dataset(
      dataset= train_dataset,
      model_path = model_path,
      output_dir_path = image_output_path,
      generation_type = "text-to-image",
      label_filter = "English_springer",
      instance_prompt = "An image of an English Springer",
      batch_size = 16,
      start_index = 0,
      num_generations_per_image = 10,
      guidance_scale = 3.0,
      num_inference_steps = 50,
      strength_inpaint = 0.970,
      strength_outpaint = 0.950,
      mask_fraction = 0.25
  )
  ```




  Combine real and synthetic data to train and evaluate the classifier:

  ```python
  from synderm.utils.utils import synthetic_train_val_split

  synthetic_dataset = SyntheticDataset(os.path.join(image_output_path, "text-to-image"))

  train, val = synthetic_train_val_split(
      real_data=train_dataset,
      synthetic_data=synthetic_dataset,
      per_class_test_size=5,
      random_state=42,
      mapping_real_to_synthetic="id"
  )
  ```



  We include several example scripts at `synderm/example_scripts`:
  - `train_diffusion_model_text_to_image.py`: Script for fine-tuning the Stable Diffusion model conditioned on a text prompt.
  - `train_diffusion_model_inpaint.py`: Script for fine-tuning the Stable Diffusion model conditioned on a text prompt, and random masks of an image.
  - `generate_synthetic_images.py`: Script for generating synthetic images using fine-tuned models
  - `sample_datasets.py`: A few example Torch datasets that are compatible with this package. Includes a `FitzDataset` sample that can be used once the original images are downloaded (see [Data](#data))



  The original Fitzpatrick17k dataset can be installed from [this GitHub link.](https://github.com/mattgroh/fitzpatrick17k) The images need to be downloaded from original source. We include clean training and held-out splits in the `fitz_metadata` folder.



  Contributions are welcome! Please open an issue or submit a pull request for any improvements or bug fixes.



  This project is licensed under the [MIT License](LICENSE).


pkgId: 3701827b17d18da11e85bc7450deafdaac0351abeed919a9721c38c5b972a150
name: python-syneto_api-help
arch: noarch
version: 0.3.11
epoch: 0
release: 1
summary: Development documents and examples for syneto_api
url: https://github.com/SynetoNet/syneto-api
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-syneto_api-0.3.11-1.src.rpm
location_href: Packages/python-syneto_api-help-0.3.11-1.noarch.rpm
checksum_type: sha256
description:
  Syneto Client API library: authentication, storage, virtualization and protection



  ```
  $ pip install syneto-api
  ```



  ```
  from syneto_api import Authentication, Virtualization, Storage, Protection

  auth_api = Authentication(url_base="https://syneto-instance-ip-address/api/auth", insecure_ssl=True)
  response = auth_api.login(username="admin", password="admin")
  jwt = response['jwt']

  virt_api = Virtualization(url_base="https://syneto-instance-ip-address/api/virtualization", insecure_ssl=True)
  virt_api.set_auth_jwt(jwt)
  print(virt_api.get_vms())

  storage_api = Storage(url_base="https://syneto-instance-ip-address/api/storage", insecure_ssl=True)
  storage_api.set_auth_jwt(jwt)
  print(storage_api.get_pools())
  ```



  For conveninence, the base urls for the api endpoints are also accepted as environment variables, please see below.

  ```
  AUTHORIZATION_USER=admin
  AUTHORIZATION_PASS=admin
  AUTHORIZATION_SERVICE=https://syneto-instance-ip-address/api/auth
  VIRTUALIZATION_SERVICE=https://syneto-instance-ip-address/api/virtualization
  STORAGE_SERVICE=https://syneto-instance-ip-address/api/storage
  PROTECTION_SERVICE=https://syneto-instance-ip-address/api/protection
  ```

  If you are using self-signed SSL certificates, set the following env. so that the http request library does not perform ssl verification.

  ```
  ALLOW_INSECURE_SSL=True
  ```


pkgId: 4ff7204c5184199e419d44f82a231c8ffa92d99edb4635044fd883150798ab33
name: python-synqly-help
arch: noarch
version: 0.3.33
epoch: 0
release: 1
summary: Development documents and examples for synqly
url: https://pypi.org/project/synqly/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-synqly-0.3.33-1.src.rpm
location_href: Packages/python-synqly-help-0.3.33-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains the `SynqlyPythonClient` SDK package, which can be used to integrate a Python application with Synqly APIs. All Synqly SDKs require a valid Synqly Organization token to use.

  If you aren't yet a Synqly customer, please feel free to [Schedule a Demo](https://synqly.com/demo/).

  The Python Pydantic type checker can, in cases, be stricter than other SDKs. If you run into any type resolution errors such as the following, please report them on Slack and we'll work on patching it as quickly as possible.

  ```
  Error configuring event logging for Tenant XYZ: 1 validation error for ProviderConfig_Siem
  config
    none is not an allowed value (type=type_error.none.not_allowed)
  ```



  To install the `SynqlyPythonClient` to your local Python environment, run the following command:

  ```bash
  pip3 install git+https://github.com/Synqly/python-sdk.git
  ```


  You should now be able to import packages from the `SynqlyPythonClient` as follows:

  ```python
  from synqly import engine
  from synqly import management as mgmt
  ```

  For more detailed examples of how to use the Synqly Python SDK, please refer to the `examples` directory in this repository. Each sub-directory in `examples` contains a standalone example of how to work with a particular Synqly Connector.



  While the files under `/src` are auto-generated, it can sometimes be useful to install a local copy of the SDK in order to debug issues such as type mismatches. The following command will install the local version of `SynqlyPythonClient`, overriding the upstream repository.

  ```bash
  cd ~/python-sdk

  pip install -e .
  ```


pkgId: 3473572b9ac9c7c69ac6167381fa3b356ae5c6b384084a03bf13454f8950374d
name: python-synthesis-workflow-help
arch: noarch
version: 1.2.3
epoch: 0
release: 1
summary: Development documents and examples for synthesis-workflow
url: https://synthesis-workflow.readthedocs.io
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-synthesis-workflow-1.2.3-1.src.rpm
location_href: Packages/python-synthesis-workflow-help-1.2.3-1.noarch.rpm
checksum_type: sha256
description:
  This project contains several workflows used for neuron synthesis and the validation of this process.
  It is divided into two packages:
  * **synthesis-workflow**, which contains the workflow tasks and tools.
  * **MorphVal**, which is a library used for morphology validation and can be used as a standalone.


pkgId: c3b48d14be91c50c7948e3597f0c910f8125cc6ee6e787a105c60cf138eed8e8
name: python-syspathmodif-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for syspathmodif
url: https://github.com/GRV96/syspathmodif
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-syspathmodif-1.1.1-1.src.rpm
location_href: Packages/python-syspathmodif-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Cette bibliothèque offre des manières concises de modifier la liste `sys.path`.
  L'utilisateur ne devrait pas avoir besoin d'interagir directement avec cette
  liste.



  Les fonctions de `syspathmodif` prennent un chemin de type `str` ou
  `pathlib.Path` comme argument.
  Elles convertissent les arguments de type `pathlib.Path` en `str` puisque
  `sys.path` n'est censée contenir que des chaînes de caractères.

  * `sp_append` ajoute le chemin donné à la fin de `sys.path`.
  * `sp_contains` indique si `sys.path` contient le chemin donné.
  * `sp_remove` enlève le chemin donné de `sys.path`.

  Pour plus d'informations, consultez la documentation des fonctions et les démos
  dans le dépôt de code source.



  This library offers concise manners to modify list `sys.path`.
  The user should not need to directly interact with that list.



  The functions in `syspathmodif` take a path of type `str` or `pathlib.Path`
  as an argument.
  They convert arguments of type `pathlib.Path` to `str` since `sys.path` is
  supposed to contain only character strings.

  * `sp_append` appends the given path to the end of `sys.path`.
  * `sp_contains` indicates whether `sys.path` contains the given path.
  * `sp_remove` removes the given path from `sys.path`.

  For more information, consult the functions' documentation and the demos in the
  source code repository.


pkgId: 2cc3386d29d0c176058c02b7abc28849a01252157afcaa08e94ffa4689ee76f7
name: python-sysprompt-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for sysprompt
url: https://pypi.org/project/sysprompt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-sysprompt-0.1.1-1.src.rpm
location_href: Packages/python-sysprompt-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Sysprompt is a Python library that provides a simple way to interact with the system prompt.



  ```bash
  pip install sysprompt
  ```


pkgId: b4ced5772468a87c69d07ee3463223779db6042c38d39c3baebc92ba9db4a53e
name: python-systemrdl-compiler-debuginfo
arch: aarch64
version: 1.28.0
epoch: 0
release: 1
summary: Debug information for package python-systemrdl-compiler
url: https://pypi.org/project/systemrdl-compiler/
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-systemrdl-compiler-1.28.0-1.src.rpm
location_href: Packages/python-systemrdl-compiler-debuginfo-1.28.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-systemrdl-compiler.
  Debug information is useful when developing applications that use this
  package or when debugging this package.

rpm_license:
  MIT License  Copyright (c) 2018 Alex Mykyta  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: 6f74e96c79d8f0a52293f66f19103136a5ebef07a69baabc26ee51b00a1d7ee9
name: python-systemrdl-compiler-debugsource
arch: aarch64
version: 1.28.0
epoch: 0
release: 1
summary: Debug sources for package python-systemrdl-compiler
url: https://pypi.org/project/systemrdl-compiler/
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-systemrdl-compiler-1.28.0-1.src.rpm
location_href: Packages/python-systemrdl-compiler-debugsource-1.28.0-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-systemrdl-compiler.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.

rpm_license:
  MIT License  Copyright (c) 2018 Alex Mykyta  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: 4464cbf75d1f128af8c2c11fa0761dbb46a2ce028b334d0801029fdb61c017ca
name: python-systemrdl-compiler-help
arch: aarch64
version: 1.28.0
epoch: 0
release: 1
summary: Development documents and examples for systemrdl-compiler
url: https://pypi.org/project/systemrdl-compiler/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-systemrdl-compiler-1.28.0-1.src.rpm
location_href: Packages/python-systemrdl-compiler-help-1.28.0-1.aarch64.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/systemrdl-compiler/badge/?version=latest)](http://systemrdl-compiler.readthedocs.io)
  [![build](https://github.com/SystemRDL/systemrdl-compiler/workflows/build/badge.svg)](https://github.com/SystemRDL/systemrdl-compiler/actions?query=workflow%3Abuild+branch%3Amain)
  [![Coverage Status](https://coveralls.io/repos/github/SystemRDL/systemrdl-compiler/badge.svg?branch=main)](https://coveralls.io/github/SystemRDL/systemrdl-compiler?branch=main)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/systemrdl-compiler.svg)](https://pypi.org/project/systemrdl-compiler)



  The `systemrdl-compiler` project implements a generic compiler front-end for
  Accellera's [SystemRDL 2.0](http://accellera.org/downloads/standards/systemrdl)
  register description language. The goal of this project is to provide a free and
  open compiler that lowers the barrier to entry to using an industry standard
  register description language.

  By providing an elaborated register model that is easy to traverse and query,
  it should be far easier to write custom register space view generators.

  ![overview](https://raw.githubusercontent.com/SystemRDL/systemrdl-compiler/main/docs/img/overview.svg?sanitize=true)


  See the [SystemRDL Compiler Documentation](http://systemrdl-compiler.readthedocs.io) for more details



  If you are looking for a complete SystemRDL command line tool, see the [PeakRDL project](https://peakrdl.readthedocs.io).



  The SystemRDL Compiler is published and distributed under the [MIT License](LICENSE).

rpm_license:
  MIT License  Copyright (c) 2018 Alex Mykyta  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: adf85788d67ba31c44eaebb42dd32c38f6e83db32b1caa8af70d29a7ff214b2f
name: python-t-page-object-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for t-page-object
url: https://www.thoughtful.ai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-t-page-object-0.2.5-1.src.rpm
location_href: Packages/python-t-page-object-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  _Base objects package for t_page_object._

  _Module for BaseApp class._
  - **Class:** `BaseApp`
    > Base class for application or portal objects and their configuration.
    - **Method:** `open_browser`
      > Open browser and set Selenium options.

  _Contains the BasePage class which is the parent class for all page objects in the project._
  - **Class:** `BasePage`
    > Base page class for all page objects in the project.
    - **Method:** `get_element_from_shadow_roots`
      > Get element from nested shadow roots.
          Args:
              roots: The css locators of the shadow root elements, in hierarchal order.
              element_css: The css locator of the element to find.
          Returns:
              The WebElement of the element found.
    - **Method:** `visit`
      > Navigate to the base page URL.
    - **Method:** `wait_for_new_window_and_switch`
      > Function for waiting and switching to new window.
          Args:
              old_window_handles: The list of window handles before the new window is opened.
          Returns:
              The new window handle.
    - **Method:** `wait_page_load`
      > Wait for the page to load by waiting for the verification element to load.
          timeout: The maximum time to wait for the element to be present, in seconds.

  _Contains the EndpointElement class._
  - **Class:** `EndpointElement`
    > This is an Endpoint Element used to build each Page.
    - **Method:** `delete`
      > Sends a DELETE request to the specified URL with optional headers and cookies.
          Args:
              headers: A dictionary containing the request headers. Defaults to an empty dictionary.
              cookies: A dictionary containing the request cookies. Defaults to an empty dictionary.
          Returns:
              The response content if the request is successful
    - **Method:** `get`
      > Sends a GET request to the specified URL with optional headers, cookies, and parameters.
          Args:
              headers: A dictionary containing the request headers. Defaults to an empty dictionary.
              cookies: A dictionary containing the request cookies. Defaults to an empty dictionary.
              params: A dictionary containing the request parameters. Defaults to an empty dictionary.
          Returns:
              The response content if the request is successful.
    - **Method:** `patch`
      > Sends a PATCH request to the specified URL with optional data, JSON, headers, cookies, and parameters.
          Args:
              data: The data to send in the request body. Defaults to None.
              json: The JSON data to send in the request body. Defaults to None.
              headers: A dictionary containing the request headers. Defaults to an empty dictionary.
              cookies: A dictionary containing the request cookies. Defaults to an empty dictionary.
              params: A dictionary containing the request parameters. Defaults to an empty dictionary.
          Returns:
              The response content if the request is successful.
    - **Method:** `post`
      > Sends a POST request to the specified URL with optional data, JSON, headers, cookies, and parameters.
          Args:
              data: The data to send in the request body. Defaults to None.
              json: The JSON data to send in the request body. Defaults to None.
              headers: A dictionary containing the request headers. Defaults to an empty dictionary.
              cookies: A dictionary containing the request cookies. Defaults to an empty dictionary.
              params: A dictionary containing the request parameters. Defaults to an empty dictionary.
          Returns:
              The response content if the request is successful.
    - **Method:** `put`
      > Sends a PUT request to the specified URL with optional data, JSON, headers, cookies, and parameters.
          Args:
              data: The data to send in the request body. Defaults to None.
              json: The JSON data to send in the request body. Defaults to None.
              headers: A dictionary containing the request headers. Defaults to an empty dictionary.
              cookies: A dictionary containing the request cookies. Defaults to an empty dictionary.
              params: A dictionary containing the request parameters. Defaults to an empty dictionary.
          Returns:
              The response content if the request is successful

  _Contains the UIElement class._
  - **Class:** `UIElement`
    > This is an UI Element used to build each Page.
    - **Method:** `format_xpath`
      > If using a dynamic xpath, this method formats the xpath string.
          Args:
              *args (list): The arguments to be used to format the xpath.
              **kwargs (dict): The keyword arguments to be used to format the
    - **Method:** `wait_element_load`
      >
          Wait for element to load.
          Args:
              timeout (int, optional): The maximum time to wait for the element to be present, in seconds.
                  Defaults to None. Overwrites apps inherent timeout if set.
          Returns:
              bool: True if element is visible, False not found and wait is False otherwise.
          Raises:


pkgId: d5284809fb87de7bff0d7432ef2b382ded4df7ea55a2c374524500bf82f089a3
name: python-t4gpd-help
arch: noarch
version: 0.9.6
epoch: 0
release: 1
summary: Development documents and examples for t4gpd
url: https://t4gpd-docs.readthedocs.io
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-t4gpd-0.9.6-1.src.rpm
location_href: Packages/python-t4gpd-help-0.9.6-1.noarch.rpm
checksum_type: sha256
description:
  Set of tools based on Python, GeoPandas and Shapely to achieve urban geoprocessing


  To be able to use the **t4gpd** plugin, perform geoprocessing and display your own maps, you need a Python3 interpreter and recent versions of the geopandas, matplotlib, numpy, and shapely libraries. One possibility is to install a [Miniconda3](https://docs.conda.io/en/latest/miniconda.html) environment, in which you will first create and then configure a new environment (we will call it gpd):
  > conda create -n gpd

  > conda activate gpd

  > conda config --env --add channels conda-forge

  > conda config --env --set channel_priority strict

  > conda install python=3.10 geopandas=0.12.2 contextily geocube imageio jupyterlab mapclassify matplotlib matplotlib-scalebar meshio networkx notebook openpyxl plotly pvlib Pyarrow pyogrio pysolar pyvista pywavelets rasterio scikit-learn scipy seaborn windrose xlrd xlwt

  > pip install dijkstar pythermalcomfort suntimes


  As **t4gpd** is now on [PyPI](https://pypi.org/project/t4gpd/), the easiest way to install the latest version is to use the pip command as follows:
  > pip install t4gpd

  Alternatively, you can download the **t4gpd** latest version from the [PyPI](https://pypi.org/project/t4gpd/#files). Then, install the Python3 plugin you downloaded:
  > pip install t4gpd-0.9.6.tar.gz


  Go to [https://t4gpd-docs.readthedocs.io](https://t4gpd-docs.readthedocs.io) to consult the documentation.


pkgId: 24e7f70e3a2bce4a52e6baf29ead3621a1e56a500aeb6cf0118f32a552d9d996
name: python-ta-cmi-help
arch: noarch
version: 3.3.1
epoch: 0
release: 1
summary: Development documents and examples for ta-cmi
url: https://gitlab.com/DeerMaximum/ta-cmi
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ta-cmi-3.3.1-1.src.rpm
location_href: Packages/python-ta-cmi-help-3.3.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python wrapper to read out  sensors from Technische Alternative using the C.M.I.





  ```python
  import asyncio

  from ta_cmi import CMI, Languages, ApiError, RateLimitError, InvalidCredentialsError, InvalidDeviceError, ChannelType


  async def main():
      try:
          cmi = CMI("http://192.168.1.101", "admin", "admin")

          devices = await cmi.get_devices()

          device = devices[0]

          
          await device.fetch_type()

          
          device.set_device_type("UVR16x2")

          await device.update()

          print(str(device))

          inputChannels = device.get_channels(ChannelType.INPUT)
          outputChannels = device.get_channels(ChannelType.OUTPUT)
          analogLogging = device.get_channels(ChannelType.ANALOG_LOGGING)

          for i in inputChannels:
              ch = inputChannels.get(i)
              print(str(ch))

          for o in outputChannels:
              ch = outputChannels.get(o)
              print(f"{str(ch)} - {ch.get_unit(Languages.DE)}")

          for al in analogLogging:
              ch = analogLogging.get(al)
              print(f"{str(ch)} - {ch.get_unit(Languages.DE)}")

      except (ApiError, RateLimitError, InvalidCredentialsError, InvalidDeviceError) as error:
          print(f"Error: {error}")


  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  loop.close()
  ```



  | Device type | Inputs | Outputs | DL-inputs | System-values: General | System-values: Date | System-values: Time | System-values: Sun | System-values: Electrical power | Analog network inputs | Digital network inputs | M-Bus | Modbus | KNX | Analog logging | Digital logging |
  |-------------|:------:|:-------:|:---------:|:----------------------:|:-------------------:|:-------------------:|:------------------:|:-------------------------------:|:---------------------:|:----------------------:|:-----:|:------:|:---:|:--------------:|:---------------:|
  | UVR1611     |   ✔    |    ✔    |     ❌     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ✔           |           ✔            |   ❌   |   ❌    |  ❌  |       ❌        |        ❌        |
  | UVR16x2     |   ✔    |    ✔    |     ✔     |           ✔            |          ✔          |          ✔          |         ✔          |                ❌                |           ❌           |           ❌            |   ❌   |   ❌    |  ❌  |       ✔        |        ✔        |
  | RSM610      |   ✔    |    ✔    |     ✔     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ✔   |   ❌    |  ❌  |       ❌        |        ❌        |
  | CAN-I/O45   |   ✔    |    ✔    |     ✔     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ❌   |   ❌    |  ❌  |       ❌        |        ❌        |
  | CAN-EZ2     |   ✔    |    ✔    |     ❌     |           ❌            |          ❌          |          ❌          |         ❌          |                ✔                |           ❌           |           ❌            |   ❌   |   ❌    |  ❌  |       ❌        |        ❌        |
  | CAN-MTx2    |   ✔    |    ✔    |     ❌     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ❌   |   ❌    |  ❌  |       ❌        |        ❌        |
  | CAN-BC2     |   ❌    |    ❌    |     ❌     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ✔   |   ✔    |  ✔  |       ❌        |        ❌        |
  | UVR65       |   ✔    |    ✔    |     ❌     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ❌   |   ❌    |  ❌  |       ❌        |        ❌        |
  | CAN-EZ3     |   ❌    |    ❌    |     ✔     |           ✔            |          ✔          |          ✔          |         ✔          |                ✔                |           ❌           |           ❌            |   ❌   |   ✔    |  ❌  |       ✔        |        ✔        |
  | UVR610      |   ✔    |    ✔    |     ✔     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ✔   |   ❌    |  ❌  |       ✔        |        ✔        |
  | UVR67       |   ✔    |    ✔    |     ❌     |           ❌            |          ❌          |          ❌          |         ❌          |                ❌                |           ❌           |           ❌            |   ❌   |   ❌    |  ❌  |       ❌        |        ❌        |

  > **Note**
  > The supported data types may differ from the official API. If a device type supports other data types than listed here, please create an issue.



  Data can be retrieved using [this](https://gitlab.com/DeerMaximum/ta-coe) CoE to HTTP server

  ```python
  import asyncio

  from ta_cmi import (
      ApiError,
      ChannelMode,
      CoE,
      InvalidCredentialsError,
      InvalidDeviceError,
      Languages,
      RateLimitError,
  )


  async def main():
      try:
          coe = CoE("http://192.168.2.201:9000")

          can_id = 42

          await coe.update(can_id)

          analog_channels = coe.get_channels(can_id, ChannelMode.ANALOG)
          digital_channels = coe.get_channels(can_id, ChannelMode.DIGITAL)

          for i in analog_channels:
              ch = analog_channels.get(i)
              print(str(ch))

          for o in digital_channels:
              ch = digital_channels.get(o)
              print(f"{str(ch)} - {ch.get_unit(Languages.DE)}")

      except (ApiError, RateLimitError, InvalidCredentialsError, InvalidDeviceError) as error:
          print(f"Error: {error}")


  loop = asyncio.get_event_loop()
  loop.run_until_complete(main())
  loop.close()
  ```

rpm_license:
  MIT License  Copyright (c) 2021 DeerMaximum  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: 07647a3ef28fc91d0a18f589c6368cd796846bf2e3f90832015bd806e0b21c72
name: python-taas-api-client-help
arch: noarch
version: 1.2.5
epoch: 0
release: 1
summary: Development documents and examples for taas-api-client
url: https://github.com/tread-labs-public/taas-api-client
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taas-api-client-1.2.5-1.src.rpm
location_href: Packages/python-taas-api-client-help-1.2.5-1.noarch.rpm
checksum_type: sha256
description:
  <img width="1037" alt="TreadLabs_logo_light@2x" src="https://uploads-ssl.webflow.com/631952c105a64138b98a5339/64af023765b5d70df562e05f_TreadLabs_logo_light.svg">




  These APIs provide a comprehensive interface to interact with a trading platform, allowing users to manage orders, view account balances, and execute various trading strategies. The endpoints are designed to facilitate the creation, retrieval, and deletion of orders, as well as the querying of account balances.


  ```
  pip install taas-api-client
  ```



  Make sure the URL specified is the full path to the TaaS instance (including "https://"). To get your auth_token for the client's user, [refer to the TaaS documentation](https://tread-labs.gitbook.io/api-docs/interacting-with-the-api/get-your-api-token).

  ```
  from taas_api import Client, PlaceOrderRequest

  c = Client(url="http://localhost:8000", auth_token="b72ab3bcbce4423208a07f52b5aed207d5bd053e")
  ```



  Submits a new order with specified parameters such as accounts, trading pair, side (buy/sell), sell token amount, duration, strategy, and engine passiveness. The place order endpoint has many fields with many restrictions. To simplify the call and run validations against the parameters, we provide a data object: `PlaceOrderRequest`. Every field can be interacted with like a regular attribute in Python.

  | Field               | Description                                                                                                        |
  |---------------------|--------------------------------------------------------------------------------------------------------------------|
  | accounts            | A list of account names to be available for the order.                                                             |
  | pair                | The trading pair for the order, following the syntax 'BASE-QUOTE' or 'BASE:VARIANT-QUOTE'.                         |
  | side                | The side of the order, indicating whether it's a buy or sell ('buy' or 'sell').                                    |
  | duration            | The duration of the order in seconds.                                                                              |
  | strategy            | The chosen trading strategy for the order (e.g. TWAP, VWAP, etc)                                                   |
  | sell_token_amount   | The amount of the sell token to be used in the order, if applicable.                                               |
  | base_asset_qty      | The quantity of the base asset (token being bought) in the order, if applicable.                                   |
  | quote_asset_qty     | The quantity of the quote asset (token being sold) in the order, if applicable.                                    |
  | engine_passiveness  | The engine passiveness parameter of the order, within the range [0, 0.1], default is 0.02.                         |
  | schedule_discretion | The schedule discretion parameter of the order, within the range [0, 0.1], default is 0.08.                        |
  | alpha_tilt          | The alpha tilt parameter of the order, within the range [-1, 1], 0 is default.                                     |
  | pov_target          | The pov target parameter of the order, within the range (0, 1], default is None. Limited to non-multi orders.      |
  | pov_limit           | The pov limit parameter of the order, within the range (0, 1], default is None. Limited to non-multi orders.       |
  | exposure_tolerance  | The exposure tolerance parameter of the order, within the range [0.1, 1], 0.5 is default. Limited to multi orders. |
  | limit_price         | The limit price that limits all the placements in the order, if applicable.                                        |
  | strategy_params     | Additional parameters specific to the chosen trading strategy, provided as a dictionary.                           |
  | notes               | Any additional notes or comments related to the order.                                                             |
  | custom_order_id     | A custom identifier for the order, if provided.                                                                    |
  | updated_leverage    | An updated leverage value for the order, if applicable. This will persist on the exchange for the pair.            |
  | max_otc             | The maximum amount for OTC transactions in the order. Limits the size of OTC trades.                               |

  Please note that the provided validation heuristics are designed to ensure that the inputs meet certain criteria before proceeding with order placement.
  [For more details on the order APIs](https://tread-labs.gitbook.io/api-docs/interacting-with-the-api/api-reference/orders)



  ```
  req = PlaceOrderRequest(accounts=["mock"], pair="ETH-USDT", side="buy", duration=300, base_asset_qty=5, strategy="TWAP")
  res = c.place_order(req)
  ```



  ```
  {
      'id': 'd3ca321a-d25c-4cee-8a0f-3f74d239c90d',
      'parent_order': None,
      'created_at': '2023-08-08T23:54:07.659244Z',
      'buy_token': 'ETH',
      'sell_token': 'USDT',
      'pair': 'ETH-USDT',
      'side': 'buy',
      'sell_token_amount': '9890.25000000000000000000',
      'strategy': '6fe4ba3e-c578-45bd-824c-c523bf3c56de',
      'strategy_params': {},
      'limit_price': '-1.00000000000000000000',
      'time_start': '2023-08-08T23:54:06.300319Z',
      'time_end': '2023-08-08T23:59:06.300319Z',
      'duration': 300,
      'accounts': ['09d3144b-9359-4ec3-8772-2dd1bfb86652'],
      'account_names': ['mock'],
      'user': '2',
      'time_zone': 'UTC',
      'placements': [],
      'executed_qty': 0,
      'executed_price': None,
      'executed_notional': 0,
      'active': True,
      'status': 'ACTIVE',
      'engine_passiveness': '0.02000000000000000000',
      'schedule_discretion': '0.08000000000000000000',
      'failure_reason': '',
      'stop_price': '-1.00000000000000000000',
      'notes': '',
      'custom_order_id': '',
      'updated_leverage': None
  }
  ```



  ```
  from taas_api import ChildOrder, PlaceMultiOrderRequest

  request = PlaceMultiOrderRequest(
      accounts=["mock"],
      duration=200,
      strategy="TWAP",
      exposure_tolerance=0.1,
      child_orders=[
          ChildOrder(
              pair="ETH:PERP-USDT",
              side="sell",
              base_asset_qty="10"
          ),
          ChildOrder(
              pair="ETH-USDT",
              side="buy",
              base_asset_qty="10"
          )
      ]
  )

  res = c.place_multi_order(request)
  ```



  ```
  {
      'id':'626c4202-a046-401a-bf23-f3805f593c21',
      'created_at':'2023-08-15T08:36:15.366052Z',
      'updated_at':'2023-08-15T08:36:15.366061Z',
      'time_start':'2023-08-15T08:36:15.357630Z',
      'duration':200,
      'child_order_ids':[
          'be508fb9-ee63-4a90-93eb-58dbdaf03378',
          '9d732e1f-e935-487b-93ac-b58e2b2896e4'
      ],
      'strategy':'6fe4ba3e-c578-45bd-824c-c523bf3c56de',
      'strategy_params':{},
      'engine_passiveness':'0.02000000000000000000',
      'schedule_discretion':'0.08000000000000000000',
      'user':'2',
      'status':'SUBMITTED',
      'time_zone':'UTC',
      'failure_reason':''
  }
  ```


  Retrieves the details of a specific order using the order ID.
  Call is very heavy and will fetch all placements and fills. Strongly recommended to use get_order_summary below.

  ```
  c.get_order("045158ea-a252-4306-8847-1b27f8157143")
  ```


  Retrieves key order attributes using the order ID.

  ```
  c.get_order_summary("045158ea-a252-4306-8847-1b27f8157143")
  ```


  Cancels a specific order using the order ID.

  ```
  c.cancel_order("045158ea-a252-4306-8847-1b27f8157143")
  ```


  The client call c.get_balances() is used to retrieve the balance details of a user's assets on a trading platform.



  ```
  res = c.get_balances()

  print(res)
  ```

  The returned value is a dictionary where the keys represent the account names and the values provide detailed information about the assets held in those accounts.

  For the given example, the account name is 'test' and the details are as follows:

  | **Key**                   | Description               |
  |-------------------------------|----------------------------------------------------------------------------------------|
  | **exchange**                   | The trading platform where the assets are held. In this case, it's 'OKX'.               |
  | **assets**                    | A list of dictionaries, each representing a different asset or position held in the account. Each asset dictionary contains: |
  | symbol                        | The identifier or ticker of the asset or position. Examples include 'BTC', 'USDT', and 'ETH:PERP-USDT'. |
  | size                          | The quantity of the asset or position. This can be positive for long positions or assets held, and negative for short positions. |
  | notional                      | The notional value of the asset or position.                                          |
  | market_type                   | The type of market the asset or position belongs to. Examples include 'UNIFIED' and 'PERP'. |
  | asset_type                    | Specifies whether the entry represents a token/coin or a trading position. Examples include 'token' and 'position'. |
  | unrealized_profit             | The profit or loss that would be realized if the asset or position were to be closed at the current market price. |
  | initial_margin                | [The amount of money used to open the position](https://www.binance.com/en/futures/trading-rules/quarterly/leverage-margin). |
  | maint_margin                  | The minimum amount of equity that must be maintained in the margin account.            |
  | margin_balance                | The total balance in the margin account after accounting for unrealized profits and losses. |
  | leverage                      | The amount of leverage applied to the position. If None, it means no leverage is applied. |
  | notional_pct_total     | The percentage of the notional value of the asset or position relative to the total notional value of all assets and positions in the account. |

  [For details on account structure](https://tread-labs.gitbook.io/api-docs/interacting-with-the-api/api-reference/accounts)

  ```
  {
      'test': {
          'exchange': 'OKX',
          'assets': [
              {
                  'symbol': 'BTC',
                  'size': 3.0,
                  'notional': 89409.0,
                  'market_type': 'unified',
                  'asset_type': 'token',
                  'unrealized_profit': 0.0,
                  'initial_margin': 0.0,
                  'maint_margin': 0.0,
                  'margin_balance': 3.0,
                  'leverage': None,
                  'notional_pct_total': 0.438558
              },
              {
                  'symbol': 'USDT',
                  'size': 8930.5901255465,
                  'notional': 8930.5901255465,
                  'market_type': 'unified',
                  'asset_type': 'token',
                  'unrealized_profit': -47.43906302083299,
                  'initial_margin': 37.148328685,
                  'maint_margin': 28.57563745,
                  'margin_balance': 8883.151062525667,
                  'leverage': None,
                  'notional_pct_total': 0.043805
              },
              {
                  'symbol': 'ETH:PERP-USDT',
                  'size': -181.0,
                  'notional': -33618.397,
                  'market_type': 'perp',
                  'asset_type': 'position',
                  'unrealized_profit': -47.43906302083299,
                  'initial_margin': 37.148328685,
                  'maint_margin': 28.57563745,
                  'margin_balance': 8883.151062525667,
                  'leverage': 0.0,
                  'notional_pct_total': 1.0
              }
          ]
      }
  }
  ```


  Follow https://packaging.python.org/en/latest/tutorials/packaging-projects/ for steps to release. Do not specify --repository option for real release. Uses token authentication.


pkgId: e9c997879ea304cd058c47e25c7e869d1bb726dfac2744239b9a6fa8a15faefc
name: python-tabcorr-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for tabcorr
url: https://pypi.org/project/tabcorr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tabcorr-1.1.1-1.src.rpm
location_href: Packages/python-tabcorr-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/tabcorr?color=blue)](https://pypi.org/project/tabcorr/)
  [![License: MIT](https://img.shields.io/github/license/johannesulf/TabCorr?color=blue)](https://raw.githubusercontent.com/johannesulf/TabCorr/main/LICENSE)
  ![Language: Python](https://img.shields.io/github/languages/top/johannesulf/TabCorr)

  This Python module provides extremely efficient and precise calculations of galaxy correlation functions in halotools using tabulated values. It is specifically intended for Markov chain monte carlo (MCMC) exploration of the galaxy-halo connection. It implements the method described in [Zheng & Guo (2016)](https://doi.org/10.1093/mnras/stw523) of tabulating correlation functions that only need to be convolved with the mean halo occupation to obtain the full correlation function of galaxies.



  The package can be installed via pip.

  ```
  pip install tabcorr
  ```



  The following code demonstrates the basic usage of `TabCorr`.

  ```
  import numpy as np
  import matplotlib.pyplot as plt
  import matplotlib as mpl
  from halotools.empirical_models import PrebuiltHodModelFactory
  from halotools.mock_observables import wp
  from halotools.sim_manager import CachedHaloCatalog
  from tabcorr import TabCorr




  rp_bins = np.logspace(-1, 1, 20)

  halocat = CachedHaloCatalog(simname='bolplanck')
  halotab = TabCorr.tabulate(halocat, wp, rp_bins, pi_max=40, verbose=True,
                             num_threads=4)


  halotab.write('bolplanck_wp.hdf5')



  halotab = TabCorr.read('bolplanck_wp.hdf5')


  model = PrebuiltHodModelFactory('zheng07', threshold=-18)

  rp_ave = 0.5 * (rp_bins[1:] + rp_bins[:-1])

  ngal, wp = halotab.predict(model)
  plt.plot(rp_ave, wp, label='total')

  ngal, wp = halotab.predict(model, separate_gal_type=True)
  for key in wp.keys():
      plt.plot(rp_ave, wp[key], label=key, ls='--')

  plt.xscale('log')
  plt.yscale('log')
  plt.xlabel(r'$r_{\rm p} \ [h^{-1} \ \mathrm{Mpc}]$')
  plt.ylabel(r'$w_{\rm p} \ [h^{-1} \ \mathrm{Mpc}]$')
  plt.legend(loc='lower left', frameon=False)
  plt.tight_layout(pad=0.3)
  plt.savefig('wp_decomposition.png', dpi=300)
  plt.close()



  sm = mpl.cm.ScalarMappable(
      cmap=mpl.cm.viridis, norm=mpl.colors.Normalize(vmin=12.0, vmax=12.8))

  for logm1 in np.linspace(12.0, 12.8, 1000):
      model.param_dict['logM1'] = logm1
      ngal, wp = halotab.predict(model)
      plt.plot(rp_ave, wp, color=sm.to_rgba(logm1), lw=0.1)

  cb = plt.colorbar(sm, ax=plt.gca())
  cb.set_label(r'$\log M_1$')
  plt.xscale('log')
  plt.yscale('log')
  plt.xlabel(r'$r_{\rm p} \ [h^{-1} \ \mathrm{Mpc}]$')
  plt.ylabel(r'$w_{\rm p} \ [h^{-1} \ \mathrm{Mpc}]$')
  plt.tight_layout(pad=0.3)
  plt.savefig('wp_vs_logm1.png', dpi=300)
  plt.close()
  ```

  ![](docs/examples/wp_decomposition.png)
  ![](docs/examples/wp_vs_logm1.png)



  Johannes Ulf Lange



  The method implemented in `TabCorr` has first been described in earlier work, particularly [Neistein et al. (2011)](https://doi.org/10.1111/j.1365-2966.2011.19145.x) and [Zheng & Guo (2016)](https://doi.org/10.1093/mnras/stw523). In [Lange et al. (2019a)](https://doi.org/10.1093/mnras/stz2124), we developed a generalized framework for this method that also takes into account assembly bias. Finally, a good reference for the `TabCorr` code itself is [Lange et al. (2019b)](https://doi.org/10.1093/mnras/stz2664).



  `TabCorr` is licensed under the MIT License.


pkgId: 7aebbab28eddd187bf946f06a3c2ca2c4b2e9a04e50f78f30cde8440aa26f613
name: python-tabutorch-help
arch: noarch
version: 0.0.1a0
epoch: 0
release: 1
summary: Development documents and examples for tabutorch
url: https://github.com/durandtibo/tabutorch
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tabutorch-0.0.1a0-1.src.rpm
location_href: Packages/python-tabutorch-help-0.0.1a0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <a href="https://github.com/durandtibo/tabutorch/actions">
          <img alt="CI" src="https://github.com/durandtibo/tabutorch/workflows/CI/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/tabutorch/actions">
          <img alt="Nightly Tests" src="https://github.com/durandtibo/tabutorch/workflows/Nightly%20Tests/badge.svg">
      </a>
      <a href="https://github.com/durandtibo/tabutorch/actions">
          <img alt="Nightly Package Tests" src="https://github.com/durandtibo/tabutorch/workflows/Nightly%20Package%20Tests/badge.svg">
      </a>
      <br/>
      <a href="https://durandtibo.github.io/tabutorch/">
          <img alt="Documentation" src="https://github.com/durandtibo/tabutorch/workflows/Documentation%20(stable)/badge.svg">
      </a>
      <a href="https://durandtibo.github.io/tabutorch/">
          <img alt="Documentation" src="https://github.com/durandtibo/tabutorch/workflows/Documentation%20(unstable)/badge.svg">
      </a>
      <br/>
      <a href="https://codecov.io/gh/durandtibo/tabutorch">
          <img alt="Codecov" src="https://codecov.io/gh/durandtibo/tabutorch/branch/main/graph/badge.svg">
      </a>
      <a href="https://codeclimate.com/github/durandtibo/tabutorch/maintainability">
          <img src="https://api.codeclimate.com/v1/badges/51366656f06710471ed9/maintainability" />
      </a>
      <a href="https://codeclimate.com/github/durandtibo/tabutorch/test_coverage">
          <img src="https://api.codeclimate.com/v1/badges/51366656f06710471ed9/test_coverage" />
      </a>
      <br/>
      <a href="https://github.com/psf/black">
          <img  alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg">
      </a>
      <a href="https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/%20style-google-3666d6.svg">
      </a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
      </a>
      <a href="https://github.com/guilatrova/tryceratops">
          <img  alt="Doc style: google" src="https://img.shields.io/badge/try%2Fexcept%20style-tryceratops%20%F0%9F%A6%96%E2%9C%A8-black">
      </a>
      <br/>
      <a href="https://pypi.org/project/tabutorch/">
          <img alt="PYPI version" src="https://img.shields.io/pypi/v/tabutorch">
      </a>
      <a href="https://pypi.org/project/tabutorch/">
          <img alt="Python" src="https://img.shields.io/pypi/pyversions/tabutorch.svg">
      </a>
      <a href="https://opensource.org/licenses/BSD-3-Clause">
          <img alt="BSD-3-Clause" src="https://img.shields.io/pypi/l/tabutorch">
      </a>
      <br/>
      <a href="https://pepy.tech/project/tabutorch">
          <img  alt="Downloads" src="https://static.pepy.tech/badge/tabutorch">
      </a>
      <a href="https://pepy.tech/project/tabutorch">
          <img  alt="Monthly downloads" src="https://static.pepy.tech/badge/tabutorch/month">
      </a>
      <br/>
  </p>



  PyTorch Library for Modeling Tabular Data

  TODO



  TODO



  :warning: While `tabutorch` is in development stage, no API is guaranteed to be stable from one
  release to the next. In fact, it is very likely that the API will change multiple times before a
  stable 1.0.0 release. In practice, this means that upgrading `tabutorch` to a new version will
  possibly break any code that was using the old version of `tabutorch`.



  `tabutorch` is licensed under BSD 3-Clause "New" or "Revised" license available
  in [LICENSE](https://github.com/durandtibo/tabutorch/blob/main/LICENSE) file.


pkgId: 7b0b0b6199bbe14d4d1f995dcea4f33b0a72b5ec610dfb1e4edb5f77bc1d55dc
name: python-tacoreader-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for tacoreader
url: https://github.com/tacofoundation/tacoreader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tacoreader-0.1.0-1.src.rpm
location_href: Packages/python-tacoreader-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).


pkgId: 7a44e56f5d5e9dd044f95df34f9143b134a6f2353fd99bd518276ed466ae26c6
name: python-tactigon-ironboy-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for tactigon-ironboy
url: https://nextind.eu
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tactigon-ironboy-1.0.0-1.src.rpm
location_href: Packages/python-tactigon-ironboy-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  ![The tactigon team](https://avatars.githubusercontent.com/u/63020285?s=200&v=4)

  This package enables to comunicate with IronBoy using a Bluetooth to UART device such as Adafruit Bluefruit LE Uart.

  This package can be used alongside with [Tactigon Gear](https://pypi.org/project/tactigon-gear/) and [Tactigon Speech](https://pypi.org/project/tactigon-speech/) libraries to drive IronBoy robot using gesture and "edge" voice command detection.



  In order to use the Tactigon Arduino Braccio library you need:

  * Python version: following versions has been used and tested. It is STRONGLY recommended to use these ones depending on platform.
    * Win10: 3.8.7



  Install and update using pip:

  `pip install tactigon-ironboy`



  ```python
  import time
  from tactigon_ironboy import IronBoy, IronBoyCommand, IronBoyConfig

  if __name__ == "__main__":
      cfg = IronBoyConfig("TactigonIronBoy", "FE:E2:2B:47:5D:80")

      with IronBoy(cfg) as ironboy:
          while True:
              if not ironboy.connected:
                  print("connecting...")
                  time.sleep(1)
                  continue

              print("Connected")

              
              ironboy.send_command(IronBoyCommand.WALK_FWD, 5)

              while ironboy.executing:
                  time.sleep(0.1)

              
              ironboy.send_command(IronBoyCommand.CELEBRATE)

              while ironboy.executing:
                  time.sleep(0.1)

              break
  ```


  - [Arduino code](https://github.com/TactigonTeam/Tactigon-SDK/blob/main/examples/arduino_braccio/arduino_code/braccio.ino)
  - [Solver](https://github.com/NNaert/Python-controlled-Braccio-robot-arm)
  - [Tactigon integration](https://github.com/TactigonTeam/Tactigon-SDK)


pkgId: 3011443960f8c0e0b1523f24184bdf61a2d01cc39690f49e4cca61e602d4e078
name: python-taegis-magic-help
arch: noarch
version: 2024.12.16
epoch: 0
release: 1
summary: Development documents and examples for taegis-magic
url: https://github.com/secureworks/taegis-magic
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taegis-magic-2024.12.16-1.src.rpm
location_href: Packages/python-taegis-magic-help-2024.12.16-1.noarch.rpm
checksum_type: sha256
description:
  Taegis Magic is a Jupyter Notebook and Command Line Interface for interacting with the [Secureworks](https://www.secureworks.com/) [Taegis](https://www.secureworks.com/products/taegis)™ security platform.  The Magics project is intended to assist users with workflows and analysis through [Jupyter Notebook](https://jupyter.org/) integrations and [Pandas](https://pandas.pydata.org/) [DataFrames](https://pandas.pydata.org/docs/reference/frame.html).



  ```bash
  python -m pip install taegis-magic
  ```



  ```bash
  $ taegis --help

   Usage: taegis [OPTIONS] COMMAND [ARGS]...

   Taegis Magic main callback.

  ╭─ Options ───────────────────────────────────────────────────────────────────────────────────────╮
  │ --warning                 --no-warning          [default: warning]                              │
  │ --verbose                 --no-verbose          [default: no-verbose]                           │
  │ --debug                   --no-debug            [default: no-debug]                             │
  │ --trace                   --no-trace            [default: no-trace]                             │
  │ --sdk-warning             --no-sdk-warning      [default: no-sdk-warning]                       │
  │ --sdk-verbose             --no-sdk-verbose      [default: no-sdk-verbose]                       │
  │ --sdk-debug               --no-sdk-debug        [default: no-sdk-debug]                         │
  │ --install-completion                            Install completion for the current shell.       │
  │ --show-completion                               Show completion for the current shell, to copy  │
  │                                                 it or customize the installation.               │
  │ --help                -h                        Show this message and exit.                     │
  ╰─────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ Commands ──────────────────────────────────────────────────────────────────────────────────────╮
  │ alerts                                                                                          │
  │ audits                                                                                          │
  │ clients                                                                                         │
  │ configure                                                                                       │
  │ events                                                                                          │
  │ investigations                                                                                  │
  │ preferences                                                                                     │
  │ rules                                                                                           │
  │ tenants                                                                                         │
  │ threat                                                                                          │
  │ users                                                                                           │
  ╰─────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```



  For more in depth examples see [docs](https://github.com/secureworks/taegis-magic/blob/main/docs/README.md).



  ```bash
  taegis alerts search --limit 2 --cell "FROM alert EARLIEST=-1d" --graphql-output "alerts { list { id metadata { title } } }"
  ```



  ```python
  %load_ext taegis_magic
  ```

  ```python
  %taegis alerts search --limit 10 --graphql-output "alerts { list { id metadata { title } } }" --assign df --display df
  FROM alert
  EARLIEST=-1d
  ```

  |    | id                                                                                 | metadata.title            |
  |---:|:-----------------------------------------------------------------------------------|:--------------------------|
  |  0 | alert://priv:event-filter:xxxxx:1668534654520:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  1 | alert://priv:event-filter:xxxxx:1668534458035:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  2 | alert://priv:event-filter:xxxxx:1668534458036:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  3 | alert://priv:event-filter:xxxxx:1668534458037:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  4 | alert://priv:event-filter:xxxxx:1668534458038:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  5 | alert://priv:event-filter:xxxxx:1668534458039:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  6 | alert://priv:event-filter:xxxxx:1668534458040:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  7 | alert://priv:event-filter:xxxxx:1668534458040:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  8 | alert://priv:event-filter:xxxxx:1668534458040:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |
  |  9 | alert://priv:event-filter:xxxxx:1668534458042:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx | AWS - GetCredentialReport |

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product 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 NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of 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 reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS


pkgId: eff829dbf0b653a9d2d6f58a46c6048f448af551e0bfc95518cc1356224745ef
name: python-taegis-sdk-python-help
arch: noarch
version: 1.2.29
epoch: 0
release: 1
summary: Development documents and examples for taegis-sdk-python
url: https://github.com/secureworks/taegis-sdk-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taegis-sdk-python-1.2.29-1.src.rpm
location_href: Packages/python-taegis-sdk-python-help-1.2.29-1.noarch.rpm
checksum_type: sha256
description:
  The Taegis SDK is a Python library for interfacing with the GraphQL APIs in Taegis.



  - Python 3.8 or higher.



  - Set `CLIENT_ID` and `CLIENT_SECRET` environment variables as described in the [Taegis XDR Documenation](https://docs.ctpx.secureworks.com/apis/api_authenticate/).

  OR

  - Login using username/password with mfa upon service creation

  OR

  - Device Code SSO




  ```bash
  python -m pip install taegis-sdk-python
  ```




  To use the SDK, you must first import the `GraphQLService`


  ```python
  from taegis_sdk_python import GraphQLService
  from pprint import pprint as pp
  service = GraphQLService()
  ```

  Now that you have the `GraphQLService`, you can make requests and process responses for `Taegis XDR Services`. The following example uses the `Investigations Service` to send a query to get all available investigations

  ```python
  result = service.investigations.query.investigations_search(
      page=1,
      per_page=3,
      query="WHERE deleted_at IS NOT NULL EARLIEST=-90d"
  )
  pp(result)
  ```

  ```python
  result = service.tenants.query.tenants(tenants_query=TenantsQuery(
      max_results=10,
      page_num=1,
  ))
  pp(result)
  ```

  ```python
  results = service.events.subscription.event_query(
      query="FROM process EARLIEST=-1d",
      options=EventQueryOptions(
          max_rows=20,
          page_size=10,
          skip_cache=True,
      ),
  )
  pp(results)
  print()
  try:
      next_page = next(
          iter(
              {
                  result.next
                  for result in results
                  if result.next
              }
          )
      )
  except StopIteration:
      next_page = None

  if next_page:
      results = service.events.subscription.event_page(page_id=next_page)
      pp(results)
  ```



  ```python
  from taegis_sdk_python import GraphQLService

  service = GraphQLService()
  schema = service.core.get_sync_schema()
  ```

  For more in depth analysis see: [Exploring the Schema](docs/exploring_the_schema.md)




  For more information see the [Getting Started](docs/getting_started.md)


pkgId: f525d20343c3f0339a0b59bd1a61ae7bf8fc9677cc578eb3600850afb73aa3d8
name: python-taiwan-holidays-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for taiwan-holidays
url: https://github.com/Chesham/taiwan-holidays
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taiwan-holidays-0.4.0-1.src.rpm
location_href: Packages/python-taiwan-holidays-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  `taiwan-holidays` is a Python package designed to check whether a specific date is a workday or a holiday in Taiwan, based on the official work calendar provided by the Taiwan government.

  ![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)
  ![license](https://img.shields.io/badge/license-MIT-green)



  - Determine if a date is a workday or holiday.
  - Support for official Taiwan government work calendar rules, including special adjusted workdays and holidays.
  - Easy-to-use API for date checking.
  - Currently, only the official Taiwanese government calendar of public working days starting from the year 2019 (Republic of China year 108) onwards is supported.



  You can install `taiwan-holidays` via pip:

  ```bash
  pip install taiwan-holidays
  ```



  Here's how you can use taiwan-holidays in your Python project.



  ```python
  from taiwan_holidays.taiwan_calendar import TaiwanCalendar


  calendar = TaiwanCalendar()
  date = dateutil.parser.parse('2024-12-08')
  print(calendar.is_holiday(date))
  print(calendar.is_holiday('2024-12-08'))
  print(calendar.is_holiday('20241208'))
  print(calendar.is_holiday('2024/12/08'))


  calendar.iter_workdays('2024-12-01', '2024-12-31')


  calendar.iter_workdays('2024-12-31', '2024-12-01')
  ```



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



  Special thanks to the Taiwan government for providing the official administrative calendar as the basis for this package.

  Feel free to report any issues or suggest new features in the Issues section.


pkgId: 018e7d2efc29f944f3d71344b048446a5d346ae0caf3d0754ac2a2e030c3b172
name: python-tamarix-analytics-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for tamarix-analytics
url: https://pypi.org/project/tamarix-analytics/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tamarix-analytics-0.0.4-1.src.rpm
location_href: Packages/python-tamarix-analytics-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for row matching and F1 score calculations using the Hungarian algorithm.



  ```bash
  pip install tamarix-analytics
  ```



  ```python
  from tamarix_analytics import match_rows, f1_score_unordered, f1_score_ordered, get_row_score
  ```





  Finds the optimal assignment of rows between two objects using the Hungarian algorithm.
  The optimal assignment is invariant to the order of the objects in the lists.
  This allows to make a comparison between tables even if the order/number of rows is different.

  **Input**:
  - `tentative_data: list[BaseModel]` - list of arbitrary objects for comparison
  - `ground_truth: list[BaseModel]` - ground truth list of objects to match `tentative_data` against.

  **Output**:
  A list of 2-tuples where the first item is the index of an object in the ground truth list and the second item is the index of an object in the tentative list.



  Calculates the F1 score between two list of arbitrary objects, without penalizing the wrong order of objects in the list. Internally uses the `match_rows` function to find the best mapping between the rows.

  **Input**:
  - `tentative_data: list[BaseModel]` - list of arbitrary objects for comparison
  - `ground_truth: list[BaseModel]` - ground truth list of objects.

  **Output**:
  F1 score as float



  Caluclates the F1 score where values are checked with consideration to the structure and order of the tables being compared.

  **Input**:
  - `tentative_data: list[BaseModel]` - list of arbitrary objects for comparison
  - `ground_truth: list[BaseModel]` - ground truth list of objects.

  **Output**:
  F1 score as float



  The ratio between the number of items in the `ground_truth` list over the number of items in `tentative_data`.

  **Input**:
  - `tentative_data: list[BaseModel]` - list of arbitrary objects for comparison
  - `ground_truth: list[BaseModel]` - ground truth list of objects.

  **Output**:
  Row score ratio as float


pkgId: 89a4335ccc32ad8ac676d5e50f84209cfb094822504a5719dee7f73735ce49a4
name: python-tan-lib-help
arch: noarch
version: 0.2
epoch: 0
release: 1
summary: Development documents and examples for tan-lib
url: https://github.com/yourusername/tan_lib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tan-lib-0.2-1.src.rpm
location_href: Packages/python-tan-lib-help-0.2-1.noarch.rpm
checksum_type: sha256
description:
  This is a simple math library with basic functions like add and subtract.



  To install this library, use pip:

  ```bash
  pip install tan_lib


pkgId: e52eccc68b857edfeec61662137aea40406763d5a95435d9de4e3dd2c6dd0ec8
name: python-tangbao-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for tangbao
url: https://pypi.org/project/tangbao/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tangbao-0.3.0-1.src.rpm
location_href: Packages/python-tangbao-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a Python package for helping with creating LLM-based Streamlit apps in Boehringer.

  "tangbao" is Chinese for "soup dumpling", a type of dim sum popular in Shanghai. It is made by filling a dumpling with meat and a mixture of ice and lard. When the dumpling steams, the frozen part melts and imparts the "tang" to the "bao". The word "bao" is also the name for a package or library in coding.

  Contact [Steven Brooks](mailto:steven.brooks@boehringer-ingelheim.com) or [Pietro Mascheroni](mailto:pietro.mascheroni@boehringer-ingelheim.com) for feedback/support.





  Everything below assumes you have a python venv already created. If you dont, then run

  ```bash
  python -m venv .venv
  source .venv/bin/activate
  ```

  To install the package run `pip install tangbao`.



  You might need to install additional dependencies based on the types of documents you plan to parse.

  See the `unstructured` documentation here: https://pypi.org/project/unstructured/

  In this package, we only install the minimal dependencies necessary.



  This project requires certain environment variables to be set. These variables are used for connecting to external APIs and services.

  1. Create a `.env` file in the root directory of the project.
  2. Add the following content to the `.env` file, replacing placeholder values with your actual credentials:



  Apollo is the focus of the remainder of this guide.

  ```env
  APOLLO_CLIENT_ID=your_client_id
  APOLLO_CLIENT_SECRET=your_client_secret
  INDEX_NAME="" # Set this to your index name, see below for more details
  ```
  To obtain the client id and client secret, please refer to the [guide](https://boehringer.sharepoint.com/sites/z365apollocontrolcenter/SitePages/Marketplace.aspx) in the apollo website. We recommend starting from the "Experimentation Use Case" route for new projects.



  To use the Azure endpoints, you'll need the following in your .env file:

  ```env
  AZURE_BASE_URL=https://azure.example.com
  AZURE_API_KEY=your_azure_api_key
  AZURE_DEPLOYMENT_VERSION=v1
  AZURE_DEPLOYMENT_NAME=model_name
  ```



  - [Step 1: Parse Documents](#step-1-parse-documents)
  - [Step 2: Index the RAG Database](#step-2-index-the-rag-database)
  - [Step 3: Build a Streamlit App](#step-3-build-a-streamlit-app)



  **Note:** This guide, and all following guides assume you've set up your environment properly. See above for instructions.

  Before we can build the RAG, we need to parse the documents. This package provides functions to make that easier.

  **IMPORTANT**: PDF images are not be parsed with the current release.

  We provide a basic chunking strategy, i.e., unstructured chunking. This means that meta-information such as the chapter or section level is missed when chunking the documents.

  Two parameters control the chunking structure:

  - CHUNK_SIZE: controls the maximum number of characters in one text chunk
  - CHUNK_OVERLAP: controls the characters that overlap between following chunks.

  The chunk size controls the granularity in which the text is divided: small chunks provide very specific, almost keyword based, matches to the query.
  Larger chunks allow to grasp more context and subtle meaning of the text.

  To start with, we suggest to go for CHUNK_SIZE = 500, CHUNK_OVERLAP = 0. From our experiments, these values provide a good starting point for many situations.

  The following is a simple example to setup a parsing strategy. Please follow these steps:

  1. Store PDF documents in a folder named `./documents`
  2. Create a script like the following:

  ```python
  from tangbao import parse_docs

  CHUNK_SIZE = 500
  CHUNK_OVERLAP = 0

  filenames_df = parse_docs.get_filenames("./documents")
  processed_docs = parse_docs.process_documents(filenames_df, CHUNK_SIZE, CHUNK_OVERLAP)
  processed_docs["Metadata"] = processed_docs["Metadata"].apply(parse_docs.parse_metadata)

  processed_docs.to_parquet(f'my_docs_cs_{CHUNK_SIZE}_co_{CHUNK_OVERLAP}.parquet')
  ```



  After we've parsed the documents in Step 1, we can index the RAG's vector database with the
  document chunks and metadata.

  1. Make sure to use the same CHUNK_SIZE and CHUNK_OVERLAP values from the previous step.
  2. Make sure you have the `.parquet` file in your working directory.
  3. The INDEX_NAME should have the following format: `app-id_your-index-name`.
  The `app-id` for your use case can be retrieven by following the code snippet below.
  For the index name, consider that it can have underscores, dashes, numbers and lower-case characters only.
  **Note**: The index name scheme for Apollo is set to be changed soon, so this code will need to be updated.

  **IMPORTANT**: It is very important that you keep your index name a secret so others won't overwrite it with their documents.
  Consider using an environment variable for this, similar to how we treat an API Key. Another level of assurance that no one
  will overwrite your index with their documents would be to generate a unique index name, e.g., with

  ```python
  import uuid
  from tangbao.apollo import Apollo
  your_index_name = str(uuid.uuid4()) # can only include lower case alpha-numeric, underscores, and dashes
  apollo = Apollo()
  iam = apollo.iam()
  app_id = iam["id"]
  INDEX_NAME=f'{app_id}_{your_index_name}'
  ```
  But then just remember to record this index name in your `.env` for use later on. If you call it `INDEX_NAME`, then
  you can call on it with e.g., `os.getenv("INDEX_NAME")`.

  4. Index the RAG DB. This can be done following a similar script:

  ```python
  from tangbao.apollo import Apollo
  from tangbao.parse_docs import separate_for_indexing
  from tangbao import config
  import pandas as pd
  import os


  CHUNK_SIZE = 500
  CHUNK_OVERLAP = 0
  PARQUET_FILE = f'my_docs_cs_{CHUNK_SIZE}_co_{CHUNK_OVERLAP}.parquet'
  INDEX_NAME = os.getenv("INDEX_NAME")
  EMBEDDING_MODEL = "openai-text-embedding-3-large" # you can see other embedding models with apollo.get_model_info()
  processed_docs = pd.read_parquet(PARQUET_FILE, engine='pyarrow')
  texts, ids, metadatas = separate_for_indexing(processed_docs)


  apollo.index_multi_threaded(
      texts=texts,
      ids=ids,
      metadatas=metadatas,
      index_name=INDEX_NAME,
      embedding_model=EMBEDDING_MODEL,
      max_workers=8
  )
  ```
  If there are any failures in indexing doc chunks, they will be written to a log file. You can resubmit those chunks using this method:

  ```python
  if os.path.exists(config.LOG_FILE):
      apollo.resubmit_failed_chunks(
          log_file=config.LOG_FILE,
          texts=texts,
          ids=ids,
          metadatas=metadatas,
          index_name=INDEX_NAME,
          embedding_model=EMBEDDING_MODEL,
          max_workers=8
      )
  ```
  After the indexing is completed, it is possible to query the RAG dataset with a test question.
  This can be accomplished using the following script:

  ```python
  apollo.query_index(
      user_query="YOUR QUERY HERE",
      num_chunks=5,
      index_name=INDEX_NAME,
      embedding_model=EMBEDDING_MODEL
  )
  ```



  It is possible to also use alternative retrievers. To use a BM25 retriever (keyword based), follow this code. The vector store will be created in memory, so it will be necessary to index the documents inside the app.

  ```python
  from tangbao.parse_docs import separate_for_BM25
  from tangbao.retrievers import BM25Retriever


  documents = separate_for_BM25(processed_docs)


  bm25_retriever = BM25Retriever(documents)


  bm25_retriever.index_corpus()


  output = bm25_retriever.query_corpus("YOUR QUERY HERE")
  print(output)
  ```

  It is also possible to call a hybrid retrieval that combines keyword-based and semantic searches. This is supported by the class `HybridRetrieverApollo` that combines a BM25 retriever with the vector database from apollo. Note that this requires the documents to be already indexed in the apollo vector store before performing the search (see step 4 above).

  ```python
  from tangbao.retrievers import HybridRetrieverApollo

  INDEX_NAME = os.getenv("INDEX_NAME") # the index name used during indexing
  EMBEDDING_MODEL = "openai-text-embedding-3-large" # the embedding model used during indexing


  sample_query = "YOUR QUERY HERE"


  hybrid_retriever = HybridRetrieverApollo(processed_docs, INDEX_NAME, EMBEDDING_MODEL)


  combined_scores = hybrid_retriever.query_indices(sample_query, num_chunks=2)


  for doc in combined_scores:
      print(f'{doc["text"]}: {doc["rank"]:.4f}, metadata: {doc["metadata"]}')
  ```
  Note that it is also possible to assign a weight to the importance of keyword-based retrieval (relative to embedding-based).

  ```python

  combined_scores = hybrid_retriever.query_indices(sample_query, num_chunks=2, keyword_weight=0.1)


  for doc in combined_scores:
      print(f'{doc["text"]}: {doc["rank"]:.4f}, metadata: {doc["metadata"]}')
  ```
  The weight controls the importance that is given to keyword-based retrieval when ranking the documents in the hybrid search.
  If the user is looking for very specific terms, than it would make sense to impose more weight to keyword-based retriever.
  On the other hand, if the user is unsure about the content and wordings that are present in the documents, then it is possible to assign more freedom in the search by selecting a lower weight. By default, an equal weight is assigned to both keyword- and embedding-based retrievers.

  We also support an in-memory retriever from [LangChain](https://python.langchain.com/docs/introduction/). This is convenient for relatively small documents that don't have to be stored between sessions (the in-memory retriever will indeed be erased when the application or notebook is closed). It performs a similarity search in the embedding space using cosine similarity (please see the full details at this [link](https://python.langchain.com/api_reference/core/vectorstores/langchain_core.vectorstores.in_memory.InMemoryVectorStore.html).)
  Here is a code snippet that shows how to initialize the retriever and use it for a simple query:

  ```python
  from tangbao.parse_docs import separate_for_indexing
  from tangbao.retrievers import ApolloEmbeddings
  from langchain_core.vectorstores import InMemoryVectorStore


  texts, ids, metadatas = separate_for_indexing(processed_docs)


  embeddings = ApolloEmbeddings(model="openai-text-embedding-3-large", dimensions=3072)


  vectorstore = InMemoryVectorStore.from_texts(
      texts=texts,
      embedding=embeddings,
      ids=ids,
      metadatas=metadatas,
  )


  retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 5})


  retrieved_documents = retriever.invoke("YOUR QUERY HERE")


  for doc in retrieved_documents:
      print(doc.page_content)
  ```
  Note that it is also possible to use a hybrid retriever that combines the in-memory embedding-based retrieval with keyword-based search. This is implemented through the class `HybridRetrieverInMemory`. See the following code snippet:

  ```python
  from tangbao.retrievers import HybridRetrieverInMemory


  sample_query = "YOUR QUERY HERE"


  hybrid_retriever = HybridRetrieverInMemory(processed_docs, emb_model="openai-text-embedding-3-large", emb_dimensions=3072)


  combined_scores = hybrid_retriever.query_indices(sample_query, num_chunks=2, keyword_weight=0.2)


  for doc in combined_scores:
      print(f'{doc["text"]}: RANK {doc["rank"]:.4f}, metadata: {doc["metadata"]}')
  ```



  To improve the outcome of retrieval, it is possible to add a reranking step that improves the match between the user query and the retrieved chunks. This is supported through the `ReRanker` class and works for all the supported retrieval frameworks (keyword-, embedding-based and hybrid). Here is a code snippet showing how to setup reranking for documents retrieved using the apollo vector database:

  ```bash
  pip install tangbao[rerank] # installs torch and sentence-transformers for reranking
  ```

  ```python
  from tangbao.retrievers import extract_docs_from_apollo_vs
  from tangbao.rerankers import ReRanker


  example_user_query = "YOUR QUERY HERE"


  response_apollo_query_index = apollo.query_index(
      user_query=example_user_query,
      num_chunks=5,
      index_name=INDEX_NAME,
      embedding_model=EMBEDDING_MODEL
  )


  example_docs_retrieved = extract_docs_from_apollo_vs(response_apollo_query_index)


  reranker = ReRanker()


  reranker.rerank(example_user_query, example_docs_retrieved)
  ```

  **NOTE**: the re-formatting of the retrieved chunks is not needed for BM25 and hybrid retrieval, since the output of these methods is already compatible with the `ReRanker` class. For documents retrieved using the in-memory retrieval strategy, the function `extract_docs_from_langchain_re` can be used to pre-process the documents before reranking. Check the docs of `ReRanker` by typing `help(ReRanker)` for additional reranking options.




  Now that we have indexed our documents in the RAG database, we can build a Streamlit
  app to let users 'chat' with the document store.

  To create the app, follow these steps:

  1. Make sure you have the INDEX_NAME from the previous step
  2. Create a file called `app.py` and use the following template. Make sure to change the custom prompt below if needed!
  Changing the prompt is a crucial step to assure that the generation phase of the RAG conforms to your specific use case.
  Invest some time in prompt engineering, to get the best out of the LLM used to generate the answers to the user queries.

  ```python
  import streamlit as st
  import pandas as pd
  from tangbao import utils
  from tangbao.apollo import Apollo
  import os

  INDEX_NAME = os.getenv("INDEX_NAME")
  EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL") # make sure its the same one you used for indexing above!

  st.title("Chat with Docs")


  if "messages" not in st.session_state.keys():
      st.session_state.messages = [{"role": "assistant", "content": "How may I help you?"}]

  if "used_tokens" not in st.session_state:
     st.session_state.used_tokens = 0


  for message in st.session_state.messages:
      with st.chat_message(message["role"]):
          st.write(message["content"])

  apollo = Apollo()

  @st.cache_data
  def cached_model_info(_apollo_client):
     return _apollo_client.get_model_info()

  model_info = cached_model_info(apollo)
  chat_models = [model["model_name"] for model in model_info if model["model_info"]["mode"] == "chat"]


  with st.sidebar:
     selected_model = st.selectbox("Select LLM:", chat_models)
     CONTEXT_WINDOW = [model['model_info']['max_input_tokens'] for model in model_info if model['model_name'] == selected_model][0]
     token_display = st.empty()
     with token_display.container():
        st.progress(st.session_state.used_tokens/CONTEXT_WINDOW, text = f"Context window used ({st.session_state.used_tokens} out of {CONTEXT_WINDOW})")
     temperature = st.slider("Select model creativity (temperature)", min_value=0.0, max_value=1.0, value = 0.0)
     chunk_num = st.slider("Select number of chunks", min_value=1, max_value=8, value=4)


  if user_query := st.chat_input("Ask a question"):
     st.session_state.messages.append({"role": "user", "content": user_query})
     with st.chat_message("user"):
        st.markdown(user_query)

  if st.session_state.messages[-1]["role"] != "assistant":
     
     with st.chat_message("assistant"):
        with st.spinner("Thinking..."):
          context = apollo.query_index(user_query, chunk_num, INDEX_NAME)
          
          prompt = f"""\
              Use the following CONTEXT delimited by triple backticks to answer the QUESTION at the end.

              If you don't know the answer, just say that you don't know.

              Use three to five sentences and keep the answer as concise as possible.

              You are also a language expert, and so can translate your responses to other languages upon request.

              CONTEXT: ```
              {context['docs']}
              ```

              QUESTION: ```
              {user_query}
              ```

              Helpful Answer:"""

          response_full = apollo.chat_completion(
              messages=[{'role': 'user', 'content': prompt}] +
              [{'role': m['role'], 'content': m['content']} for m in st.session_state.messages],
              model=selected_model,
              temperature=temperature,
              seed=42,
              is_stream=False
          )

          response = apollo.get_content(response_full)
          st.session_state.used_tokens = apollo.get_token_usage(response_full)
          st.write(response)

          with st.sidebar:
              with token_display.container():
                  st.progress(st.session_state.used_tokens/CONTEXT_WINDOW, text = f"Context window used ({st.session_state.used_tokens} out of {CONTEXT_WINDOW})")
              sources, titles = utils.extract_source(context)
              st.header("Sources:")
              st.table(pd.DataFrame({"Documents referenced": titles}))
              st.markdown(sources, unsafe_allow_html=True)

          st.session_state.messages.append({"role": "assistant", "content": response})
  ```

  Then run `streamlit run app.py` to see if it works!





  ```bash
  pip install -e .
  ```

  The `-e` flag in `pip install -e .` installs the package in "editable" mode, which means:
  - Changes you make to the source code will be reflected immediately without reinstalling
  - The package will be available in your Python environment just like a normal installed package
  - You can import it with `import tangbao` in your scripts

  For unit testing, we'll use the `pytest` framework.

  ```bash
  source .venv/bin/activate
  python -m pytest tests/
  ```



  ```bash
  source .venv/bin/activate
  pip install -e .
  pip install --upgrade build wheel bumpversion
  bumpversion patch # or major or minor
  rm -rf dist
  python -m build
  ```



  Requires a PyPI API Token. Get one at https://pypi.org

  Set the token in your environment as `TWINE_PASSWORD`

  ```bash
  source .venv/bin/activate
  pip install --upgrade twine
  twine upload --repository pypi dist/*
  ```


pkgId: a8491c2d57d6d66f059b53a50a6fc91b22c430954d45784282ed40944bc18763
name: python-taospy-help
arch: noarch
version: 2.7.18
epoch: 0
release: 1
summary: Development documents and examples for taospy
url: https://pypi.org/project/taospy/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taospy-2.7.18-1.src.rpm
location_href: Packages/python-taospy-help-2.7.18-1.noarch.rpm
checksum_type: sha256
description:
  | Github Workflow | PyPI Version | PyPI Downloads | CodeCov |
  | --------------- | ------------ | -------------- | ------- |
  | ![workflow](https://img.shields.io/github/actions/workflow/status/taosdata/taos-connector-python/test-ubuntu-2204.yml) | ![PyPI](https://img.shields.io/pypi/v/taospy) | ![PyPI](https://img.shields.io/pypi/dm/taospy) | [![codecov](https://codecov.io/gh/taosdata/taos-connector-python/branch/main/graph/badge.svg?token=BDANN3DBXS)](https://codecov.io/gh/taosdata/taos-connector-python) |




  [TDengine](https://github.com/taosdata/TDengine) connector for Python enables python programs to access TDengine, using
  an API which is compliant with the Python DB API 2.0 (PEP-249). It contains two modules:

  1. The `taos` module. It uses TDengine C client library for client server communications.
  2. The `taosrest` module. It wraps TDengine RESTful API to Python DB API 2.0 (PEP-249). With this module, you do not need to install the TDengine C client library.



  You can use `pip` to install the connector from PyPI:

  ```bash
  pip3 install taospy
  ```

  Or with git url:

  ```bash
  pip3 install git+https://github.com/taosdata/taos-connector-python.git
  ```

  Note: taospy v2.7.2 requirs Python 3.6+. The early versions of taospy from v2.5.0 to v2.7.1 require Python 3.7+.



  ```bash

  pip3 install taospy
  pip3 install taos-ws-py
  ```

  Note: The taosws module is provided by taos-ws-py package separately from v2.7.2. It is part of early version of taospy.
  taos-ws-py requires Python 3.7+.



  [Reference](https://docs.tdengine.com/reference/connector/python/)



  - `taosrest` is designed to use with taosAdapter. If your TDengine version is older than v2.4.0.0, taosAdapter may not
    be available.



  We use MIT license for Python connector.


pkgId: 80587920cc5f1069c545ed79a1c27064e4dedc295d2c730387bcdec7387629c5
name: python-tap-betterstack-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for tap-betterstack
url: https://github.com/edgarrmondragon/tap-betterstack
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-betterstack-0.2.1-1.src.rpm
location_href: Packages/python-tap-betterstack-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-betterstack/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-betterstack/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-betterstack/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-betterstack"/>
    </a>
    <a href="https://github.com/astral-sh/ruff">
      <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
    </a>
    <a href="https://pypi.org/p/tap-betterstack/">
      <img alt="Python versions" src="https://img.shields.io/pypi/pyversions/tap-betterstack"/>
    </a>
  </div>

  Singer tap for [Better Stack](https://betterstack.com). Built with the [Meltano Singer SDK](https://sdk.meltano.com).

  </div



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`
  * `batch`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | token               | True     | None    | API Token for Better Stack |
  | start_date          | False    | None    | Earliest datetime to get data from |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |
  | batch_config        | False    | None    |             |

  A full list of supported settings and capabilities is available by running: `tap-betterstack --about`





  * [`monitors`](https://betterstack.com/docs/uptime/api/list-all-existing-monitors/)
  * [`monitor_groups`](https://betterstack.com/docs/uptime/api/list-all-existing-monitor-groups/)
  * [`heartbeats`](https://betterstack.com/docs/uptime/api/list-all-existing-hearbeats/)
  * [`heartbeat_groups`](https://betterstack.com/docs/uptime/api/list-all-existing-heartbeat-groups/)
  * [`on_calls`](https://betterstack.com/docs/uptime/api/list-all-existing-on-call-calendars/)
  * [`escalation_policies`](https://betterstack.com/docs/uptime/api/list-all-escalation-policies/)
  * [`incidents`](https://betterstack.com/docs/uptime/api/list-all-incidents/)
  * [`incident_events`](https://betterstack.com/docs/uptime/api/list-of-incident-timeline-events/)
  * [`email_integrations`](https://betterstack.com/docs/uptime/api/list-all-email-integrations/)
  * [`incoming_webhooks`](https://betterstack.com/docs/uptime/api/list-all-incoming-webhooks/)
  * [`status_pages`](https://betterstack.com/docs/uptime/api/list-all-existing-status-pages/)



  * [`status_page_sections`](https://betterstack.com/docs/uptime/api/list-existing-sections-of-a-status-page/)
  * [`status_page_resources`](https://betterstack.com/docs/uptime/api/list-existing-resources-of-a-status-page/)
  * [`status_page_reports`](https://betterstack.com/docs/uptime/api/list-existing-reports-on-a-status-page/)
  * [`status_page_report_updates`](https://betterstack.com/docs/uptime/api/list-all-existing-status-updates-for-a-status-page-report/)



  You can easily run `tap-betterstack` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-betterstack --version
  tap-betterstack --help
  tap-betterstack --config CONFIG --discover > ./catalog.json
  ```



  - [ ] `Developer TODO:` As a first step, scan the entire project for the text "`TODO:`" and complete any recommended steps, deleting the "TODO" references once completed.



  ```bash
  pipx install poetry
  poetry install
  ```



  Create tests within the `tests` subfolder and then run:

  ```bash
  poetry run pytest
  ```

  You can also test the `tap-betterstack` CLI interface directly using `poetry run`:

  ```bash
  poetry run tap-betterstack --help
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Open the `meltano.yml` and follow any _"TODO"_ items listed in
  the file.

  Next, install Meltano (if you haven't already) and any needed plugins:

  ```bash

  pipx install meltano

  cd tap-betterstack
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-betterstack --version

  meltano elt tap-betterstack target-jsonl
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.


pkgId: d39612a074a2a93c765000c8d5af1bc148559dd2def62bc5bf37956b090d7579
name: python-tap-bitly-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for tap-bitly
url: https://github.com/edgarrmondragon/tap-bitly
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-bitly-0.3.2-1.src.rpm
location_href: Packages/python-tap-bitly-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-bitly/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-bitly/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-bitly/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-bitly"/>
    </a>
    <a href="https://github.com/astral-sh/ruff">
      <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
    </a>
    <a href="https://github.com/pypa/hatch">
      <img alt="Hatch project" src="https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg"/>
    </a>
  </div>

  Singer tap for [Bitly](https://bitly.com/). Built with the [Meltano Singer SDK](https://sdk.meltano.com).

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`



  | Setting              | Required | Default | Description                                                                                                                                 |
  | :------------------- | :------: | :-----: | :------------------------------------------------------------------------------------------------------------------------------------------ |
  | token                |   True   |  None   | API Token for Bitly                                                                                                                         |
  | include_paid_streams |  False   |  False  | Whether to sync paid streams                                                                                                                |
  | start_date           |  False   |  None   | Earliest datetime to get data from                                                                                                          |
  | stream_maps          |  False   |  None   | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config    |  False   |  None   | User-defined config values to be used within map expressions.                                                                               |
  | flattening_enabled   |  False   |  None   | 'True' to enable schema flattening and automatically expand nested properties.                                                              |
  | flattening_max_depth |  False   |  None   | The max depth to flatten schemas.                                                                                                           |



  | Stream Name              | Endpoint                                                                                           | Notes                 |
  | :----------------------- | :------------------------------------------------------------------------------------------------- | :-------------------- |
  | `groups`                 | [/v4/groups](https://dev.bitly.com/api-reference/#getGroups)                                       |                       |
  | `bitlinks`               | [/v4/groups/{group_guid}/bitlinks](https://dev.bitly.com/api-reference/#getBitlinksByGroup)        |                       |
  | `bsds`                   | [/v4/bsds](https://dev.bitly.com/api-reference/#getBSDs)                                           |                       |
  | `campaigns`              | [/v4/campaigns](https://dev.bitly.com/api-reference/#getCampaigns)                                 |                       |
  | `channels`               | [/v4/channels](https://dev.bitly.com/api-reference/#getChannels)                                   |                       |
  | `organizations`          | [/v4/organizations](https://dev.bitly.com/api-reference/#getOrganizations)                         |                       |
  | `webhooks`               | [/v4/organizations/{organization_guid}/webhooks](https://dev.bitly.com/api-reference/#getWebhooks) | Requires paid account |
  | `daily_bitlink_clicks`   | [/v4/bitlinks/{bitlink}/clicks](https://dev.bitly.com/api-reference/#getClicksForBitlink)          |                       |
  | `monthly_bitlink_clicks` | [/v4/bitlinks/{bitlink}/clicks](https://dev.bitly.com/api-reference/#getClicksForBitlink)          |                       |

  A full list of supported settings and capabilities is available by running: `tap-bitly --about`



  Generate an access token from the [Bitly API Console](https://app.bitly.com/settings/api/).



  You can easily run `tap-bitly` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-bitly --version
  tap-bitly --help
  tap-bitly --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run test:integration
  ```

  You can also test the `tap-bitly` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

  1. Install all plugins

     ```bash
     meltano install
     ```

  2. Check that the extractor is working properly

     ```bash
     meltano invoke tap-bitly --version
     ```

  3. Execute an ELT pipeline

     ```bash
     meltano run tap-bitly target-jsonl
     ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product 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 NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of 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 reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2021 Meltano  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 098f03ca1402b54cbeb4e3ba1f4193067776bb78683589380ebb045efa28394d
name: python-tap-bitso-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for tap-bitso
url: https://github.com/edgarrmondragon/tap-bitso
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-bitso-0.4.1-1.src.rpm
location_href: Packages/python-tap-bitso-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  ⚠️ Warning: this project is under active development, essential features are still missing and implementation subject to change. ⚠️

  `tap-bitso` is a Singer tap for the [Bitso API](https://bitso.com/api_info).

  Built with the Meltano [SDK](https://gitlab.com/meltano/sdk) for Singer Taps.



  ```bash
  pipx install git+https://github.com/edgarrmondragon/tap-bitso.git
  ```





  A full list of supported settings and capabilities for this
  tap is available by running:

  ```bash
  tap-bitso --about
  ```

  | Field      | Description             | Type           | Required | Default                 |
  |------------|-------------------------|----------------|----------|-------------------------|
  | `key`      | Bitso API Key           | `string`       | yes      |                         |
  | `secret`   | Bitso API Secret        | `string`       | yes      |                         |
  | `base_url` | Bitso API URL           | `string`       | no       | `https://api.bitso.com` |
  | `books`    | Tickers to get data for | `list(string)` | no       | `["btc_mxn"]`           |



  This tap handles the [digest access authentication for the Bitso API](https://docs.bitso.com/bitso-api/docs/authentication).



  You can easily run `tap-bitso` by itself or in a pipeline using [Meltano](www.meltano.com).



  ```bash
  tap-bitso --version
  tap-bitso --help
  tap-bitso --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install poetry
  poetry install
  ```

  <!--


  Create tests within the `tap_bitso/tests` subfolder and
    then run:

  ```bash
  poetry run pytest
  ```

  You can also test the `tap-bitso` CLI interface directly using `poetry run`:

  ```bash
  poetry run tap-bitso --help
  ```
  -->



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Next, install Meltano (if you haven't already) and any needed plugins:

  ```bash

  pipx install meltano

  cd tap-bitso
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-bitso --version

  meltano elt tap-bitso target-sqlite
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.

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


pkgId: 73bb3ba8a65270bf49db7f96f38a9d3fd7fec95126e15b58f8731d147d04fe64
name: python-tap-checkly-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for tap-checkly
url: https://github.com/edgarrmondragon/tap-checkly
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-checkly-0.4.1-1.src.rpm
location_href: Packages/python-tap-checkly-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-checkly/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-checkly/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-checkly/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-checkly"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-checkly/">
      <img alt="License" src="https://img.shields.io/pypi/pyversions/tap-checkly"/>
    </a>
  </div>

  Singer Tap for [Checkly](https://www.checklyhq.com/). Built with the [Meltano Singer SDK](https://sdk.meltano.com).

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | account_id          | True     | None    | Checkly Account ID |
  | token               | True     | None    | API Token for Checkly |
  | start_date          | False    | None    | Earliest datetime to get data from |
  | include_paid_streams| False    |       0 | Include streams that require a paid Checkly plan |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |

  A full list of supported settings and capabilities is available by running: `tap-checkly --about`



  | API Endpoint                  | Supported | Notes                     |
  | :---------------------------- | :-------: | :------------------------ |
  | `/v1/alert-channels`          |    ✅     |                            |
  | `/v1/alert-notifications`     |    ✅     |  Payment required          |
  | `/v1/checks`                  |    ✅     |                            |
  | `/v1/check-alerts`            |    ✅     |                            |
  | `/v1/check-groups`            |    ✅     |                            |
  | `/v1/check-results/{checkId}` |    N/A    | [Heavily rate-limited][1] |
  | `/v1/dashboards`              |    ✅     |                            |
  | `/v1/locations`               |    ✅     |                            |
  | `/v1/maintenance-windows`     |    ✅     |                            |
  | `/v1/private-locations`       |    ✅     |                            |
  | `/v1/runtimes`                |    ✅     |                            |
  | `/v1/snippets`                |    ✅     |                            |
  | `/v1/variables`               |    ✅     |                            |

  A full list of supported settings and capabilities is available by running: `tap-checkly --about`





  You can easily run `tap-checkly` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-checkly --version
  tap-checkly --help
  tap-checkly --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run test:integration
  ```

  You can also test the `tap-checkly` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

  1. Install all plugins

     ```bash
     meltano install
     ```

  1. Check that the extractor is working properly

     ```bash
     meltano invoke tap-checkly --version
     ```

  1. Execute an ELT pipeline

     ```bash
     meltano run tap-checkly target-jsonl
     ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to develop your own taps and targets.

  [1]: https://developers.checklyhq.com/reference/getv1checkresultscheckid


pkgId: deccbb122d75b31fc0e1febf8dca7a8fb4ca98599fc50bd9494ea63d080bd2da
name: python-tap-clinicaltrials-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for tap-clinicaltrials
url: https://github.com/edgarrmondragon/tap-clinicaltrials
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-clinicaltrials-0.2.1-1.src.rpm
location_href: Packages/python-tap-clinicaltrials-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Singer tap for [ClinicalTrials.gov](https://clinicaltrials.gov/data-about-studies/learn-about-api) study records data.

  Built with the [Meltano Tap SDK](https://sdk.meltano.com) for Singer Taps.



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | start_date          | False    | None    | Earliest datetime to get data from |
  | condition           | False    | None    | Conditions or disease query |
  | sponsor             | False    | None    | Sponsor query |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |
  | batch_config        | False    | None    |             |

  A full list of supported settings and capabilities is available by running: `tap-clinicaltrials --about`







  ```bash
  meltano add extractor tap-clinicaltrials --from-ref=https://raw.githubusercontent.com/edgarrmondragon/tap-clinicaltrials/main/plugin.yaml
  ```

  Requires Meltano v3.1.0+.



  Not yet available.



  ```bash
  python3 -m pip install --upgrade tap-clinicaltrials
  ```



  ```bash
  pipx install tap-clinicaltrials
  ```

  [pipx]: https://github.com/pypa/pipx



  ```bash
  git clone https://github.com/edgarrmondragon/tap-clinicaltrials
  cd tap-clinicaltrials
  python3 -m pip install .
  ```



  You can easily run `tap-clinicaltrials` by itself or in a pipeline using [Meltano](https://meltano.com/).



  1. Clone the repo and `cd` into it:

     ```bash
     git clone https://github.com/edgarrmondragon/tap-clinicaltrials.git
     cd tap-clinicaltrials
     ```

  1. Make sure you have [Meltano](https://docs.meltano.com/guide/installation-guide) installed

  1. Install all plugins

     ```bash
     meltano install
     ```

  1. Configure the `tap-clinicaltrials` tap:

     ```bash
     meltano config tap-clinicaltrials set start_date '2020-01-01'
     meltano config tap-clinicaltrials set condition 'COVID-19'
     meltano config tap-clinicaltrials set sponsor 'Pfizer'
     ```

  1. Run a test `tap-clinicaltrials` extraction

     ```bash
     meltano run tap-clinicaltrials target-duckdb
     ```

  1. That's it! Check the data

     ```console
     $ duckdb output/warehouse.duckdb -c "select nctid, lastUpdateSubmitDate, protocolsection->>'$.identificationModule.briefTitle' from clinicaltrials.studies limit 5;
     ┌─────────────┬──────────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────┐
     │    nctid    │ lastupdatesubmitdate │                      (protocolsection ->> '$.identificationModule.briefTitle')                      │
     │   varchar   │       varchar        │                                               varchar                                               │
     ├─────────────┼──────────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────┤
     │ NCT06156215 │ 2023-12-06           │ PROmotion of COVID-19 BOOSTer VA(X)Ccination in the Emergency Department - PROBOOSTVAXED            │
     │ NCT05487040 │ 2023-12-06           │ A Study to Measure the Amount of Study Medicine in Blood in Adult Participants With COVID-19 and …  │
     │ NCT06163677 │ 2023-12-07           │ A Study to Look at the Health Outcomes of Patients With COVID-19 and Influenza.                     │
     │ NCT05032976 │ 2023-12-07           │ Korea Comirnaty Post-marketing Surveillance                                                         │
     │ NCT05596734 │ 2023-12-11           │ A Study to Evaluate the Safety, Tolerability, and Immunogenicity of Combined Modified RNA Vaccine…  │
     └─────────────┴──────────────────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────┘
     ```



  ```bash
  tap-clinicaltrials --version
  tap-clinicaltrials --help
  tap-clinicaltrials --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run test:integration
  ```

  You can also test the `tap-clinicaltrials` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product 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 NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of 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 reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2023 [name of copyright owner]  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: a451aca0a64059519169938f78724eb1a6d39a23cac5b8eefe6f07f7c0b05a10
name: python-tap-forem-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for tap-forem
url: https://pypi.org/project/tap-forem/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-forem-0.3.1-1.src.rpm
location_href: Packages/python-tap-forem-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  Singer tap for the [Forem API](https://developers.forem.com/api).

  Built with the [Meltano SDK](https://sdk.meltano.com) for Singer Taps and Targets.



  * `catalog`
  * `discover`
  * `about`
  * `stream-maps`



  * `state`



  | Setting | Required | Default | Description |
  |:--------|:--------:|:-------:|:------------|
  | api_key | True     | None    | The Forem API key. |
  | tag     | True     | None    | Tag for filter articles by. |
  | api_url | False    | https://dev.to/api/ | The url for the API service. |

  A full list of supported settings and capabilities is available by running: `tap-forem --about`



  Follow the official docs in https://developers.forem.com/api#section/Authentication.



  You can easily run `tap-forem` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-forem --version
  tap-forem --help
  tap-forem --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install poetry
  poetry install
  ```



  Create tests within the `tests` folder and
    then run:

  ```bash
  poetry run pytest
  ```

  You can also test the `tap-forem` CLI interface directly using `poetry run`:

  ```bash
  poetry run tap-forem --help
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Open the `meltano.yml` and follow any _"TODO"_ items listed in
  the file.

  Next, install Meltano (if you haven't already) and any needed plugins:

  ```bash

  pipx install meltano

  cd tap-forem
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-forem --version

  meltano elt tap-forem target-jsonl
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.

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


pkgId: d74261a202e9983e67293f33158a4e3963925d877d82ea9c4aae3704b31b4db4
name: python-tap-geekbot-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for tap-geekbot
url: https://github.com/edgarrmondragon/tap-geekbot
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-geekbot-0.4.1-1.src.rpm
location_href: Packages/python-tap-geekbot-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-betterstack/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-betterstack/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-betterstack/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-betterstack"/>
    </a>
    <a href="https://github.com/astral-sh/ruff">
      <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
    </a>
    <a href="https://pypi.org/p/tap-geekbot/">
      <img alt="Python versions" src="https://img.shields.io/pypi/pyversions/tap-geekbot"/>
    </a>
  </div>

  Singer tap for [Geekbot](https://geekbot.com/).

  Built with the [Meltano Tap SDK](https://sdk.meltano.com) for Singer Taps.

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`



  - [ ] `Developer TODO:` Declare tap settings here.

  A full list of supported settings and capabilities is available by running: `tap-geekbot --about`



  - [ ] `Developer TODO:` If your tap requires special access on the source system, or any special authentication requirements, provide those here.



  You can easily run `tap-geekbot` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-geekbot --version
  tap-geekbot --help
  tap-geekbot --config CONFIG --discover > ./catalog.json
  ```



  - [ ] `Developer TODO:` As a first step, scan the entire project for the text "`TODO:`" and complete any recommended steps, deleting the "TODO" references once completed.



  ```bash
  pipx install poetry
  poetry install
  ```



  Create tests within the `tests` subfolder and then run:

  ```bash
  poetry run pytest
  ```

  You can also test the `tap-geekbot` CLI interface directly using `poetry run`:

  ```bash
  poetry run tap-geekbot --help
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Open the `meltano.yml` and follow any _"TODO"_ items listed in
  the file.

  Next, install Meltano (if you haven't already) and any needed plugins:

  ```bash

  pipx install meltano

  cd tap-geekbot
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-geekbot --version

  meltano elt tap-geekbot target-jsonl
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.


pkgId: 74957fc5987cbf263619b8add4dfbf67c05e6e8621d52fdf99dcc9cba14ee955
name: python-tap-jotform-help
arch: noarch
version: 0.5.9
epoch: 0
release: 1
summary: Development documents and examples for tap-jotform
url: https://github.com/edgarrmondragon/tap-jotform
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-jotform-0.5.9-1.src.rpm
location_href: Packages/python-tap-jotform-help-0.5.9-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-jotform/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-jotform/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-jotform/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-jotform"/>
    </a>
    <a href="https://pypi.org/p/tap-jotform">
      <img alt="License" src="https://img.shields.io/pypi/pyversions/tap-jotform"/>
    </a>
  </div>

  Singer Tap for Jotform. Built with the [Meltano Singer SDK](https://sdk.meltano.com).

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | api_key             | True     | None    | Authentication key. See https://api.jotform.com/docs/#authentication |
  | api_url             | False    | https://api.jotform.com | API Base URL |
  | user_agent          | False    | tap-jotform/0.0.1 | User-Agent header |
  | start_date          | False    | None    | Start date for data collection |
  | requests_cache | False    | None    | Cache configuration for HTTP requests |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |

  A full list of supported settings and capabilities is available by running: `tap-jotform --about`



  | Stream name | API endpoint      | API docs                                       | Notes |
  | :---------- | :---------------- | :--------------------------------------------- | :---- |
  | forms       | /user/forms       | https://api.jotform.com/docs/#user-forms       | Replication for this stream is opt-in. See instructions [below](#configuring-incremental-replication). |
  | questions   | /form/{form_id}/questions | https://api.jotform.com/docs/#form-id-questions | |
  | submissions | /user/submissions | https://api.jotform.com/docs/#user-submissions | Replication for this stream is opt-in. See instructions [below](#configuring-incremental-replication).  |
  | reports     | /user/reports     | https://api.jotform.com/docs/#user-reports | |
  | user_history | /user/history    | https://api.jotform.com/docs/#user-history | |




  By default, the `forms` and `submissions` stream are synced with `FULL_TABLE` replication. Incremental replication can be enabled by setting the replication metadata in the stream's entry in the catalog file:

  * `replication_method`: set to`INCREMENTAL`
  * `replication_key` set to `created_at` or `updated_at`. The former will omit updated submissions, while the latter will omit new submissions.

  For example, to enable incremental replication for the `submissions` stream:

  ```json
  {
    "streams": [
      {
        "tap_stream_id": "submissions",
        "stream": "submissions",
        "replication_method": "INCREMENTAL",
        "replication_key": "updated_at",
      }
    ]
  }
  ```



  To generate an API key, follow the instructions in https://api.jotform.com/docs/#gettingstarted.



  You can easily run `tap-jotform` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-jotform --version
  tap-jotform --help
  tap-jotform --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install poetry
  poetry install
  ```



  Create tests within the `tap_jotform/tests` subfolder and
    then run:

  ```bash
  poetry run pytest
  ```

  You can also test the `tap-jotform` CLI interface directly using `poetry run`:

  ```bash
  poetry run tap-jotform --help
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Open the `meltano.yml` and follow any _"TODO"_ items listed in
  the file.

  Next, install Meltano (if you haven't already) and any needed plugins:

  ```bash

  pipx install meltano

  cd tap-jotform
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-jotform --version

  meltano elt tap-jotform target-jsonl
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.


pkgId: 3443ad66207e6fed80c2d28c38ed2cf8e557e5fc62061ba082fbdd2fc2e7bb53
name: python-tap-neon-help
arch: noarch
version: 0.4.7
epoch: 0
release: 1
summary: Development documents and examples for tap-neon
url: https://github.com/edgarrmondragon/tap-neon
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-neon-0.4.7-1.src.rpm
location_href: Packages/python-tap-neon-help-0.4.7-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-neon/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-neon/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-neon/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-neon"/>
    </a>
    <a href="https://github.com/astral-sh/ruff">
      <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
    </a>
    <a href="https://pypi.org/p/tap-neon/">
      <img alt="Python versions" src="https://img.shields.io/pypi/pyversions/tap-neon"/>
    </a>
  </div>

  Singer tap for Neon Serverless Postgres.

  Built with the [Meltano Singer SDK](https://sdk.meltano.com).

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | api_key             | True     | None    | API Key for Neon Serverless Postgres |
  | start_date          | False    | None    | Earliest datetime to get data from |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |

  A full list of supported settings and capabilities is available by running: `tap-neon --about`



  Read the [docs](https://neon.tech/docs/get-started-with-neon/using-api-keys/) to learn how to generate an API key.



  You can easily run `tap-neon` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-neon --version
  tap-neon --help
  tap-neon --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run test:integration
  ```

  You can also test the `tap-neon` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

  1. Install all plugins

     ```bash
     meltano install
     ```

  1. Check that the extractor is working properly

     ```bash
     meltano invoke tap-neon --version
     ```

  1. Execute an ELT pipeline

     ```bash
     meltano run tap-neon target-jsonl
     ```

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product 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 NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of 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 reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2023 [name of copyright owner]  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 4440c1c387d79c61dcfc67c006fb91f702b9ec44843f04d81b693611e0093d85
name: python-tap-pipedream-help
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Development documents and examples for tap-pipedream
url: https://github.com/edgarrmondragon/tap-pipedream
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-pipedream-0.4.1-1.src.rpm
location_href: Packages/python-tap-pipedream-help-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-pipedream/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-pipedream/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-pipedream/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-pipedream"/>
    </a>
    <a href="https://github.com/astral-sh/ruff">
      <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;">
    </a>
    <a href="https://pypi.org/p/tap-pipedream/">
      <img alt="Python versions" src="https://img.shields.io/pypi/pyversions/tap-pipedream"/>
    </a>
  </div>

  Singer tap for [Pipedream](https://pipedream.com/). Built with the [Meltano Singer SDK](https://sdk.meltano.com).

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | token               | True     | None    | API Token for Pipedream |
  | start_date          | False    | None    | Earliest timestamp to get data from |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |

  A full list of supported settings and capabilities is available by running: `tap-pipedream --about`



  To generate an API key, follow the instructions [in the docs](https://pipedream.com/docs/api/auth/#pipedream-api-key).



  You can easily run `tap-pipedream` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-pipedream --version
  tap-pipedream --help
  tap-pipedream --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run test:integration
  ```

  You can also test the `tap-pipedream` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Install Meltano (if you haven't already) and any needed plugins:

  ```bash

  pipx install meltano

  cd tap-pipedream
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-pipedream --version

  meltano elt tap-pipedream target-jsonl
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.


pkgId: 3b0049d93a4c335a01d5ed7554f9dce510f79534eca377dc81c8d4ad59ea782a
name: python-tap-pushbullet-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for tap-pushbullet
url: https://github.com/edgarrmondragon/tap-pushbullet
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-pushbullet-0.4.0-1.src.rpm
location_href: Packages/python-tap-pushbullet-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Singer tap for Pushbullet.

  Built with the [Meltano Tap SDK](https://sdk.meltano.com) for Singer Taps.



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`



  - [ ] `Developer TODO:` Declare tap settings here.

  A full list of supported settings and capabilities is available by running: `tap-pushbullet --about`



  - [ ] `Developer TODO:` If your tap requires special access on the source system, or any special authentication requirements, provide those here.



  You can easily run `tap-pushbullet` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-pushbullet --version
  tap-pushbullet --help
  tap-pushbullet --config CONFIG --discover > ./catalog.json
  ```



  - [ ] `Developer TODO:` As a first step, scan the entire project for the text "`TODO:`" and complete any recommended steps, deleting the "TODO" references once completed.



  Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if you haven't already.



  Create tests within the `tests` subfolder and then run:

  ```bash
  uv run pytest
  ```

  You can also test the `tap-pushbullet` CLI interface directly using `uv run`:

  ```bash
  uv run tap-pushbullet --help
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Open the `meltano.yml` and follow any _"TODO"_ items listed in
  the file.

  Next, install Meltano (if you haven't already) and any needed plugins:

  ```bash

  uv tool install meltano


  meltano config meltano set venv.backend uv


  cd tap-pushbullet
  meltano install
  ```

  Now you can test and orchestrate using Meltano:

  ```bash

  meltano invoke tap-pushbullet --version


  meltano run tap-pushbullet target-jsonl
  ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.


pkgId: 63917cc144fa8b69d1dad3dc7282c846c37600e3c90ed2ba1f4140ff2bb15ef5
name: python-tap-readme-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for tap-readme
url: https://github.com/edgarrmondragon/tap-readme
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-readme-0.2.1-1.src.rpm
location_href: Packages/python-tap-readme-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Singer tap for ReadMe.com.

  Built with the [Meltano Singer SDK](https://sdk.meltano.com).



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`
  * `schema-flattening`
  * `batch`



  | Setting             | Required | Default | Description |
  |:--------------------|:--------:|:-------:|:------------|
  | api_key             | True     | None    | API Key for ReadMe.com |
  | stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
  | stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
  | faker_config        | False    | None    | Config for the [`Faker`](https://faker.readthedocs.io/en/master/) instance variable `fake` used within map expressions. Only applicable if the plugin specifies `faker` as an addtional dependency (through the `singer-sdk` `faker` extra or directly). |
  | flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
  | flattening_max_depth| False    | None    | The max depth to flatten schemas. |
  | batch_config        | False    | None    |             |

  A full list of supported settings and capabilities is available by running: `tap-readme --about`



  * 3.9
  * 3.10
  * 3.11
  * 3.12
  * 3.13



  Follow the [official authentication instructions](https://docs.readme.com/main/reference/intro/authentication) to get an API Key.



  You can easily run `tap-readme` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-readme --version
  tap-readme --help
  tap-readme --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run tests:integration
  ```

  You can also test the `tap-tap-readme` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

  1. Install all plugins

     ```bash
     meltano install
     ```

  1. Check that the extractor is working properly

     ```bash
     meltano invoke tap-tap-readme --version
     ```

  1. Execute an ELT pipeline

     ```bash
     meltano run tap-tap-readme target-jsonl
     ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product 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 NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of 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 reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2023 [name of copyright owner]  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: b3f5d764e057ac52c21f13316d26a447a22387865f1c5010631336c1b1f4183e
name: python-tap-shortcut-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for tap-shortcut
url: https://github.com/edgarrmondragon/tap-shortcut
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tap-shortcut-0.6.1-1.src.rpm
location_href: Packages/python-tap-shortcut-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">



  <div>
    <a href="https://results.pre-commit.ci/latest/github/edgarrmondragon/tap-shortcut/main">
      <img alt="pre-commit.ci status" src="https://results.pre-commit.ci/badge/github/edgarrmondragon/tap-shortcut/main.svg"/>
    </a>
    <a href="https://github.com/edgarrmondragon/tap-shortcut/blob/main/LICENSE">
      <img alt="License" src="https://img.shields.io/github/license/edgarrmondragon/tap-shortcut"/>
    </a>
  </div>

  Singer tap for Shortcut. Built with the [Meltano Tap SDK](https://sdk.meltano.com) for Singer Taps.

  </div>



  * `catalog`
  * `state`
  * `discover`
  * `about`
  * `stream-maps`



  | Setting | Required | Default | Description    |
  |:--------|:--------:|:-------:|:---------------|
  | token   | True     | None    | Shortcut Token |

  A full list of supported settings and capabilities is available by running: `tap-shortcut --about`



  See https://developer.shortcut.com/api/rest/v3#Authentication.



  You can easily run `tap-shortcut` by itself or in a pipeline using [Meltano](https://meltano.com/).



  ```bash
  tap-shortcut --version
  tap-shortcut --help
  tap-shortcut --config CONFIG --discover > ./catalog.json
  ```





  ```bash
  pipx install hatch
  ```



  Run integration tests:

  ```bash
  hatch run test:integration
  ```

  You can also test the `tap-shortcut` CLI interface directly:

  ```bash
  hatch run sync:console -- --about --format=json
  ```



  _**Note:** This tap will work in any Singer environment and does not require Meltano.
  Examples here are for convenience and to streamline end-to-end orchestration scenarios._

  Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

  1. Install all plugins

     ```bash
     meltano install
     ```

  1. Check that the extractor is working properly

     ```bash
     meltano invoke tap-shortcut --version
     ```

  1. Execute an ELT pipeline

     ```bash
     meltano run tap-shortcut target-jsonl
     ```



  See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
  develop your own taps and targets.

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


pkgId: 8bdc1683689db141df7c1dd0b513fe8b8be855521401fcc6f235868343014730
name: python-tartube-help
arch: noarch
version: 2.5.66
epoch: 0
release: 1
summary: Development documents and examples for tartube
url: https://tartube.sourceforge.io
rpm_license: LGPLv2.1+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tartube-2.5.66-1.src.rpm
location_href: Packages/python-tartube-help-2.5.66-1.noarch.rpm
checksum_type: sha256
description:
  Tartube is a GUI front-end for youtube-dl, yt-dlp and other compatible video
  downloaders.
  .
   - You can fetch a list of videos from your favourite channels and playlists on
   YouTube, BitChute, and hundreds of other websites
   - In buffering is an issue, you can download a temporary copy of a video
   before automatically opening it in your favourite media player
   - Tartube will organise your videos into convenient folders (if that's what
   you want)
   - Tartube can alert you when livestreams and debut videos are starting
   (YouTube only)
   - If you think the censors will remove a video, against the wishes of its
   creators and before you've had a chance to watch it, Tartube can make an
   archive copy
   - Tartube won't manipulate search results, unsubscribe you from your favourite
   channels or deliberately conceal videos
   - Tartube is free and open-source software


pkgId: 68200f5b7e328cf3a7b6eeba9abecd96b09db718af2929ce1b61c6050334e26a
name: python-task-scheduler2-by-kheal-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for task-scheduler2-by-kheal
url: https://github.com/Khealgit08/taskscheduler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-task-scheduler2-by-kheal-1.0.2-1.src.rpm
location_href: Packages/python-task-scheduler2-by-kheal-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Task Scheduler is a Python application for managing and scheduling tasks using a graphical user interface built with Tkinter. It supports adding, deleting, and modifying tasks, along with maintaining a task history.


  - Add tasks with descriptions, times, and dates.
  - View and modify a list of scheduled tasks.
  - Keep track of changes with a task history feature.
  - Simple and interactive GUI.


  - Python 3.7+
  - Dependencies:
    - `tkinter`
    - `tkcalendar`

  Install dependencies via pip:
  ```bash
  pip install tkcalendar


pkgId: 2c25ce85f052e7a81d2f7cc7d7ebac1974f690334269cfe9024ea585bca13c73
name: python-task-scheduler2-by-kheal-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for task-scheduler2-by-kheal
url: https://github.com/Khealgit08/taskscheduler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-task-scheduler2-by-kheal-1.0.3-1.src.rpm
location_href: Packages/python-task-scheduler2-by-kheal-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Task Scheduler is a Python application for managing and scheduling tasks using a graphical user interface built with Tkinter. It supports adding, deleting, and modifying tasks, along with maintaining a task history. It also allows users to add and manage taskscheduler account.


  * **Task Management:**
  - Add tasks with descriptions, times, and dates.
  - View and modify a list of scheduled tasks.
  - Keep track of changes with a task history feature.

  * **Add/Modify Account Info:**
  -Add account information: Username, Address, Contact Number, bio.
  -Username and bio will reflect to the top of the screen.

  * **User Interface**
  - Simple and interactive GUI.


  - Python 3.7+
  - Dependencies:
    - `tkinter`
    - `tkcalendar`

  Install dependencies via pip:
  ```bash
  pip install tkcalendar


pkgId: 9a16f04e1165dbca4a030819e68274d27ad85a3ea570db97688db448da4da38d
name: python-taskara-help
arch: noarch
version: 0.1.175
epoch: 0
release: 1
summary: Development documents and examples for taskara
url: https://pypi.org/project/taskara/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taskara-0.1.175-1.src.rpm
location_href: Packages/python-taskara-help-0.1.175-1.noarch.rpm
checksum_type: sha256
description:
  <!-- PROJECT LOGO -->
  <br />
  <p align="center">
    <!-- <a href="https://github.com/agentsea/skillpacks">
      <img src="https://project-logo.png" alt="Logo" width="80">
    </a> -->

    <h1 align="center">Taskara</h1>

    <p align="center">
      Task management for AI agents
      <br />
      <a href="https://docs.hub.agentsea.ai/taskara/intro"><strong>Explore the docs »</strong></a>
      <br />
      <br />
      <a href="https://youtu.be/exoOUUwFRB8">View Demo</a>
      ·
      <a href="https://github.com/agentsea/taskara/issues">Report Bug</a>
      ·
      <a href="https://github.com/agentsea/taskara/issues">Request Feature</a>
    </p>
    <br>
  </p>



  ```sh
  pip install taskara
  ```



  Create a task

  ```python
  from taskara import Task

  task = Task(
      description="Search for the most common varieties of french ducks",
      owner_id="delores@agentsea.ai"
  )
  ```

  Assign the task to an agent

  ```python
  task.assigned_to = "roko@agentsea.ai"
  ```

  Post a message to the task thread

  ```python
  task.post_message("assistant", "Getting started working on this")
  task.status = "in progress"
  ```

  Create a custom thread for the task

  ```python
  task.create_thread("debug")
  task.post_message("assistant", "I'll post debug messages to this thread", thread="debug")
  task.post_message("assistant", 'My current screenshot', images=["b64img"], thread="debug")
  ```

  Store prompts used to accomplish the task

  ```python
  from mllm import RoleThread, RoleMessage

  thread = RoleThread()
  thread.post(role="system", msg="I am a helpful assistant")

  response = RoleMessage(
      role="assistant",
      text="How can I help?"
  )
  task.store_prompt(thread, response, namespace="actions")
  ```

  Store the result

  ```python
  task.output = "The most common type of french duck is the Rouen"
  task.status = "success"
  ```

  Save the task

  ```python
  task.save()
  ```



  Taskara comes with a task tracker server which can be run on docker or kubernetes.

  Install surfkit to create a tracker

  ```
  pip install surfkit
  ```

  Create a tracker

  ```
  surfkit create tracker
  ```

  List trackers

  ```
  surfkit list trackers
  ```

  Get tracker logs

  ```
  surfkit logs tracker <name>
  ```

  Create a task

  ```
  surfkit create task --description "Search for french ducks"
  ```

  List tasks

  ```
  surfkit list tasks
  ```

  Get a task

  ```
  surfkit get task <id>
  ```



  Taskara is integrated with:

  - [Surfkit](https://github.com/agentsea/surfkit) A platform for AI agents
  - [MLLM](https://github.com/agentsea/mllm) A prompt management, routing, and schema validation library for multimodal LLMs
  - [Skillpacks](https://github.com/agentsea/skillpacks) A library to fine tune AI agents on tasks.
  - [Threadmem](https://github.com/agentsea/threadmem) A thread management library for AI agents



  Come join us on [Discord](https://discord.gg/hhaq7XYPS6).



  Thread and prompt storage can be backed by:

  - Sqlite
  - Postgresql

  Sqlite will be used by default. To use postgres simply configure the env vars:

  ```sh
  DB_TYPE=postgres
  DB_NAME=tasks
  DB_HOST=localhost
  DB_USER=postgres
  DB_PASS=abc123
  ```

  Thread image storage by default will utilize the db, to configure bucket storage using GCS:

  - Create a bucket with fine grained permissions
  - Create a GCP service account JSON with permissions to write to the bucket

  ```sh
  export THREAD_STORAGE_SA_JSON='{
    "type": "service_account",
    ...
  }'
  export THREAD_STORAGE_BUCKET=my-bucket
  ```


pkgId: a1ea8ea78b39b525801773751cde06a539484b4ec8e430dcb45ba3df3d3ef6b0
name: python-taskcluster-help
arch: noarch
version: 77.0.0
epoch: 0
release: 1
summary: Development documents and examples for taskcluster
url: https://github.com/taskcluster/taskcluster
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taskcluster-77.0.0-1.src.rpm
location_href: Packages/python-taskcluster-help-77.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Download](https://img.shields.io/badge/pypi-taskcluster-brightgreen)](https://pypi.python.org/pypi/taskcluster)
  [![License](https://img.shields.io/badge/license-MPL%202.0-orange.svg)](http://mozilla.org/MPL/2.0)

  **A Taskcluster client library for Python.**

  This library is a complete interface to Taskcluster in Python.  It provides
  both synchronous and asynchronous interfaces for all Taskcluster API methods.



  For a general guide to using Taskcluster clients, see [Calling Taskcluster APIs](https://docs.taskcluster.net/docs/manual/using/api).



  Before calling an API end-point, you'll need to create a client instance.
  There is a class for each service, e.g., `Queue` and `Auth`.  Each takes the
  same options, described below.  Note that only `rootUrl` is
  required, and it's unusual to configure any other options aside from
  `credentials`.

  For each service, there are sync and async variants.  The classes under
  `taskcluster` (e.g., `taskcluster.Queue`) operate synchronously.  The classes
  under `taskcluster.aio` (e.g., `taskcluster.aio.Queue`) are asynchronous.



  Here is a simple set-up of an Index client:

  ```python
  import taskcluster
  index = taskcluster.Index({
    'rootUrl': 'https://tc.example.com',
    'credentials': {'clientId': 'id', 'accessToken': 'accessToken'},
  })
  ```

  The `rootUrl` option is required as it gives the Taskcluster deployment to
  which API requests should be sent.  Credentials are only required if the
  request is to be authenticated -- many Taskcluster API methods do not require
  authentication.

  In most cases, the root URL and Taskcluster credentials should be provided in [standard environment variables](https://docs.taskcluster.net/docs/manual/design/env-vars).  Use `taskcluster.optionsFromEnvironment()` to read these variables automatically:

  ```python
  auth = taskcluster.Auth(taskcluster.optionsFromEnvironment())
  ```

  Note that this function does not respect `TASKCLUSTER_PROXY_URL`.  To use the Taskcluster Proxy from within a task:

  ```python
  auth = taskcluster.Auth({'rootUrl': os.environ['TASKCLUSTER_PROXY_URL']})
  ```



  If you wish to perform requests on behalf of a third-party that has small set
  of scopes than you do. You can specify [which scopes your request should be
  allowed to
  use](https://docs.taskcluster.net/docs/manual/design/apis/hawk/authorized-scopes),
  in the `authorizedScopes` option.

  ```python
  opts = taskcluster.optionsFromEnvironment()
  opts['authorizedScopes'] = ['queue:create-task:highest:my-provisioner/my-worker-type']
  queue = taskcluster.Queue(opts)
  ```



  The following additional options are accepted when constructing a client object:

  * `signedUrlExpiration` - default value for the `expiration` argument to `buildSignedUrl`
  * `maxRetries` - maximum number of times to retry a failed request



  API methods are available as methods on the corresponding client object.  For
  sync clients, these are sync methods, and for async clients they are async
  methods; the calling convention is the same in either case.

  There are four calling conventions for methods:

  ```python
  client.method(v1, v1, payload)
  client.method(payload, k1=v1, k2=v2)
  client.method(payload=payload, query=query, params={k1: v1, k2: v2})
  client.method(v1, v2, payload=payload, query=query)
  ```

  Here, `v1` and `v2` are URL parameters (named `k1` and `k2`), `payload` is the
  request payload, and `query` is a dictionary of query arguments.

  For example, in order to call an API method with query-string arguments:

  ```python
  await queue.listTaskGroup('JzTGxwxhQ76_Tt1dxkaG5g',
    query={'continuationToken': previousResponse.get('continuationToken')})
  ```




  It is often necessary to generate the URL for an API method without actually calling the method.
  To do so, use `buildUrl` or, for an API method that requires authentication, `buildSignedUrl`.

  ```python
  import taskcluster

  index = taskcluster.Index(taskcluster.optionsFromEnvironment())
  print(index.buildUrl('findTask', 'builds.v1.latest'))
  secrets = taskcluster.Secrets(taskcluster.optionsFromEnvironment())
  print(secret.buildSignedUrl('get', 'my-secret'))
  ```

  Note that signed URLs are time-limited; the expiration can be set with the `signedUrlExpiration` option to the client constructor, or with the `expiration` keyword arguement to `buildSignedUrl`, both given in seconds.



  If you have non-temporary taskcluster credentials you can generate a set of
  [temporary credentials](https://docs.taskcluster.net/docs/manual/design/apis/hawk/temporary-credentials) as follows. Notice that the credentials cannot last more
  than 31 days, and you can only revoke them by revoking the credentials that was
  used to issue them (this takes up to one hour).

  It is not the responsibility of the caller to apply any clock drift adjustment
  to the start or expiry time - this is handled by the auth service directly.

  ```python
  import datetime

  start = datetime.datetime.now()
  expiry = start + datetime.timedelta(0,60)
  scopes = ['ScopeA', 'ScopeB']
  name = 'foo'

  credentials = taskcluster.createTemporaryCredentials(
      
      clientId,
      
      accessToken,
      
      start,
      
      expiry,
      
      scopes,
      
      name
  )
  ```

  You cannot use temporary credentials to issue new temporary credentials.  You
  must have `auth:create-client:<name>` to create a named temporary credential,
  but unnamed temporary credentials can be created regardless of your scopes.


  Many taskcluster APIs require ISO 8601 time stamps offset into the future
  as way of providing expiration, deadlines, etc. These can be easily created
  using `datetime.datetime.isoformat()`, however, it can be rather error prone
  and tedious to offset `datetime.datetime` objects into the future. Therefore
  this library comes with two utility functions for this purposes.

  ```python
  dateObject = taskcluster.fromNow("2 days 3 hours 1 minute")
    
  dateString = taskcluster.fromNowJSON("2 days 3 hours 1 minute")
    
  ```

  By default it will offset the date time into the future, if the offset strings
  are prefixed minus (`-`) the date object will be offset into the past. This is
  useful in some corner cases.

  ```python
  dateObject = taskcluster.fromNow("- 1 year 2 months 3 weeks 5 seconds");
    
  ```

  The offset string is ignorant of whitespace and case insensitive. It may also
  optionally be prefixed plus `+` (if not prefixed minus), any `+` prefix will be
  ignored. However, entries in the offset string must be given in order from
  high to low, ie. `2 years 1 day`. Additionally, various shorthands may be
  employed, as illustrated below.

  ```
    years,    year,   yr,   y
    months,   month,  mo
    weeks,    week,         w
    days,     day,          d
    hours,    hour,         h
    minutes,  minute, min
    seconds,  second, sec,  s
  ```

  The `fromNow` method may also be given a date to be relative to as a second
  argument. This is useful if offset the task expiration relative to the the task
  deadline or doing something similar.  This argument can also be passed as the
  kwarg `dateObj`

  ```python
  dateObject1 = taskcluster.fromNow("2 days 3 hours");
  dateObject2 = taskcluster.fromNow("1 year", dateObject1);
  taskcluster.fromNow("1 year", dateObj=dateObject1);
    
  ```


  To generate slugIds (Taskcluster's client-generated unique IDs), use
  `taskcluster.slugId()`, which will return a unique slugId on each call.

  In some cases it is useful to be able to create a mapping from names to
  slugIds, with the ability to generate the same slugId multiple times.
  The `taskcluster.stableSlugId()` function returns a callable that does
  just this.

  ```python
  gen = taskcluster.stableSlugId()
  sometask = gen('sometask')
  assert gen('sometask') == sometask  # same input generates same output
  assert gen('sometask') != gen('othertask')

  gen2 = taskcluster.stableSlugId()
  sometask2 = gen('sometask')
  assert sometask2 != sometask  # but different slugId generators produce
                                
  ```



  The `scopeMatch(assumedScopes, requiredScopeSets)` function determines
  whether one or more of a set of required scopes are satisfied by the assumed
  scopes, taking *-expansion into account.  This is useful for making local
  decisions on scope satisfaction, but note that `assumed_scopes` must be the
  *expanded* scopes, as this function cannot perform expansion.

  It takes a list of a assumed scopes, and a list of required scope sets on
  disjunctive normal form, and checks if any of the required scope sets are
  satisfied.

  Example:

  ```python
  requiredScopeSets = [
      ["scopeA", "scopeB"],
      ["scopeC:*"]
  ]
  assert scopesMatch(['scopeA', 'scopeB'], requiredScopeSets)
  assert scopesMatch(['scopeC:xyz'], requiredScopeSets)
  assert not scopesMatch(['scopeA'], requiredScopeSets)
  assert not scopesMatch(['scopeC'], requiredScopeSets)
  ```



  Many Taskcluster API methods are paginated.  There are two ways to handle
  pagination easily with the python client.  The first is to implement pagination
  in your code:

  ```python
  import taskcluster
  queue = taskcluster.Queue({'rootUrl': 'https://tc.example.com'})
  i = 0
  tasks = 0
  outcome = queue.listTaskGroup('JzTGxwxhQ76_Tt1dxkaG5g')
  while outcome.get('continuationToken'):
      print('Response %d gave us %d more tasks' % (i, len(outcome['tasks'])))
      if outcome.get('continuationToken'):
          outcome = queue.listTaskGroup('JzTGxwxhQ76_Tt1dxkaG5g', query={'continuationToken': outcome.get('continuationToken')})
      i += 1
      tasks += len(outcome.get('tasks', []))
  print('Task Group %s has %d tasks' % (outcome['taskGroupId'], tasks))
  ```

  There's also an experimental feature to support built in automatic pagination
  in the sync client.  This feature allows passing a callback as the
  'paginationHandler' keyword-argument.  This function will be passed the
  response body of the API method as its sole positional arugment.

  This example of the built in pagination shows how a list of tasks could be
  built and then counted:

  ```python
  import taskcluster
  queue = taskcluster.Queue({'rootUrl': 'https://tc.example.com'})

  responses = []

  def handle_page(y):
      print("%d tasks fetched" % len(y.get('tasks', [])))
      responses.append(y)

  queue.listTaskGroup('JzTGxwxhQ76_Tt1dxkaG5g', paginationHandler=handle_page)

  tasks = 0
  for response in responses:
      tasks += len(response.get('tasks', []))

  print("%d requests fetch %d tasks" % (len(responses), tasks))
  ```



  This library can generate exchange patterns for Pulse messages based on the
  Exchanges definitions provded by each service.  This is done by instantiating a
  `<service>Events` class and calling a method with the name of the vent.
  Options for the topic exchange methods can be in the form of either a single
  dictionary argument or keyword arguments.  Only one form is allowed.

  ```python
  from taskcluster import client
  qEvt = client.QueueEvents({rootUrl: 'https://tc.example.com'})

  print(qEvt.taskCompleted({'taskId': 'atask'}))
  print(qEvt.taskCompleted(taskId='atask'))
  ```

  Note that the client library does *not* provide support for interfacing with a Pulse server.



  Logging is set up in `taskcluster/__init__.py`.  If the special
  `DEBUG_TASKCLUSTER_CLIENT` environment variable is set, the `__init__.py`
  module will set the `logging` module's level for its logger to `logging.DEBUG`
  and if there are no existing handlers, add a `logging.StreamHandler()`
  instance.  This is meant to assist those who do not wish to bother figuring out
  how to configure the python logging module but do want debug messages



  The Object service provides an API for reliable uploads and downloads of large objects.
  This library provides convenience methods to implement the client portion of those APIs, providing well-tested, resilient upload and download functionality.
  These methods will negotiate the appropriate method with the object service and perform the required steps to transfer the data.

  All methods are available in both sync and async versions, with identical APIs except for the `async`/`await` keywords.

  In either case, you will need to provide a configured `Object` instance with appropriate credentials for the operation.

  NOTE: There is an helper function to upload `s3` artifacts, `taskcluster.helper.upload_artifact`, but it is deprecated as it only supports the `s3` artifact type.



  To upload, use any of the following:

  * `await taskcluster.aio.upload.uploadFromBuf(projectId=.., name=.., contentType=.., contentLength=.., uploadId=.., expires=.., maxRetries=.., objectService=.., data=..)` - asynchronously upload data from a buffer full of bytes.
  * `await taskcluster.aio.upload.uploadFromFile(projectId=.., name=.., contentType=.., contentLength=.., uploadId=.., expires=.., maxRetries=.., objectService=.., file=..)` - asynchronously upload data from a standard Python file.
    Note that this is [probably what you want](https://github.com/python/asyncio/wiki/ThirdParty#filesystem), even in an async context.
  * `await taskcluster.aio.upload(projectId=.., name=.., contentType=.., contentLength=.., expires=.., uploadId=.., maxRetries=.., objectService=.., readerFactory=..)` - asynchronously upload data from an async reader factory.
  * `taskcluster.upload.uploadFromBuf(projectId=.., name=.., contentType=.., contentLength=.., expires=.., uploadId=.., maxRetries=.., objectService=.., data=..)` - upload data from a buffer full of bytes.
  * `taskcluster.upload.uploadFromFile(projectId=.., name=.., contentType=.., contentLength=.., expires=.., uploadId=.., maxRetries=.., objectService=.., file=..)` - upload data from a standard Python file.
  * `taskcluster.upload(projectId=.., name=.., contentType=.., contentLength=.., expires=.., uploadId=.., maxRetries=.., objectService=.., readerFactory=..)` - upload data from a sync reader factory.

  A "reader" is an object with a `read(max_size=-1)` method which reads and returns a chunk of 1 .. `max_size` bytes, or returns an empty string at EOF, async for the async functions and sync for the remainder.
  A "reader factory" is an async callable which returns a fresh reader, ready to read the first byte of the object.
  When uploads are retried, the reader factory may be called more than once.

  The `uploadId` parameter may be omitted, in which case a new slugId will be generated.



  To download, use any of the following:

  * `await taskcluster.aio.download.downloadToBuf(name=.., maxRetries=.., objectService=..)` - asynchronously download an object to an in-memory buffer, returning a tuple (buffer, content-type).
    If the file is larger than available memory, this will crash.
  * `await taskcluster.aio.download.downloadToFile(name=.., maxRetries=.., objectService=.., file=..)` - asynchronously download an object to a standard Python file, returning the content type.
  * `await taskcluster.aio.download.download(name=.., maxRetries=.., objectService=.., writerFactory=..)` - asynchronously download an object to an async writer factory, returning the content type.
  * `taskcluster.download.downloadToBuf(name=.., maxRetries=.., objectService=..)` - download an object to an in-memory buffer, returning a tuple (buffer, content-type).
    If the file is larger than available memory, this will crash.
  * `taskcluster.download.downloadToFile(name=.., maxRetries=.., objectService=.., file=..)` - download an object to a standard Python file, returning the content type.
  * `taskcluster.download.download(name=.., maxRetries=.., objectService=.., writerFactory=..)` - download an object to a sync writer factory, returning the content type.

  A "writer" is an object with a `write(data)` method which writes the given data, async for the async functions and sync for the remainder.
  A "writer factory" is a callable (again either async or sync) which returns a fresh writer, ready to write the first byte of the object.
  When uploads are retried, the writer factory may be called more than once.



  Artifacts can be downloaded from the queue service with similar functions to those above.
  These functions support all of the queue's storage types, raising an error for `error` artifacts.
  In each case, if `runId` is omitted then the most recent run will be used.

  * `await taskcluster.aio.download.downloadArtifactToBuf(taskId=.., runId=.., name=.., maxRetries=.., queueService=..)` - asynchronously download an object to an in-memory buffer, returning a tuple (buffer, content-type).
    If the file is larger than available memory, this will crash.
  * `await taskcluster.aio.download.downloadArtifactToFile(taskId=.., runId=.., name=.., maxRetries=.., queueService=.., file=..)` - asynchronously download an object to a standard Python file, returning the content type.
  * `await taskcluster.aio.download.downloadArtifact(taskId=.., runId=.., name=.., maxRetries=.., queueService=.., writerFactory=..)` - asynchronously download an object to an async writer factory, returning the content type.
  * `taskcluster.download.downloadArtifactToBuf(taskId=.., runId=.., name=.., maxRetries=.., queueService=..)` - download an object to an in-memory buffer, returning a tuple (buffer, content-type).
    If the file is larger than available memory, this will crash.
  * `taskcluster.download.downloadArtifactToFile(taskId=.., runId=.., name=.., maxRetries=.., queueService=.., file=..)` - download an object to a standard Python file, returning the content type.
  * `taskcluster.download.downloadArtifact(taskId=.., runId=.., name=.., maxRetries=.., queueService=.., writerFactory=..)` - download an object to a sync writer factory, returning the content type.



  The Python Taskcluster client has a module `taskcluster.helper` with utilities which allows you to easily share authentication options across multiple services in your project.

  Generally a project using this library will face different use cases and authentication options:

  * No authentication for a new contributor without Taskcluster access,
  * Specific client credentials through environment variables on a developer's computer,
  * Taskcluster Proxy when running inside a task.



  The class `taskcluster.helper.TaskclusterConfig` is made to be instantiated once in your project, usually in a top level module. That singleton is then accessed by different parts of your projects, whenever a Taskcluster service is needed.

  Here is a sample usage:

  1. in `project/__init__.py`, no call to Taskcluster is made at that point:

  ```python
  from taskcluster.helper import Taskcluster config

  tc = TaskclusterConfig('https://community-tc.services.mozilla.com')
  ```

  2. in `project/boot.py`, we authenticate on Taskcuster with provided credentials, or environment variables, or taskcluster proxy (in that order):

  ```python
  from project import tc

  tc.auth(client_id='XXX', access_token='YYY')
  ```

  3. at that point, you can load any service using the authenticated wrapper from anywhere in your code:

  ```python
  from project import tc

  def sync_usage():
      queue = tc.get_service('queue')
      queue.ping()

  async def async_usage():
      hooks = tc.get_service('hooks', use_async=True)  # Asynchronous service class
      await hooks.ping()
  ```

  Supported environment variables are:
  - `TASKCLUSTER_ROOT_URL` to specify your Taskcluster instance base url. You can either use that variable or instanciate `TaskclusterConfig` with the base url.
  - `TASKCLUSTER_CLIENT_ID` & `TASKCLUSTER_ACCESS_TOKEN` to specify your client credentials instead of providing them to `TaskclusterConfig.auth`
  - `TASKCLUSTER_PROXY_URL` to specify the proxy address used to reach Taskcluster in a task. It defaults to `http://taskcluster` when not specified.

  For more details on Taskcluster environment variables, [here is the documentation](https://docs.taskcluster.net/docs/manual/design/env-vars).



  Another available utility is `taskcluster.helper.load_secrets` which allows you to retrieve a secret using an authenticated `taskcluster.Secrets` instance (using `TaskclusterConfig.get_service` or the synchronous class directly).

  This utility loads a secret, but allows you to:
  1. share a secret across multiple projects, by using key prefixes inside the secret,
  2. check that some required keys are present in the secret,
  3. provide some default values,
  4. provide a local secret source instead of using the Taskcluster service (useful for local development or sharing _secrets_ with contributors)

  Let's say you have a secret on a Taskcluster instance named `project/foo/prod-config`, which is needed by a backend and some tasks. Here is its content:

  ```yaml
  common:
    environment: production
    remote_log: https://log.xx.com/payload

  backend:
    bugzilla_token: XXXX

  task:
    backend_url: https://backend.foo.mozilla.com
  ```

  In your backend, you would do:

  ```python
  from taskcluster import Secrets
  from taskcluster.helper import load_secrets

  prod_config = load_secrets(
    Secrets({...}),
    'project/foo/prod-config',

    
    prefixes=['common', 'backend'],

    
    required=['bugzilla_token'],

    
    existing={
      'environment': 'dev',
    }
  )
    
    
    
    
    
  ```

  In your task, you could do the following using `TaskclusterConfig` mentionned above (the class has a shortcut to use an authenticated `Secrets` service automatically):

  ```python
  from project import tc

  prod_config = tc.load_secrets(
    'project/foo/prod-config',

    
    prefixes=['common', 'bot'],

    
    existing={
      'environment': 'dev',
      'backend_url': 'http://localhost:8000',
    }
  )
    
    
    
    
    
  ```

  To provide local secrets value, you first need to load these values as a dictionary (usually by reading a local file in your format of choice : YAML, JSON, ...) and providing the dictionary to `load_secrets` by using the `local_secrets` parameter:

  ```python
  import os
  import yaml

  from taskcluster import Secrets
  from taskcluster.helper import load_secrets

  local_path = 'path/to/file.yml'

  prod_config = load_secrets(
    Secrets({...}),
    'project/foo/prod-config',

    
    local_secrets=yaml.safe_load(open(local_path)) if os.path.exists(local_path) else None,
  )
  ```



  This library is co-versioned with Taskcluster itself.
  That is, a client with version x.y.z contains API methods corresponding to Taskcluster version x.y.z.
  Taskcluster is careful to maintain API compatibility, and guarantees it within a major version.
  That means that any client with version x.* will work against any Taskcluster services at version x.*, and is very likely to work for many other major versions of the Taskcluster services.
  Any incompatibilities are noted in the [Changelog](https://github.com/taskcluster/taskcluster/blob/main/CHANGELOG.md).


pkgId: a71ca916f26047a06ceaa75a27995682415bae23fa1b6286ad19987881f3c4c6
name: python-taskiq-fastapi-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for taskiq-fastapi
url: https://pypi.org/project/taskiq-fastapi/
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taskiq-fastapi-0.3.3-1.src.rpm
location_href: Packages/python-taskiq-fastapi-help-0.3.3-1.noarch.rpm
checksum_type: sha256
description:
  This repository has a code to integrate FastAPI with taskiq easily.

  Taskiq and FastAPI both have dependencies and this library makes it possible to depend on
  `fastapi.Request` or `starlette.requests.HTTPConnection` in taskiq tasks.

  With this library you can easily re-use your fastapi dependencies in taskiq functions.



  It adds startup functions to broker so it imports your fastapi application
  and creates a single worker-wide Request and HTTPConnection objects that you depend on.

  THIS REQUEST IS NOT RELATED TO THE ACTUAL REQUESTS IN FASTAPI!
  This request won't have actual data about the request you were handling while sending task.



  Here we have an example of function that is being used by both taskiq's task and
  fastapi's handler function.

  I have a script called `test_script.py` so my app can be found at `test_script:app`.
  We use strings to resolve application to bypass circular imports.

  Also, as you can see, we use `TaskiqDepends` for Request. That's because
  taskiq dependency resolver must know that this type must be injected. FastAPI disallow
  Depends for Request type. That's why we use `TaskiqDepends`.

  ```python
  from fastapi import FastAPI, Request
  from pydantic import BaseModel
  from redis.asyncio import ConnectionPool, Redis
  from fastapi import Depends as FastAPIDepends
  from taskiq import TaskiqDepends
  import taskiq_fastapi
  from taskiq import ZeroMQBroker

  broker = ZeroMQBroker()

  app = FastAPI()


  @app.on_event("startup")
  async def app_startup():
      
      
      
      
      
      
      
      if not broker.is_worker_process:
          print("Starting broker")
          await broker.startup()
      print("Creating redis pool")
      app.state.redis_pool = ConnectionPool.from_url("redis://localhost")


  @app.on_event("shutdown")
  async def app_shutdown():
      
      
      
      
      
      
      
      if not broker.is_worker_process:
          print("Shutting down broker")
          await broker.shutdown()
      print("Stopping redis pool")
      await app.state.redis_pool.disconnect()



  taskiq_fastapi.init(broker, "test_script:app")




  def get_redis_pool(request: Request = TaskiqDepends()) -> ConnectionPool:
      return request.app.state.redis_pool


  @broker.task
  async def my_redis_task(
      key: str,
      val: str,
      
      
      
      pool: ConnectionPool = TaskiqDepends(get_redis_pool),
  ):
      async with Redis(connection_pool=pool) as redis:
          await redis.set(key, val)
          print("Value set.")


  class MyVal(BaseModel):
      key: str
      val: str


  @app.post("/val")
  async def setval_endpoint(val: MyVal) -> None:
      await my_redis_task.kiq(
          key=val.key,
          val=val.val,
      )
      print("Task sent")


  @app.get("/val")
  async def getval_endpoint(
      key: str,
      pool: ConnectionPool = FastAPIDepends(get_redis_pool),
  ) -> str:
      async with Redis(connection_pool=pool, decode_responses=True) as redis:
          return await redis.get(key)

  ```



  When using `InMemoryBroker` it may be required to update the dependency context manually. This may also be useful when setting up tests.

  ```py
  import taskiq_fastapi
  from taskiq import InMemoryBroker

  broker = InMemoryBroker()

  app = FastAPI()

  taskiq_fastapi.init(broker, "test_script:app")
  taskiq_fastapi.populate_dependency_context(broker, app)
  ```


pkgId: 179f47ea17cffb260c4e1c5b05f9c5299ff16695f9bb63754bda1885b966cdd7
name: python-tastytrade-help
arch: noarch
version: 9.5
epoch: 0
release: 1
summary: Development documents and examples for tastytrade
url: https://github.com/tastyware/tastytrade
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tastytrade-9.5-1.src.rpm
location_href: Packages/python-tastytrade-help-9.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Docs](https://readthedocs.org/projects/tastyworks-api/badge/?version=latest)](https://tastyworks-api.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/tastytrade)](https://pypi.org/project/tastytrade)
  [![Downloads](https://static.pepy.tech/badge/tastytrade)](https://pepy.tech/project/tastytrade)
  [![Release)](https://img.shields.io/github/v/release/tastyware/tastytrade?label=release%20notes)](https://github.com/tastyware/tastytrade/releases)



  A simple, reverse-engineered SDK for Tastytrade built on their (now mostly public) API. This will allow you to create trading algorithms for whatever strategies you may have quickly and painlessly in Python.



  - Up to 10x less code than using the API directly
  - Sync/async functions for all endpoints
  - Powerful websocket implementation for account alerts and data streaming, with support for auto-reconnection and reconnection callbacks
  - 100% typed, with Pydantic models for all JSON responses from the API
  - 95%+ unit test coverage
  - Comprehensive documentation
  - Utility functions for timezone calculations, futures monthly expiration dates, and more

  > [!NOTE]
  > Want to see the SDK in action? Check out [tastytrade-cli](https://github.com/tastyware/tastytrade-cli), a CLI for Tastytrade that showcases many of the SDK's features.



  ```console
  $ pip install tastytrade
  ```



  A session object is required to authenticate your requests to the Tastytrade API.
  You can create a real session using your normal login, or a certification (test) session using your certification login.

  ```python
  from tastytrade import Session
  session = Session('username', 'password')
  ```



  The streamer is a websocket connection to dxfeed (the Tastytrade data provider) that allows you to subscribe to real-time data for quotes, greeks, and more.

  ```python
  from tastytrade import DXLinkStreamer
  from tastytrade.dxfeed import Quote

  async with DXLinkStreamer(session) as streamer:
      subs_list = ['SPY']  # list of symbols to subscribe to
      await streamer.subscribe(Quote, subs_list)
      
      quote = await streamer.get_event(Quote)
      print(quote)
  ```

  ```python
  >>> Quote(event_symbol='SPY', event_time=0, sequence=0, time_nano_part=0, bid_time=0, bid_exchange_code='Q', bid_price=411.58, bid_size=400.0, ask_time=0, ask_exchange_code='Q', ask_price=411.6, ask_size=1313.0)
  ```

  Note that this is asynchronous code, so you can't run it as is unless you're using a Jupyter notebook or something similar.



  ```python
  from tastytrade import Account

  account = Account.get_accounts(session)[0]
  positions = account.get_positions(session)
  print(positions[0])
  ```

  ```python
  >>> CurrentPosition(account_number='5WX01234', symbol='IAU', instrument_type=<InstrumentType.EQUITY: 'Equity'>, underlying_symbol='IAU', quantity=Decimal('20'), quantity_direction='Long', close_price=Decimal('37.09'), average_open_price=Decimal('37.51'), average_yearly_market_close_price=Decimal('37.51'), average_daily_market_close_price=Decimal('37.51'), multiplier=1, cost_effect=<PriceEffect.CREDIT: 'Credit'>, is_suppressed=False, is_frozen=False, realized_day_gain=Decimal('7.888'), realized_day_gain_date=datetime.date(2023, 5, 19), realized_today=Decimal('-0.512'), realized_today_date=datetime.date(2023, 5, 19), created_at=datetime.datetime(2023, 3, 31, 14, 38, 32, 58000, tzinfo=datetime.timezone.utc), updated_at=datetime.datetime(2023, 5, 19, 16, 56, 51, 920000, tzinfo=datetime.timezone.utc), mark=None, mark_price=None, restricted_quantity=Decimal('0'), expires_at=None, fixing_price=None, deliverable_type=None)
  ```



  ```python
  from decimal import Decimal
  from tastytrade import Account
  from tastytrade.instruments import Equity
  from tastytrade.order import NewOrder, OrderAction, OrderTimeInForce, OrderType

  account = Account.get_account(session, '5WX01234')
  symbol = Equity.get_equity(session, 'USO')
  leg = symbol.build_leg(Decimal('5'), OrderAction.BUY_TO_OPEN)  # buy to open 5 shares

  order = NewOrder(
      time_in_force=OrderTimeInForce.DAY,
      order_type=OrderType.LIMIT,
      legs=[leg],  # you can have multiple legs in an order
      price=Decimal('-10')  # limit price, $10/share debit for a total value of $50
  )
  response = account.place_order(session, order, dry_run=True)  # a test order
  print(response)
  ```

  ```python
  >>> PlacedOrderResponse(buying_power_effect=BuyingPowerEffect(change_in_margin_requirement=Decimal('-125.0'), change_in_buying_power=Decimal('-125.004'), current_buying_power=Decimal('1000.0'), new_buying_power=Decimal('874.996'), isolated_order_margin_requirement=Decimal('-125.0'), is_spread=False, impact=Decimal('125.004'), effect=<PriceEffect.DEBIT: 'Debit'>), fee_calculation=FeeCalculation(regulatory_fees=Decimal('0.0'), clearing_fees=Decimal('-0.004'), commission=Decimal('0.0'), proprietary_index_option_fees=Decimal('0.0'), total_fees=Decimal('-0.004'), order=PlacedOrder(account_number='5WV69754', time_in_force=<OrderTimeInForce.DAY: 'Day'>, order_type=<OrderType.LIMIT: 'Limit'>, size='5', underlying_symbol='USO', underlying_instrument_type=<InstrumentType.EQUITY: 'Equity'>, status=<OrderStatus.RECEIVED: 'Received'>, cancellable=True, editable=True, edited=False, updated_at=datetime.datetime(1970, 1, 1, 0, 0, tzinfo=datetime.timezone.utc), legs=[Leg(instrument_type=<InstrumentType.EQUITY: 'Equity'>, symbol='USO', action=<OrderAction.BUY_TO_OPEN: 'Buy to Open'>, quantity=Decimal('5'), remaining_quantity=Decimal('5'), fills=[])], id=None, price=Decimal('-10.0'), gtc_date=None, value=None, stop_trigger=None, contingent_status=None, confirmation_status=None, cancelled_at=None, cancel_user_id=None, cancel_username=None, replacing_order_id=None, replaces_order_id=None, in_flight_at=None, live_at=None, received_at=None, reject_reason=None, user_id=None, username=None, terminal_at=None, complex_order_id=None, complex_order_tag=None, preflight_id=None, order_rule=None), complex_order=None, warnings=[Message(code='tif_next_valid_sesssion', message='Your order will begin working during next valid session.', preflight_id=None)], errors=None)
  ```



  ```python
  from tastytrade import DXLinkStreamer
  from tastytrade.dxfeed import Greeks
  from tastytrade.instruments import get_option_chain
  from tastytrade.utils import get_tasty_monthly

  chain = get_option_chain(session, 'SPLG')
  exp = get_tasty_monthly()  # 45 DTE expiration!
  subs_list = [chain[exp][0].streamer_symbol]

  async with DXLinkStreamer(session) as streamer:
      await streamer.subscribe(Greeks, subs_list)
      greeks = await streamer.get_event(Greeks)
      print(greeks)
  ```

  ```python
  >>> [Greeks(event_symbol='.SPLG230616C23', event_time=0, event_flags=0, index=7235129486797176832, time=1684559855338, sequence=0, price=26.3380972233688, volatility=0.396983376650804, delta=0.999999999996191, gamma=4.81989763184255e-12, theta=-2.5212017514875e-12, rho=0.01834504287973133, vega=3.7003015672215e-12)]
  ```

  For more examples, check out the [documentation](https://tastyworks-api.readthedocs.io/en/latest/).



  This is an unofficial SDK for Tastytrade. There is no implied warranty for any actions and results which arise from using it.

  ![Alt](https://repobeats.axiom.co/api/embed/292b0cb5dd25a26e9abc6e5f8d8e180461d9faf8.svg "Repobeats analytics image")

rpm_license:
  MIT License  Copyright (c) 2021 Graeme Holliday  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: f39d159c824e4455ec9412f048c13100a7cbeb2453e3054d1bf5fe306bcc28fb
name: python-tatc-help
arch: noarch
version: 3.3.0
epoch: 0
release: 1
summary: Development documents and examples for tatc
url: https://tatc.readthedocs.io
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tatc-3.3.0-1.src.rpm
location_href: Packages/python-tatc-help-3.3.0-1.noarch.rpm
checksum_type: sha256
description:
  The Tradespace Analysis Toolkit for Constellations (TAT-C) provides low-level
  data structures and functions for systems engineering analysis and design of
  Earth-observing space missions suitable for pre-Phase A concept studies.

  Documentation: [https://tatc.readthedocs.io](https://tatc.readthedocs.io)

  Repository: [https://github.com/code-lab-org/tatc](https://github.com/code-lab-org/tatc)



  TAT-C uses the pip build system to manage dependencies. Install the tatc library in "editable" mode:
  ```shell
  pip install -e .
  ```

  Note: the following optional dependencies are available with bracket notation:
   * `pip install -e ".[dev]"`: for development (unit testing, coverage, and linting)
   * `pip install -e ".[docs]"`: for generating documentation
   * `pip install -e ".[examples]"`: for running optional examples
   * `pip install -e ".[osse]"`: for running optional observing system simulation experiment (OSSE) examples

  Multiple optional dependencies can be installed with a comma-separated list (e.g., `pip install -e ".[dev,examples]"`)



  Development tools are applicable when working with the source code.



  Run unit tests with:
  ```shell
  python -m unittest
  ```

  Optionally, run a test coverage report:
  ```shell
  coverage run -m unittest
  ```
  including html output:
  ```shell
  coverage html
  ```



  Generate documentation from the `docs` directory using the command:
  ```shell
  make html
  ```



  This project uses the black code style, applied from the project root:
  ```shell
  black .
  ```



  Paul T. Grogan <paul.grogan@asu.edu>



  This project was supported in part by the National Aeronautics and Space
  Administration (NASA) Earth Science Division (ESD) Earth Science Technology
  Office (ESTO) Advanced Information Systems Technology (AIST) program.
  Financial support is acknowledged under NASA grant numbers: NNX17AE06G,
  80NSSC17K0586, 80NSSC20K1118, 80NSSC21K1515, 80NSSC22K1705, 80NSSC24K0575,
  80NSSC24K0921; NASA Jet Propulsion Laboratory subcontracts: 1689594, 1686623,
  1704657, 1705655; Texas A \& M University subaward M2403907.

  Current Project Team
   * PI: Paul T. Grogan <paul.grogan@asu.edu>
   * I. Josue Tapia-Tamayo <josue.tapia@asu.edu>
   * Suvan Kumar <skuma208@asu.edu>

  Project Alumni
   * Isaac Feldman
   * Hayden Daly
   * Lindsay Portelli
   * Matthew Sabatini
   * Evan Abel
   * Sigfried Hache


pkgId: fe900f0038544c3502aa5c7368dd52052771741646838fccc05a8ae4ee2b61c7
name: python-taxcalc-help
arch: noarch
version: 4.3.5
epoch: 0
release: 1
summary: Development documents and examples for taxcalc
url: https://github.com/PSLmodels/Tax-Calculator
rpm_license: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-taxcalc-4.3.5-1.src.rpm
location_href: Packages/python-taxcalc-help-4.3.5-1.noarch.rpm
checksum_type: sha256
description:
  Tax-Calculator is an open-source microsimulation model for static
  analysis of USA federal income and payroll taxes.
  We are seeking contributors and maintainers. If you are interested in joining the project as a contributor or maintainer,
  open a new [issue](https://github.com/PSLmodels/Tax-Calculator/issues) and ping [@MattHJensen](https://github.com/MattHJensen/) or [@jdebacker](https://github.com/jdebacker/) -- or just jump right in.
  Complete documentation is available
  [here](https://PSLmodels.github.io/Tax-Calculator/).


pkgId: d561f2e6b8dadf2ffa3d005b4c3b161ce8acea7e01887951f1a647b241643f4a
name: python-tb-nightly
arch: noarch
version: 2.19.0a20241214
epoch: 0
release: 1
summary: TensorBoard lets you watch Tensors Flow
url: https://github.com/tensorflow/tensorboard
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tb-nightly-2.19.0a20241214-1.src.rpm
location_href: Packages/python-tb-nightly-2.19.0a20241214-1.noarch.rpm
checksum_type: sha256
description:
  TensorBoard is a suite of web applications for inspecting and understanding
  your TensorFlow runs and graphs.

  Releases prior to 1.6.0 were published under the ``tensorflow-tensorboard`` name
  and may be found at https://pypi.python.org/pypi/tensorflow-tensorboard.


pkgId: 6595c27c9a7503847782493dd4beec6b536786c9df091c554dbe68667fcf2bf8
name: python-tc-admin-help
arch: noarch
version: 4.0.2
epoch: 0
release: 1
summary: Development documents and examples for tc-admin
url: https://github.com/taskcluster/tc-admin
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tc-admin-4.0.2-1.src.rpm
location_href: Packages/python-tc-admin-help-4.0.2-1.noarch.rpm
checksum_type: sha256
description:
  The `tc-admin` library supports administration of the runtime configuration of a Taskcluster deployment.
  This means creation and maintenance of resources such as roles, hooks, and worker pools, based on version-controlled specifications..



  This library is used as a dependency of a Python application containing code and configuration specific to the taskcluster deployment(s) being administered.
  The project should contain a `tc-admin.py` that serves to define the application configuration.

  Assuming that is in place, the tool is easy to use:

  After installing the app, run `tc-admin generate` to generate the expected set of resources (use `--json` to get JSON output).
  This will require `TASKCLUSTER_ROOT_URL` to be set in the environment, to know which deployment to talk to.
  Similarly, `tc-admin current` will generate the current set of resources (optionally with `--json`).
  To compare them, run `tc-admin diff`.

  If the configuration includes secrets, you may want to pass the `--without-secrets` option.
  This option skips managing the content of secrets, and thus needs neither access to secret values nor Taskcluster credentials to fetch secrets.

  Run `tc-admin apply` to apply the changes.
  Note that only `apply` will require Taskcluster credentials, and it's a good practice to only set TC credentials when running this command.

  See `tc-admin <command> --help` for more useful options.



  Checks are a way to double-check that purpose-specific invariants are satisfied in a Taskcluster deployment.
  For example, it may be important to check that only specific repository roles have scopes to create tasks in critical worker pools.
  Checks are defined as normal Python tests, and have access to the current and generated configurations.

  If the app has checks set up, then `tc-admin check` will run those checks.



  The operation of this tool is pretty simple: it generates a set of expected Taskcluster resources, downloads existing resources from the Taskcluster API, and compares them.
  A collection of resources also specifies the set of "managed" resources -- this allows deletion of resources that are no longer expected, without risk of deleting *everything* in the Taskcluster API.

  After generation, resources can be "modified".
  This is typically used to make minor changes to resources depending on environment.
  For exmaple, in a staging environment, hook schedules might be removed.





  A tc-admin app is configured by `tc-admin.py`.
  This is a Python file which is responsible for creating and customizing an `AppConfig` object.

  ```python
  from tcadmin.appconfig import AppConfig

  appconfig = AppConfig()

  ```

  The `tc-admin` command looks for `tc-admin.py` in the current directory, or in the directory given by `$TC_ADMIN_PY` or command-line argument `--tc-admin-py`.
  Like most Python modules, the global `__file__` is set when `tc-admin.py` is executed, and can be used to determine relative paths.

  Before `tc-admin.py` is executed, the current working directory is changed to the directory containing it.
  This enables relative imports as well as loading files with relative paths (such as with LocalLoader, below).



  This library can also be used programmatically.
  Simply create an AppConfig object directly and call `tcadmin.main.main` with it:

  ```python
  from tcadmin.appconfig import AppConfig
  from tcadmin.main import main

  def boot():
      appconfig = AppConfig()
      
      main(appconfig)

  if __name__ == "__main__":
      boot()
  ```

  Note that the current directory is not automatically set in this case.



  The AppConfig object contains a number of properties that can be customized, described below.
  During execution, the current AppConfig object is available from `AppConfig.current()`.
  This can be useful when generators or modifiers are defined in separate Python modules.



  Generators generate expected Taskcluster resources and defined the managed resource names.
  Each generator is an async function that is given a `Resources` object and is expected to call `resources.manage` and `resources.update`.

  Generators are registered with `appconfig.generators.register`, most easily with a decorator:

  ```python
  @appconfig.generators.register
  async def update_resources(resources):
      
  ```

  When generating secrets, respect the `--with-secrets` option, and generate secrets without values when it is false.
  You can also use this option to determine whether the generation process requires access to secret values.
  This allows generation runs with `--without-secrets` to occur without any credentials or access to secret values.

  ```python
  @appconfig.generators.register
  async def update_resources(resources):
      
      if appconfig.options.get('--with-secrets'):
          secretstore = load_secret_values()
          resources.add(Secret(
              name="top-secret/cookie-recipe",
              secret=secretstore.decrypt('recipes/double-chocolate-chip')))
       else:
          resources.add(Secret(name="top-secret/cookie-recipe"))
  ```



  Modifiers are responsible for modifying an existing set of resources.
  Since resources are immutable, the signature differs slightly from generators:

  ```python
  @appconfig.modifiers.register
  async def modify_resources(resources):
      
      return resources.map(..)
  ```

  Modifiers are called sequentially in the order in which they were registered.



  Callbacks are external function from your own application that can be executed at specific times during the `tc-admin apply` execution:

  * A `before_apply` callback will run before a resource is created, updated or deleted,
  * A `after_apply` callback will run after a resource has beencreated, updated or deleted.

  Supported actions are :

  * create
  * update
  * delete

  By default all actions are used.

  All resources are supported by callbacks, and enabled by default. If you want to limit your callback to some resources, you need to specify them using their class (not a string).

  You can declare your callbacks as:

  ```python
  from tcadmin.resources import Secret

  async def my_action(action, resource):
      print("Got a callback on", action, resource)


  appconfig.callbacks.add("after_apply", my_action, actions=["update", "delete"], resources=[Secret, ])
  ```



  Apps can add additional command-line options, the values of which are then available during resource generation.

  To register an option, call `appconfig.options.add`, with the full option name and any of the following keyword options:
   * `required` - if True, the option is required
   * `help` - help string to be shown in `tc-admin generate --help`
   * `default` - default value for the option

  To retrieve the option value during generation, call `appconfig.options.get(name)`.
  All together, then:

  ```python
  appconfig.options.add("--branch", help="configuration branch to read from")

  @appconfig.generators.register
  async def update_resources(resources):
      branch = appconfig.options.get("--branch")
      
  ```

  As a special case, the `--with-secrets` secret is available through this same mechanism.



  The `appconfig.check_path` property gives the path of the checks to run for `tc-admin check`, relative to the current directory.
  This directory is a "normal" pytest directory.

  To help distinguish checks from tests, include a `pytest.ini` in this directory:

  ```ini
  [pytest]
  python_classes = Check*
  python_files = check_*.py
  python_functions = check_*
  ```



  The `appconfig.description_prefix` property allows the users to customize the prefix of the description.
  This can be customized in the `tc-admin.py` as follows:

  ```python
  from tcadmin.appconfig import AppConfig

  appconfig = AppConfig()
  appconfig.description_prefix = "YOUR_CUSTOM_PREFIX"
  ```

  The DEFAULT value of the description_prefix is `*DO NOT EDIT* - This resource is configured automatically.\n\n`



  For the common case of a configuration that applies to only one Taskcluster deployment, specify that deployment's root URL in `tc-admin.py`:

  ```python
  from tcadmin.appconfig import AppConfig

  appconfig = AppConfig()
  appconfig.root_url = "https://taskcluster.example.com"
  ```

  To support more complex cases, this value can also be an async callable.
  It will be invoked once, after the `click` options have been processed, so it can access `appconfig.options` if necessary.

  The current root URL is available from an async helper function:

  ```python
  from tcadmin.util.root_url import root_url

  async def foo():
      print(await root_url())
  ```

  This will retrieve the value from the AppConfig or, if that is not set, from `TASKCLUSTER_ROOT_URL`.
  If both are set, and the values do not match, it will produce an error message.



  Most uses of this library load configuration data from some easily-modified YAML files.
  The `tcadmin.util.config` package provides some support for loading and parsing these files.
  All of this is entirely optional; use what is appropriate to the purpose.



  First, define a loader that can load data from files.

  ```python
  from tcadmin.util.config import LocalLoader

  loader = LocalLoader()
  ```

  The LocalLoader class knows how to load configuration from files relative to `tc-admin.py`.
  It has a `load` method that will load data, optionally parsing it as YAML:

  ```python
  data = loader.load("data.bin")
  aliases = await loader.load("aliases.yml", parse="yaml")
  ```

  You can also define your own loader class.
  Just implement the `load_raw` method to return bytes, given a filename.



  YAML data is inconvenient to deal with in Python, introducig a lot of `[".."]` noise.
  Commonly, config files are either a top-level array, or a top-level object with named "stanzas" of configuration.
  The ConfigList and ConfigDict classes support these formats.
  We suggest using these with the Python `attrs` library.

  Define a class that inherits from either of these classes, specifies the filename to load from, and has an `Item` class for the items in the collection:

  ```python
  from tcadmin.util.config import ConfigList

  class Workers(ConfigList):
      filename = "workers.yml"

      @attr.s
      class Item:
          workerId = attr.ib(type=str)
          bigness = attr.ib(type=int, default=1)
  ```

  Then simply call `await Workers.load(loader)` to load a `workers.yml` that looks something like

  ```yaml
  - workerId: small
    bigness: 5
  - workerId: huge
    bigness: 5000
  ```

  The ConfigDict class is similar, but parses files like

  ```yaml
  small:
    bigness: 5
  huge:
    bigness: 5000
  ```

  ConfigList creates new `Item` instances from array elements `item` with `Item(**item)`.
  ConfigDict creates new `Item` instances from `k: item` with `Item(k, **item)`.
  This approach is compatible with `attrs`, where in the latter case `k` should be the first attribute defined.

  If array elements or object values are not themselves YAML objects, add a class method named `transform_item` to transform the data in the YAML file into a Python dictionary.
  For example:

  ```python
  class Workers(ConfigList):

      @classmethod
      def transform_item(cls, item):
          
          if isinstance(item, str):
              return {"workerId": item}
          return item

      ...
  ```



  The `tcadmin.resources` package contains clasess for defining Taskcluster resources and collections.

  ```python
  from tcadmin.resources import Resources
  ```

  The `Resources` class defines a collection of resources and tracks what resources are managed.
  Resources found in the Taskcluster deployment that match the "managed" patterns but are not generated will be deleted on `apply`.
  The class has the following methods:

  * `resources.add(resource)` - add a resource to the collection.  The resource must be managed.
  * `resources.update(iterable)` - add an iterable full of resources to the collection.  All resources must be managed.
  * `resources.manage(pattern)` - consider reources matching regular expression string `pattern` to be managed
  * `resources.is_managed(id)` - return true if the given resource is managed
  * `resources.filter(pattern)` - return a new Resources object containing only resources matching the given regular expression string
  * `resources.map(functor)` - return a new Resources object, with fuctor applied to each resource.  This is typically used in modifiers.

  Resources must be unique -- tc-admin cannot manage multiple hooks with the same name, for example.
  However, some resource kinds support merging, where adding a resource with the same identity as one that already exists "merges" it into the existing resource.
  See the description of roles, below.

  The remaining classes represent individual resources.
  Each has an `id` formed from its kind and the unique identifier for the resource in the Taskcluster.
  For example, `Hook=release-hooks/beta-release`.
  Resources are immutable once created, but can be "evolved" (returning a new resource) with `rsrc.evolve(**updates)`.

  Resources with descriptions automatically prepend a "DO NOT EDIT" prefix to dissuade users from editing them in the Taskcluster UI.



  ```python
  from tcadmin.resources import Hook, Binding

  hook = Hook(
      hookGroupId=..,
      hookId=..,
      name=..,
      description=..,
      owner=..,
      emailOnError=..,
      schedule=(.., ..),
      bindings=(.., ..),
      task={..},
      triggerSchema={..})
  ```

  Most of these fields correspond directly to the Taskcluster definition.
  Both `schedule` and `bindings` must be tuples, not lists (as lists are mutable).
  The items in `schedule` are cron-like strings.
  The items in `bindings` are instances of `Binding(exchange=.., routingKeyPattern=..)`.



  ```python
  from tcadmin.resources import Secret

  secret = Secret(
      name=..,
      secret=..)



  secret = Secret(name=..)
  ```

  Secrets are managed using the Secret resource type.
  While Taskcluster supports expiration times on secrets, this library sets those times the far future, effectively creating non-expiring secrets

  This library is careful to not display secret values in its output.
  Instead, it displays `<unknown>` when not managing secret values, and displays a salted hash of the secret value when managing secret values.
  The salted hash allows `tc-admin diff` to show that a secret value has changed, without revealing the value of that secret.
  The salt includes a per-run salt, and the name of the secret, with the result that even if two secrets have the same value, they will be shown with different hashes in `tc-admin generate`.



  ```python
  from tcadmin.resources import Role

  role = Role(
      roleId=..,
      description=..,
      scopes=(.., ..))
  ```

  As with hooks, `scopes` must be a tuple (not a list) of strings.

  Roles can be merged if their descriptions match.
  The resulting role contains the union of the scopes of the input roles.
  This functionality makes management of roles easier in cases where different parts of the generation process may add scopes to the same role.

  For example:

  ```python
  resources.add(Role(roleId="my-role", description="My Role", scopes=["scope1"]))
  resources.add(Role(roleId="my-role", description="My Role", scopes=["scope2"]))
  ```

  This will result in a single Role with scopes `["scope1", "scope2"]`.



  ```python
  from tcadmin.resources import Client

  client = Client(
      clientId=..,
      description=..,
      scopes=(.., ..))
  ```

  Clients work much like roles.
  As with roles, `scopes` must be a tuple (not a list) of strings.
  This library does not manage access tokens: it discards them from the response to `auth.createClient`.
  The expectation is that project admins who need credentials for the managed clients will call `auth.resetAccessToken` and use the returned token.

  Clients configured by this library have an expiration date far in the future.
  Like roles, the clients managed here last "forever".



  ```python
  from tcadmin.resources import WorkerPool

  workerPool = WorkerPool(
      workerPoolId=..,
      providerId=..,
      description=..,
      owner=..,
      config={..},
      emailOnError=..)
  ```

  All attributes of this class match the Taskcluster definition.



  The library provides a number of utilities for common application requirements.

  *NOTE*: only functions described in this README are considered stable.
  Other functions defined by the library may change without notice.



  As an aid to writing checks, tc-admin supplies local implementations of various scope-related algorithms.

  ```python
  from tcadmin.util.scopes import satisfies, normalizeScopes, Resolver
  ```

  The `satisfies` function determines scope satisfaction, without any expansion.
  Satisfaction means that the first argument contains all scopes in the second argument.

  ```python
  assert satisfies(['balloons:*', 'cake:birthday'], ['baloons:mylar:happy-birthday'])
  ```

  The `normalizeScopes` function normalizes a scopeset, removing redundant scopes and sorting.

  ```python
  assert normalizedScopes(['balloons:*', 'balloons:mylar:*']) == ['baloons:*']
  ```

  Finally, `Resolver` can perform scope expansion.
  It is initialized with a dictionary mapping roleIds to scope lists.
  Alternately, it can be initialized from a `Resources` instance using `Resolver.from_resources(resources)`.

  Its `expandScopes` method behaves identically to the remote call `auth.expandScopes`.

  ```python
  resolver = Resolver.from_resources(resources)
  assert resolver.expandScopes(['assume:clown:grimaldi']) == ['assume:clown:grimaldi', 'ruffle:full']
  ```



  The library uses `aiohttp` to communicate with Taskcluster, and establishes a single session for efficiency.
  Applications can use the same session for any other HTTP operations.

  ```python
  from tcadmin.util.session import aiohttp_session

  async def foo():
      
      async with aiohttp_session().get(url) as response:
          response.raise_for_status()
          result = await response.read()
  ```

  Tests and checks can set this value using `with_aiohttp_session`:

  ```python
  from tcadmin.util.sessions import with_aiohttp_session
  import pytest

  @pytest.mark.asyncio
  @with_aiohttp_session
  async def test_something():
      
  ```



  A MatchList is a list of regular expressions that can determine whether a given
  string matches one of those patterns.  Patterns are rooted at the left, but
  should use `$` where required to match the end of the string.

  ```python
  from tcadmin.util.matchlist import MatchList

  ml = MatchList()
  ml.add("fo+$")
  ml.add("ba+r$")
  assert ml.matches("foo")
  ```

  This functionality is used to track managed resources, but may be useful otherwise.



  To install for development, in a virtualenv:

  ```
  pip install -e [path]
  ```

  And to run flake8 and tests:

  ```
  python setup.py flake8
  python setup.py test
  ```

  The library uses [Black](https://black.readthedocs.io/en/stable/) to format code.

  ```
  pip install black
  black tcadmin
  ```



  To release:

   * update version in `setup.py` and `git commit -m "vX.Y.Z"`
   * `git tag vX.Y.Z`
   * `git push`
   * `git push --tags`
   * `./release.sh --real` and enter your pypi credentials when prompted (omit the `--real` to try it against the testing pypi, if you're not sure)
   * go to https://github.com/taskcluster/tc-admin/releases/tag/vX.Y.Z and create a new release from the tag with a brief description of the changes
   * build and publish a new version of the linux/amd64 tc-admin docker image:

  ```bash
  pass git pull
  pass hub.docker.com/taskclusterbot   # fetch credentials for making docker release
  docker logout
  docker login                         # use credentials output above
  docker build -t taskcluster/tc-admin:X.Y.Z .
  docker push taskcluster/tc-admin:X.Y.Z
  ```


pkgId: c859c23522caf6f6b7e6f2eed5841692ccb27a19685e07586bf5b48c18272add
name: python-tc-etl-lib-help
arch: noarch
version: 0.14.0
epoch: 0
release: 1
summary: Development documents and examples for tc-etl-lib
url: https://pypi.org/project/tc-etl-lib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tc-etl-lib-0.14.0-1.src.rpm
location_href: Packages/python-tc-etl-lib-help-0.14.0-1.noarch.rpm
checksum_type: sha256
description:
  platform linux -- Python 3.9.2, pytest-8.3.4, pluggy-1.0.0
  rootdir: /home/fermin/src/etl-framework/python-lib/tc_etl_lib
  collected 7 items


pkgId: 4b99ebf6fa793c0117e247ac4391a3b353660813d3e60c11b4eb18d53e326139
name: python-tccli-help
arch: noarch
version: 3.0.1234.1
epoch: 0
release: 1
summary: Development documents and examples for tccli
url: https://github.com/TencentCloud/tencentcloud-cli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tccli-3.0.1234.1-1.src.rpm
location_href: Packages/python-tccli-help-3.0.1234.1-1.noarch.rpm
checksum_type: sha256
description:
  欢迎使用腾讯云命令行工具(TCCLI)，TCCLI是管理腾讯云资源的统一工具。通过腾讯云命令行工具，您可以快速轻松的调用腾讯云 API来管理您的腾讯云资源。您还可以基于腾讯云的命令行工具来做自动化和脚本处理，能够以更多样的方式进行组合和重用。

  1. 安装 Python 环境和 Pip 工具，安装命令行工具前请确保您的系统已经安装了 Python 环境和 Pip 工具。**注意python版本必须为2.7及以上版本**,更多内容请参考[python主页](https://www.python.org/)和[pip主页](https://pypi.org/project/pip/)。
  2. TCCLI依赖于TencentCloudApi Python SDK，**如果TencentCloudApi Python SDK的版本号小于要安装TCCLI版本号，在安装TCCLI时会自动升级TencentCloudApi Python SDK**。
  3. 安装TCCLI，执行以下命令：
  ```bash
  pip install tccli
  ```
  如果是MacOS用户，您还可以使用homebrew来安装tccli：

  > 执行如下命令之前您需要先安装homebrew，安装的方法可以参考[homebrew官网](https://brew.sh/index_zh-cn)
  ```bash
  brew tap tencentcloud/tccli
  brew install tccli
  ```
  注意：如果是从3.0.252.3以下版本升级的需要执行
  ```bash
  sudo pip uninstall tccli jmespath
  sudo pip install tccli
  ```
  4. 安装完成之后执行tccli --version检测是否安装成功。
  5. 如果您的环境是linux环境，您可以通过以下命令启动自动补全功能：
  ```bash
  complete -C 'tccli_completer' tccli
  ```
  可以将命令``complete -C 'tccli_completer' tccli``加入环境变量(/etc/profile)中，使自动补全功能一直有效。



  ```shell
  docker run --rm -it tencentcom/tencentcloud-cli --version
  docker run --rm -it tencentcom/tencentcloud-cli help
  ```



  ```yaml
  master:
    push:
    - stages:
      - name: run with tencentcloud-cli
        image: tencentcom/tencentcloud-cli
        commands: |
          tccli --version
          tccli help
  ```


  要使用腾讯云命令行工具，您还需要进行一些初始化配置，使其完成使用 云 API的必要前提条件。
  1. 交互模式，您可以通过tccli configure命令进入交互模式快速配置。

  ```bash
  $  tccli configure
  TencentCloud API secretId [*afcQ]:AKIDwLw1234MMfPRle2g9nR2OTI787aBCDP
  TencentCloud API secretKey [*ArFd]:OxXj7khcV1234dQSSYNABcdCc1LiArFd
  region: ap-guangzhou
  output[json]:
  ```
  secretId: 云 API 密钥SecretId。
  secretIKey: 云 API 密钥SecretKey。
  region： 云产品地域，请移驾对应产品页面获取可用的region。
  output： 可选参数，请求回包输出格式，支持[json table text]三种格式，默认为json。
  更多信息请执行tccli configure help查看。

  注意：如果环境变量定义了相关配置，则会优先于配置文件生效。分别为 TENCENTCLOUD\_SECRET\_ID，TENCENTCLOUD\_SECRET\_KEY，TENCENTCLOUD\_REGION。

  2. 命令行模式，通过命令行模式您可以在自动化脚本中配置您的信息。
  ```bash

  tccli configure set secretId AKIDwLw1234MMfPRle2g9nR2OTI787aBCDP
  tccli configure set region ap-guangzhou  output json language zh-CN


  tccli configure set-root-domain internal.tencentcloudapi.com


  tccli configure get secretKey
  secretKey = OxXj7khcV1234dQSSYNABcdCc1LiArFd


  tccli configure list
  credential:
  secretId =  AKIDwLw1234MMfPRle2g9nR2OTI787aBCDP
  secretKey =  OxXj7khcV1234dQSSYNABcdCc1LiArFd
  configure:
  region =  ap-guangzhou
  output =  json
  language = zh-CN


  tccli configure remove
  ```
  更多信息请执行tccli configure [list get set remove] help查看。

  3. 多账户支持，TCCLI支持多账户，方便您多种配置同时使用。
  ```bash
  在交互模式中指定账户名test。
  $  tccli configure --profile test
  TencentCloud API secretId [*BCDP]:AKIDwLw1234MMfPRle2g9nR2OTI787aBCDP
  TencentCloud API secretKey [*ArFd]:OxXj7khcV1234dQSSYNABcdCc1LiArFd
  region: ap-guangzhou
  output[json]:


  tccli configure set region ap-guangzhou  output json language zh-CN --profile test
  tccli configure get secretKey      --profile test
  tccli configure list      --profile test
  tccli configure remove      --profile test
  tccli configure set-root-domain internal.tencentcloudapi.com --profile test


  在调用接口时指定账户(以cvm DescribeZones接口为例)。
  tccli cvm DescribeZones --profile test
  ```
  如果不希望输入命令是手动指定账户名，还可以设置环境变量，tccli能从环境变量中读取指定的profile
  ```bash
  export TCCLI_PROFILE=test
  ```

  4. 您可以配置https代理，让tccli通过代理调用API

  在环境变量中配置https代理
  ```bash

  export https_proxy=https://192.168.1.1:1111
  export https_proxy=https://myproxy.com:1111


  setx http_proxy=https://192.168.1.1:1111
  set  http_proxy=https://myproxy.com:1111

  ```

  您也可以直接使用'--https-proxy'选项设置https代理
  ```bash

  tccli cvm DescribeRegions --https-proxy https://192.168.1.1:1111
  ```



  腾讯云命令行工具（TCCLI）目前支持以下几种方式进行凭证管理，获取凭证的优先级：实例角色 > 角色 > TKE OIDC > 临时密钥 > 永久密钥：

  1. 实例角色

  有关实例角色的相关概念请参阅：[腾讯云实例角色](https://cloud.tencent.com/document/product/213/47668)

  在您为实例绑定角色后，您可以在实例中访问相关元数据接口获取临时凭证，SDK 会自动刷新临时凭证。相关命令如下：

  使用方式：
  - 命令行输入
  ```bash
  tccli cvm DescribeRegions --use-cvm-role
  ```

  2. 角色

  有关角色的相关概念请参阅：[腾讯云角色概述](https://cloud.tencent.com/document/product/598/19420)

  要使用此种方式，您必须在腾讯云访问管理控制台上创建了一个角色，具体创建过程请参阅：[腾讯云角色创建](https://cloud.tencent.com/document/product/598/19381)

  在您拥有角色后，可以通过如下方式获取临时凭证，相关命令如下：

  - 命令行输入

  ```bash
  tccli cvm DescribeRegions --secretId xx --secretKey xx --role-arn xx --role-session-name
  ```

  - 环境变量

  配置环境变量：`TENCENTCLOUD_SECRET_ID`, `TENCENTCLOUD_SECRET_KEY`, `TENCENTCLOUD_ROLE_ARN`, `TENCENTCLOUD_ROLE_SESSION_NAME`

  3. TKE OIDC

  - 环境变量
    配置环境变量：`TKE_REGION`, `TKE_PROVIDER_ID`, `TKE_WEB_IDENTITY_TOKEN_FILE`, `TKE_ROLE_ARN`

  4. 临时密钥

  - 命令行输入
  ```bash
  tccli cvm DescribeRegions --secretId xx --secretKey xx --token xx
  ```


  - 环境变量
    配置环境变量：`TENCENTCLOUD_SECRET_ID`, `TENCENTCLOUD_SECRET_KEY`, `TENCENTCLOUD_TOKEN`


  - xxx.credential文件
  ```json
  {
    "secretId": "AKIDxxxxxxxxxxxxxxxxxxxxQsPk",
    "secretKey": "QgoxxxxxxxxxxxxxxxxgvW4",
    "token": "xxxxxxxxxxxxxxxxxx"
  }
  ```


  5. 永久密钥

  - 命令行输入
  ```bash
  tccli cvm DescribeRegions --secretId xx --secretKey xx
  ```


  - 环境变量
    配置环境变量：`TENCENTCLOUD_SECRET_ID`, `TENCENTCLOUD_SECRET_KEY`


  - xxx.credential文件
  ```json
  {
    "secretId": "AKIDxxxxxxxxxxxxxxxxxxxxQsPk",
    "secretKey": "QgoxxxxxxxxxxxxxxxxgvW4"
  }
  ```


  命令行工具集成了腾讯云所有支持云 API 的产品，可以在命令行下完成对腾讯云产品的配置和管理。包括使用TCCLI创建云服务器，操作云服务器，通过TCCLI创建CBS盘、查看CBS盘使用情况，通过TCCLI创建VPC网络、往VPC网络中添加资源等等，所有在控制台页面能完成的操作，均能再命令行工具上执行命令实现。
  * 通过tccli cvm DescribeInstances命令查看当前账号有哪些云服务器。
  * 通过tccli cbs DescribeDisks命令查看有CBS盘列表。

  以创建一台cvm为例(**请注意demo中非简单类型的参数必须为标准json格式**)：
  ```bash
  tccli cvm RunInstances --InstanceChargeType POSTPAID_BY_HOUR --InstanceChargePrepaid '{"Period":1,"RenewFlag":"DISABLE_NOTIFY_AND_MANUAL_RENEW"}'
   --Placement '{"Zone":"ap-guangzhou-2"}' --InstanceType S1.SMALL1 --ImageId img-8toqc6s3 --SystemDisk '{"DiskType":"CLOUD_BASIC", "DiskSize":50}'
  --InternetAccessible '{"InternetChargeType":"TRAFFIC_POSTPAID_BY_HOUR","InternetMaxBandwidthOut":10,"PublicIpAssigned":true}' --InstanceCount 1
  --InstanceName TCCLI-TEST --LoginSettings '{"Password":"isd@cloud"}' --SecurityGroupIds '["sg-0rszg2vb"]' --HostName TCCLI-HOST-NAME1
  ```
  更多功能，您可以通过tccli help查看支持的产品，通过tccli cvm help（以cvm举例）查看产品支持的接口。通过tccli cbs DescribeDisks help(以cbs产品的DescribeDisks接口为例) 查看接口支持的参数。如果想看详细信息，可以在help的后面增加字段'--detail'查看。例如：分别使用tccli help --detail，tccli cvm help --detail和tccli cbs DescribeDisks help --detail查看对应的详细信息。


  从3.0.1009.1版本开始，命令行执行成功返回0值，执行失败返回非0值。



  某些产品可能存在多个版本的接口，TCCLI默认访问最新版本的接口。如果您想访问特定旧版本的接口，可以通过以下方式实现(以cvm举例)。
  ```bash

  tccli configure set cvm.version 2017-03-12


  tccli cvm help --version 2017-03-12
  tccli cvm DescribeZones help --version 2017-03-12
  tccli cvm DescribeZones --version 2017-03-12
  ```

  指定公共参数`language`可以获得接口指定语言的返回，`language`参数也支持在配置文件中配置，默认值为"zh-CN"
  ```

  tccli cvm DescribeZones --language zh-CN
  tccli cvm DescribeZones --language en-US
  ```

  TCCLI默认会请求就近的接口点访问服务，你也可以针对某一产品指定自己的Endpoint(以cvm为例)。
  ```bash

  tccli configure set cvm.endpoint cvm.ap-guangzhou.tencentcloudapi.com


  tccli cvm DescribeZones --endpoint cvm.ap-guangzhou.tencentcloudapi.com
  ```


  TCCLI 支持 [JMESPath](https://jmespath.org/examples.html) ，以下仅为部分示例，全部过滤能力请参考 JMESPath 官方文档。

  1. 不加任何过滤时的输出(以cvm DescribeZones接口的返回为例)。
  ```bash
  [root@VM_180_248_centos ~]# tccli cvm DescribeZones
  {
      "TotalCount": 4,
      "ZoneSet": [
          {
              "ZoneState": "AVAILABLE",
              "ZoneId": "100001",
              "Zone": "ap-guangzhou-1",
              "ZoneName": "广州一区"
          },
          {
              "ZoneState": "AVAILABLE",
              "ZoneId": "100002",
              "Zone": "ap-guangzhou-2",
              "ZoneName": "广州二区"
          },
          {
              "ZoneState": "AVAILABLE",
              "ZoneId": "100003",
              "Zone": "ap-guangzhou-3",
              "ZoneName": "广州三区"
          },
          {
              "ZoneState": "AVAILABLE",
              "ZoneId": "100004",
              "Zone": "ap-guangzhou-4",
              "ZoneName": "广州四区"
          }
      ],
      "RequestId": "4fd313a6-155f-4c7a-bf86-898c02fcae02"
  }
  ```
  2. 只看某个字段。
  ```bash
  [root@VM_180_248_centos ~]# tccli cvm DescribeZones  --filter TotalCount
  4
  ```
  3. 指定某个数组类型对象的第N个子对象的信息。
  注意：Mac OS 系统使用如下命令可能会报错 `zsh: no matches found: xxx`，这时需要将说明过滤行为的内容用单引号包裹起来
  ```bash
  [root@VM_180_248_centos ~]# tccli cvm DescribeZones  --filter ZoneSet[0]
  {
      "ZoneState": "AVAILABLE",
      "ZoneId": "100001",
      "Zone": "ap-guangzhou-1",
      "ZoneName": "广州一区"
  }
  ```
  4. 指定数组类型对象下所有某个名称的子对象的某个字段。
  ```bash
  [root@VM_180_248_centos ~]# tccli cvm DescribeZones  --filter ZoneSet[*].ZoneName
  [
      "广州一区",
      "广州二区",
      "广州三区",
      "广州四区"
  ]
  ```
  5. 过滤数组里的子对象，同时还以新的名称展示。
  注意：这里需要将说明过滤行为的内容用单引号包裹起来。
  ```bash
  [root@VM_180_248_centos ~]# tccli cvm DescribeZones  --filter 'ZoneSet[*].{name:ZoneName, id:ZoneId}'
  [
      {
          "name": "广州一区",
          "id": "100001"
      },
      {
          "name": "广州二区",
          "id": "100002"
      },
      {
          "name": "广州三区",
          "id": "100003"
      },
      {
          "name": "广州四区",
          "id": "100004"
      }
  ]
  ```
  6. 高级过滤。CVM 的 DescribeInstances 接口，返回结构体中 InstanceSet 是一个数组，里面每个元素都是一个实例的信息。假设我们想要获取中国香港地域每个实例的唯一标识符 InstanceId，实例名称 InstanceName，并且过滤特定标签。标签是一个数组，里面每个元素是一个字典，键值 Key 是标签名，键值 Value 是标签值，我们想要获取标签名是`app`的标签值。最后结果打印文本。注意，过滤的标签值实际为数组，我们只取第一个，确保不会因为是数组而导致换行。此外，复杂的命令行语句编写困难，维护不便，建议使用 SDK 封装为程序调用更为合理。
  ```
  tccli cvm DescribeInstances --region ap-hongkong --filter 'InstanceSet[].[InstanceId,InstanceName,Tags[?Key==`app`].Value|[0]]' --output text
  ins-6xe51ktg    未命名  elastic-search
  ```

  可以使用'--waiter'参数来轮询实例的信息直到出现指定的状态
  ```

  tccli cvm DescribeInstancesStatus --region ap-hongkong --waiter "{'expr':'InstanceStatusSet[0].InstanceState','to':'RUNNING'}"

  tccli cvm DescribeInstancesStatus --region ap-hongkong --waiter "{'expr':'InstanceStatusSet[0].InstanceState','to':'RUNNING','timeout':180,'interval':5}"
  ```
  使用'--waiter'参数时，必须指定一以下两个参数：

  - expr: 指定被查询的字段，使用[jmespath](http://jmespath.org/)来查找被指定的字段的值
  - to: 被轮询的字段的目标值

  可选子参数：

  - timeout: 轮询的超时时间(s)
  - inaterval: 进程睡眠的时间(s)

  您可以在配置文件中设置可选子参数的值，例如
  ```

      "waiter": {
          "interval": 5,
          "timeout": 180
        },
  ```

  ```bash
  [root@VM_180_248_centos ~]# tccli cvm RunInstances  --generate-cli-skeleton > /tmp/RunInstances.json
  ```

  ```bash
  [root@VM_180_248_centos ~]# tccli cvm RunInstances --cli-input-json file:///tmp/RunInstances.json
  {
      "RequestId": "20e2b42d-3260-4750-9293-79116208330e",
      "InstanceIdSet": null
  }
  ```


pkgId: b17bd425540dd90e51e06b7f0ea4f39ca8b6feaf5b3cc6bda47ad86137dddc12
name: python-tcloud-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for tcloud
url: https://pypi.org/project/tcloud/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tcloud-2.0.0-1.src.rpm
location_href: Packages/python-tcloud-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  The configuration for the `tcloud` CLI tool should be stored either in the `$HOME/.tcloud/tcloud.yml` file or in the `tcloud.yml` file located in the project folder.

  Below is an example of `tcloud.yml` configuration:
  ```yaml
  projects:
      <Project name>:
          url: <The project URL>
          token: <The access token>
          gateway: <The name of the SQLMesh gateway to use with this project>
          extras: <Optional - Any extras that should be installed with sqlmesh-enterprise>
          pip_executable: <Optional - The path to the pip executable to use. Ex: `uv pip` or `pip3`. Must install packages to the python environment running the tcloud command>
  default_project: <The name of a project to use by default>
  ```

  Alternatively, the target project can be configured using the `TCLOUD_URL`, `TCLOUD_TOKEN`, `TCLOUD_GATEWAY`, `TCLOUD_EXTRAS`, and `TCLOUD_PIP_EXECUTABLE` environment variables.



  The `tcloud` CLI tool allows you to run SQLMesh executor processes which can perform cadence model evaluations and plan applications outside the Tobiko Cloud environment.

  To launch an executor process responsible for runs: `tcloud executor run`.

  To launch an executor process responsible for plan applications: `tcloud executor plan`.

  Any number of executors, of either type, can be launched as needed. The actual number should be determined by the specific requirements of a given project. For instance, a project with numerous users frequently applying changes concurrently may benefit from a higher number of `plan` executors.

  The gateway / connection configuration can be provided using environment variables as described in the [documentation](https://sqlmesh.readthedocs.io/en/latest/guides/configuration/?h=environment+varia#overrides).


pkgId: 9cc5b3216d0d6486990b2075dab8460e0e98b9d8ba9e7d92681a24d4ee2e60a5
name: python-tconnectsync-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for tconnectsync
url: https://github.com/jwoglom/tconnectsync
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-tconnectsync-2.2.0-1.src.rpm
location_href: Packages/python-tconnectsync-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Python Package workflow](https://github.com/jwoglom/tconnectsync/actions/workflows/python-package.yml/badge.svg)
  [![codecov](https://codecov.io/gh/jwoglom/tconnectsync/branch/master/graph/badge.svg)](https://codecov.io/gh/jwoglom/tconnectsync)

  Tconnectsync synchronizes data one-way from Tandem Source to Nightscout.

  > [!IMPORTANT]
  > Tandem has announced that t:connect will be shut down in favor of Tandem Source in the US beginning September 30, 2024.
  > tconnectsync has undergone major changes to support Tandem Source. **For Tandem Source support, you MUST upgrade to tconnectsync version 2.0 or above.**

  If you have a t:slim X2 pump with the companion t:connect mobile Android or iOS app, this will allow your pump bolus and basal data to be uploaded to [Nightscout](https://github.com/nightscout/cgm-remote-monitor) automatically.
  Together with a CGM uploader, such as [xDrip+](https://github.com/NightscoutFoundation/xDrip) or the official Dexcom mobile app plus Dexcom Share, this allows your CGM _and_ pump data to be automatically uploaded to Nightscout!




  At a high level, tconnectsync works by querying Tandem's undocumented APIs to receive basal and bolus data from Tandem Source, and then uploads that data as treatment objects to Nightscout. It contains features for checking for new Tandem pump data continuously, and updating that data to Nightscout whenever there is new data.

  When you run the program with no arguments, it performs a single cycle of the following, and exits after completion:

  * Logs in to Tandem Source
  * Fetches your list of pumps, and unless overridden by an environment variable, fetches the event data for the pump which was most recently used
  * Processes the internal pump event metadata to extract basal, bolus, CGM, and other pump event data
  * Queries Nightscout to find the most recent data which was uploaded to it for each event category
  * Uploads any missing data to Nightscout

  If run with the `--auto-update` flag, then the application periodically looks for new data and synchronizes it to Nightscout in a loop every few minutes.



  Tconnectsync is composed of individual so-called _synchronization features_, which are elements of data that can be
  synchronized between t:connect data from the pump and Nightscout.
  When setting up tconnectsync, you can choose to configure which synchronization features are enabled and disabled.

  Here are a few examples of reasons why you might want to adjust the enabled synchronization features:

  * If you currently input boluses into Nightscout manually with comments, then you may wish to _disable the `BOLUS` synchronization feature_ so that there are no duplicated boluses in Nightscout.
  * If you want to see Sleep and Exercise Mode data appear in Nightscout, then you may wish to _enable the `PUMP_EVENTS` synchronization feature_.
  * If you want to automatically update your Nightscout insulin profile settings from your pump, then you may wish to _enable the `PROFILES` synchronization feature_.

  These synchronization features are enabled by default:

  * `BASAL`: Basal data
  * `BOLUS`: Bolus data
  * `PUMP_EVENTS`: Events reported by the pump. Includes support for the following:
    * Alarms, like cartridge out-of-insulin or pump malfunction
    * Basal suspension (user or pump-initiated) and resume
    * Cartridge, cannula, and tubing filled
    * Sleep and exercise modes
  * `PROFILES`: Insulin profile information, including segments, basal rates, correction factors, carb ratios, and the profile which is active.

  The following synchronization features can be optionally enabled:
  * `CGM`: Adds Dexcom CGM readings from the pump to Nightscout as SGV (sensor glucose value) entries. This should only be used in a situation where xDrip/Dexcom Share/etc. is not used and the pump connection to the CGM will be the only source of CGM data to Nightscout. **THIS WILL DELIVER CGM DATA WITH A SIGNIFICANT (>30 MINUTE) LAG AND SHOULD NOT BE USED AS A REPLACEMENT FOR DEXCOM SHARE OR OTHER REAL TIME MONITORING.**


  To specify custom synchronization features, pass the names of the desired features to the `--features` flag, e.g.:

  ```bash
  $ tconnectsync --features BASAL BOLUS PUMP_EVENTS PROFILES
  ```

  If you're using tconnectsync-heroku, see [this section in its README](https://github.com/jwoglom/tconnectsync-heroku#Updating-synchronization-features).



  The following setup instructions assume that you have a Linux, MacOS, or Windows (with WSL) machine that will run the application continuously.

  If you've configured Nightscout before, you may be familiar with Heroku. [You can opt to run tconnectsync with Heroku by following these instructions.](https://github.com/jwoglom/tconnectsync-heroku)

  **To get started,** you need to choose whether to install the application on your computer via
  **Pip**, **Pipenv**, or **Docker**.

  After that, you can choose to run the program continuously via **Supervisord**
  or on a regular interval with **Cron**.

  **NOTE:** If you fork the tconnectsync repository on GitHub, **do not commit your .env file**.
  If pushed to GitHub, this will make your tconnect and Nightscout passwords publicly visible and put your data at risk.



  First, you need to create a file containing configuration values.
  The name of this file will be `.env`, and its location will be dependent on which
  method of installation you choose.
  You should specify the following parameters:

  ```bash

  TCONNECT_EMAIL='email@email.com'
  TCONNECT_PASSWORD='password'


  NS_URL='https://yournightscouturl/'

  NS_SECRET='apisecret'


  TIMEZONE_NAME='America/New_York'


  PUMP_SERIAL_NUMBER=11111111
  ```

  This file contains your t:connect username and password, Tandem pump serial number (which is utilized in API calls to t:connect), your Nightscout URL and secret token (for uploading data to Nightscout), and local timezone (the timezone used in t:connect). When specifying the timezone, enter a [TZ database name value](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

  (Alternatively, these values can be specified via environment variables.)



  This is the easiest method to install.

  First, ensure that you have **Python 3** with **Pip** installed:

  * **On MacOS:** Open Terminal. Install [Homebrew](https://brew.sh/), and then run `brew install python3`
  * **On Linux:** Follow your distribution's specific instructions.
    - For Debian/Ubuntu based distros, `sudo apt install python3 python3-pip`
    - For CentOS/Rocky Linux 8:
      - `sudo dnf install python39-pip`
      - `sudo alternatives --set python /usr/bin/python3.9`
  * **On Windows:**
    - **With WSL:** Install Ubuntu under the [Windows Subsystem for Linux](https://ubuntu.com/wsl).
      Open the Ubuntu Terminal, then run `sudo apt install python3 python3-pip`.
      Perform the remainder of the steps under the Ubuntu environment.
    - **Native:** Alternatively, you can run tconnectsync in native Windows with no modifications. However, this is less well-tested (open a GitHub issue if you experience any problems).

  Now install the `tconnectsync` package with pip:

  ```
  $ pip3 install tconnectsync
  ```
  To install into a user environment instead of system-wide for a more contained install:
  ````
  $ pip3 install --user tconnectsync
  ````
    - This will place the tconnectsync binary file at ``/home/<username>/.local/bin/tconnectsync``
    - For non-WSL Windows, it will be in ``<PYTHON DIRECTORY>\Lib\site-packages\tconnectsync``

  If the pip3 command is not found, run `python3 -m pip install tconnectsync` instead.

  After this, you should be able to view tconnectsync's help with:
  ```
  $ tconnectsync --help
  usage: tconnectsync [-h] [--version] [--pretend] [-v] [--start-date START_DATE] [--end-date END_DATE] [--days DAYS] [--auto-update] [--check-login]
                 [--features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]]

  Syncs bolus, basal, and IOB data from Tandem Diabetes t:connect to Nightscout.

  optional arguments:
    -h, --help            show this help message and exit
    --version             show program's version number and exit
    --pretend             Pretend mode: do not upload any data to Nightscout.
    -v, --verbose         Verbose mode: show extra logging details
    --start-date START_DATE
                          The oldest date to process data from. Must be specified with --end-date.
    --end-date END_DATE   The newest date to process data until (inclusive). Must be specified with --start-date.
    --days DAYS           The number of days of t:connect data to read in. Cannot be used with --from-date and --until-date.
    --auto-update         If set, continuously checks for updates from t:connect and syncs with Nightscout.
    --check-login         If set, checks that the provided t:connect credentials can be used to log in.
    --features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]
                          Specifies what data should be synchronized between tconnect and Nightscout.
  ```

  Move the `.env` file you created to the following folder:

  * **MacOS:** `/Users/<username>/.config/tconnectsync/.env`
  * **Linux:** `$HOME/.config/tconnectsync/.env`
  * **Windows:** `$HOME/.config/tconnectsync/.env` (inside WSL) OR `C:\Users\<username>\.config\tconnectsync` (native Windows)

  ```
  $ tconnectsync --check-login
  ```

  If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.



  You can run the application using Pipenv.

  First, ensure you have Python 3 and pip installed, then install pipenv with `pip3 install pipenv`.

  Clone the Git repository for tconnectsync and cd into it with:
  ```
  $ git clone https://github.com/jwoglom/tconnectsync
  $ cd tconnectsync
  ```

  Then install tconnectsync's dependencies with `pipenv install`.
  Afterwards, you can launch the program with `pipenv run tconnectsync` so long as
  you are inside the checked-out tconnectsync folder.

  ```bash
  $ git clone https://github.com/jwoglom/tconnectsync && cd tconnectsync
  $ pip3 install pipenv
  $ pipenv install
  $ pipenv run tconnectsync --help
  usage: main.py [-h] [--version] [--pretend] [-v] [--start-date START_DATE] [--end-date END_DATE] [--days DAYS] [--auto-update] [--check-login]
                 [--features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]]

  Syncs bolus, basal, and IOB data from Tandem Diabetes t:connect to Nightscout.

  optional arguments:
    -h, --help            show this help message and exit
    --version             show program's version number and exit
    --pretend             Pretend mode: do not upload any data to Nightscout.
    -v, --verbose         Verbose mode: show extra logging details
    --start-date START_DATE
                          The oldest date to process data from. Must be specified with --end-date.
    --end-date END_DATE   The newest date to process data until (inclusive). Must be specified with --start-date.
    --days DAYS           The number of days of t:connect data to read in. Cannot be used with --from-date and --until-date.
    --auto-update         If set, continuously checks for updates from t:connect and syncs with Nightscout.
    --check-login         If set, checks that the provided t:connect credentials can be used to log in.
    --features {BASAL,BOLUS,IOB,PUMP_EVENTS} [{BASAL,BOLUS,IOB,PUMP_EVENTS} ...]
                          Specifies what data should be synchronized between tconnect and Nightscout.
  ```


  Move the `.env` file you created earlier into the `tconnectsync` folder, and run:

  ```
  $ pipenv run tconnectsync --check-login
  ```

  If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.



  First, [ensure that you have Docker running and installed](https://docs.docker.com/get-started/#download-and-install-docker).

  To download and run the prebuilt Docker image from GitHub Packages:

  ```bash
  $ docker pull ghcr.io/jwoglom/tconnectsync/tconnectsync:latest
  $ docker run ghcr.io/jwoglom/tconnectsync/tconnectsync --help
  ```

  Move the `.env` file you created earlier into the current folder, and run:

  ```
  $ docker run tconnectsync --check-login
  ```

  If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.




  To instead build the image locally and launch the project:

  ```bash
  $ git clone https://github.com/jwoglom/tconnectsync
  $ cd tconnectsync
  $ docker build -t tconnectsync .
  $ docker run tconnectsync --help
  ```

  Move the `.env` file you created earlier into this folder, and run:
  ```
  $ docker run --env-file=.env tconnectsync --check-login
  ```

  **NOTE:** If using the `--env-file` option to `docker run`, you may need to remove all quotation marks (`'` and `"`s) around values in the `.env` file for Docker to propagate the variables correctly.

  If you receive no errors, then you can move on to the **Running Tconnectsync Continuously** section.



  You most likely want tconnectsync to run either continuously (via the auto-update
  feature) or on a regular interval (via cron).

  The supervisord approach is recommended for simplicity.


  To configure tconnectsync to run continuously in the background using its `--auto-update` feature, you can use a tool such as Supervisord.

  First, install supervisord via your Linux system's package manager.
  (For example, for Ubuntu/Debian-based systems, run `sudo apt install supervisor`)

  Supervisord is configured by creating a configuration file in `/etc/supervisor/conf.d`.

  Here is an example `tconnectsync.conf` which you can place in that folder:

  ```
  [program:tconnectsync]
  command=/path/to/tconnectsync/run.sh
  directory=/path/to/tconnectsync/
  stderr_logfile=/path/to/tconnectsync/stderr.log
  stdout_logfile=/path/to/tconnectsync/stdout.log
  user=<your username>
  numprocs=1
  autostart=true
  autorestart=true
  ```

  In order to create a `run.sh` file, see the section below which aligns with your
  choice of installation method.

  After the configuration file has been created, ensure that Supervisor is running
  and configured to start on boot:

  ```bash
  $ sudo systemctl daemon-reload
  $ sudo systemctl start supervisord
  $ sudo systemctl enable supervisord
  ```

  Then use the `supervisorctl` command to manage the status of the tconnectsync program:

  ```bash
  $ sudo supervisorctl status
  tconnectsync                     STOPPED
  $ sudo supervisorctl start tconnectsync
  $ sudo supervisorctl status
  tconnectsync                     RUNNING   pid 18810, uptime 00:00:05
  ```

  You can look at the `stderr.log` and `stdout.log` files to check that tconnectsync
  is running and has started up properly:
  ```bash
  $ tail -f /path/to/tconnectsync/stdout.log
  Starting auto-update between 2021-09-30 00:06:39.942273 and 2021-10-01 00:06:39.942273
  2021-10-01 00:06:39 DEBUG    Instantiating new AndroidApi
  2021-10-01 00:06:39 DEBUG    Starting new HTTPS connection (1): tdcservices.tandemdiabetes.com:443
  2021-10-01 00:06:40 DEBUG    https://tdcservices.tandemdiabetes.com:443 "POST /cloud/oauth2/token HTTP/1.1" 200 404
  2021-10-01 00:06:40 INFO     Logged in to AndroidApi successfully (expiration: 2021-10-01T08:06:40.362Z, in 7 hours, 59 minutes)
  ```



  In the `tconnectsync.conf`, you should set `/path/to/tconnectsync` to the folder
  containing your `.env` file.

  Create a `run.sh` file containing:

  ```bash


  tconnectsync --auto-update
  ```



  In the `tconnectsync.conf`, you should set `/path/to/tconnectsync` to the folder
  where you checked-out the GitHub repository.

  An example `run.sh` which launches tconnectsync within its pipenv-configured virtual environment:

  ```bash


  PIPENV=/home/$(whoami)/.local/bin/pipenv
  VENV=$($PIPENV --venv)

  source $VENV/bin/activate

  cd /path/to/tconnectsync
  exec python3 -u main.py --auto-update
  ```



  In the `tconnectsync.conf`, you should set `/path/to/tconnectsync` to the folder
  where you checked-out the GitHub repository.

  An example `run.sh` if you installed tconnectsync via the GitHub Docker Registry:

  ```bash


  docker run ghcr.io/jwoglom/tconnectsync/tconnectsync --auto-update
  ```

  An example `run.sh` if you built tconnectsync locally:

  ```bash


  docker run tconnectsync --auto-update
  ```



  If you choose not to run tconnectsync with `--auto-update` continuously,
  you can instead run it at a periodic interval (i.e. every 15 minutes) by just
  invoking tconnectsync with no arguments via cron.

  If using Pipenv or a virtualenv, make sure that you either prefix the call to main.py with `pipenv run` or source the `bin/activate` file within the virtualenv, so that the proper dependencies are loaded. If not using any kind of virtualenv, you can instead just install the necessary dependencies as specified inside Pipfile globally.

  An system-wide example configuration in `/etc/crontab` which runs every 15 minutes, on the 15 minute mark:

  ```bash

  0,15,30,45  *  *   *   *   root   /path/to/tconnectsync/run.sh
  ```

  An example of a user crontab `crontab -e` if not running system-wide, which runs every 15 minutes:
  ```
  */15 * * * * /path/to/tconnectsync/run.sh
  ```

  You can use one of the same `run.sh` files referenced above, but remove the `--auto-update` flag since you are handling the functionality for running the script periodically yourself.



  Create a batch file 'tconnectsync.bat' file containing:

  ```
  python "C:\Users\<USERNAME>\AppData\Local\Programs\Python\<PYTHONVERSIONDIRECTORY>\Lib\site-packages\tconnectsync\main.py" --auto-update
  ```

  If `python` does not exist in your path, specify the full path to `python.exe`.

  If main.py doesn't exist in `C:\Users\<USERNAME>\AppData\Local\Programs\Python\<PYTHONVERSIONDIRECTORY>\Lib\site-packages\tconnectsync\`, create it to match the copy in this repository.

  [Use Windows Task Scheduler](https://www.windowscentral.com/how-create-automated-task-using-task-scheduler-windows-10) to run this batch file on a scheduled basis.



  This application utilizes three separate Tandem APIs for obtaining t:connect data, referenced here by the identifying part of their URLs:

  * [**controliq**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/controliq.py) - Contains Control:IQ related data, namely a timeline of all Basal events uploaded by the pump, separated by type (temp basals, algorithmically-updated basals, or profile-updated basals). Additionally includes CGM and Bolus data.
  * [**android**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/android.py) - Used internally by the t:connect Android app, these API endpoints were discovered by reverse-engineering the Android app. Most of the API endpoints are used for uploading pump data, and tconnectsync uses one endpoint which returns the most recent event ID uploaded by the pump, so we know when more data has been uploaded.
  * [**tconnectws2**](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/api/ws2.py) - More legacy than the others, this seems to power the bulk of the main t:connect website. It is used as a last resort due to severe performance issues with this API (see https://github.com/jwoglom/tconnectsync/issues/43). We can use it to retrieve a CSV export of non-ControlIQ basal data, as well as bolus and IOB data. It is only used for bolus data as a fallback, and for pump-reported IOB data if requested. Full tracking of pump events also uses a limited version of this API.

  I have only tested tconnectsync with a Tandem pump set in the US Eastern timezone. Tandem's (to us, undocumented) APIs are [a bit loose with timezones](https://github.com/jwoglom/tconnectsync/blob/master/tconnectsync/parser.py#L15), so please let me know if you notice any timezone-related bugs.


  To backfill existing t:connect data in to Nightscout, you can use the `--start-date` and `--end-date` options. For example, the following will upload all t:connect data between January 1st and March 1st, 2020 to Nightscout:

  ```
  python3 main.py --start-date 2020-01-01 --end-date 2020-03-01
  ```

  In order to bulk-import a lot of data, you may need to use shorter intervals, and invoke tconnectsync multiple times. Tandem's API endpoints occasionally return invalid data if you request too large of a data window which causes tconnectsync to error out mid-way through.

  One oddity when backfilling data is that the Control:IQ specific API endpoints return errors if they are queried before you updated your pump to utilize Control:IQ. This is [partially worked around in tconnectsync's code](https://github.com/jwoglom/tconnectsync/blob/d841c3811aeff3671d941a7d3ff4b80cce6a219e/main.py#L238), but you might need to update the logic if you did not switch to a Control:IQ enabled pump immediately after launch.



  To test t:connect API endpoints in a Python shell, you can do something like the following:

  ```python
  import tconnectsync
  tconnectsync.util.cli.enable_logging()
  api = tconnectsync.util.cli.get_api()

  therapy_timeline = api.controliq.therapy_timeline('2022-08-01', '2022-08-10')
  ```


