# packages

pkgId: 66dc7166a2eb0ff74071e1c1af73bb190c9c6d6cfd3fb590b25da2a65d6a1430
name: python-python-testtttt-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for python-testtttt
url: https://pypi.org/project/python-testtttt/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-testtttt-0.1.0-1.src.rpm
location_href: Packages/python-python-testtttt-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Use the `client.livestreams.create()` method to start a live stream with specific configurations. For detailed configuration options, refer to the [Create a new stream](https://docs.fastpix.io/reference/create-new-stream) API documentation.
  ```python
  liveStreamRequest = {
    "playbackSettings": {
      "accessPolicy": "public", # Defines the access level of the live stream (public or private)
    },
    "inputMediaSettings": {
      "maxResolution": "1080p", # Set the maximum resolution of the live stream
      "reconnectWindow": 1800, # Set the duration for reconnecting the stream in seconds
      "mediaPolicy": "private", # Define media policy (private or public)
      "metadata": {
        "liveStream": "fp_livestream", # Custom metadata for the live stream
      },
      "enableDvrMode": True, # Enable DVR mode to allow viewers to rewind the live stream
    },
  }

  generateLiveStream = client.livestreams.create(liveStreamRequest)
  print("Live Stream initiated successfully:", generateLiveStream)
  ```


  Use the `client.livestreams.list()` method to fetch a list of all live streams. You can customize the query by modifying parameters such as `limit`, `offset`, and `orderBy`. For detailed configuration options, refer to the [Get all live streams](https://docs.fastpix.io/reference/get-all-streams) API documentation.
  ```python
  getAllLiveStreamPagination = {
    "limit": 10, # Limit the number of live streams retrieved.
    "offset": 1, # Skip a specified number of streams for pagination.
    "orderBy": "asc", # Order the results based on the specified criteria ("asc" or "desc").
  }
  const getAllLiveStreams = client.livestreams.list(getAllLiveStreamPagination)
  print("All Live Streams:", getAllLiveStreams)
  ```

  Use the `client.livestreams.get()` method to retrieve a specific live stream by its ID. Provide the `streamId` of the stream you wish to fetch. For more details, refer to the [Get stream by ID](https://docs.fastpix.io/reference/get-live-stream-by-id) API documentation.
  ```python
  streamId =  "a09f3e958c16ed00e85bfe798abd9845" # Replace with actual stream ID
  getLiveStreamById = client.livestreams.get(streamId)
  print("Live Stream Details:", getLiveStreamById)
  ```

  Use the `client.livestreams.update()` method to update a live stream's configuration. Provide the `streamId` of the stream and specify the fields you want to update. For more details, refer to the [Update a stream](https://docs.fastpix.io/reference/update-live-stream) API documentation.
  ```python
  streamId = "a09f3e958c16ed00e85bfe798abd9845" # Provide the stream ID for the live stream to update
  updateLiveStreamRequest = {
    "metadata": {
      "livestream_name": "Game_streaming",
    },
    "reconnectWindow": 100,
  }
  updateLiveStream = client.livestreams.update(streamId,updateLiveStreamRequest)
  print("Updated Live Stream:", updateLiveStream)
  ```

  Use the `client.livestreams.delete()` method to delete a live stream by its ID. Provide `streamId` of the stream you want to delete. For more details, refer to the [Delete a stream](https://docs.fastpix.io/reference/delete-live-stream) API documentation.
  ```python
  deleteLiveStream = client.livestreams.delete("a09f3e958c16ed00e85bfe798abd9845")  # Provide the stream ID of the live stream to delete
  print("Deleted Live Stream:", deleteLiveStream)
  ```


  Use the `client.livestream_playback_ids.create()` method to generate a playback ID for a live stream. Replace `streamId` with the actual ID of the live stream and specify the desired `accessPolicy`. For more details, refer to the [Create a playback ID](https://docs.fastpix.io/reference/create-playbackid-of-stream) API documentation.
  ```python
  streamId = "a09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream ID
  body = { "accessPolicy": "public" }
  generateLiveStreamPlaybackId = client.livestream_playback_ids.create(streamId, body)
  print("Generated Live Stream Playback ID:", generateLiveStreamPlaybackId)
  ```

  Use the `client.livestream_playback_ids.delete()` method to delete a specific playback ID for a live stream. You need to provide both the `streamId` of the live stream and the `playbackId` to delete. For more details, refer to the [Delete a playback ID](https://docs.fastpix.io/reference/delete-playbackid-of-stream) API documentation.
  ```python
  streamId = "a09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream ID
  playbackId = "632029b4-7c53-4dcf-a4d3-1884c29e90f8"  # Replace with actual playback ID
  deleteLiveStreamPlaybackId = client.livestream_playback_ids.delete(streamId, playbackId)
  print("Deleted Live Stream Playback ID:", deleteLiveStreamPlaybackId)
  ```

  Use the `client.livestream_playback_ids.get()` method to retrieve the playback policy for a specific live stream playback ID. Replace `streamId` with the stream's ID and `playbackId` with the actual playback ID to fetch the policy. For more details, refer to the [Get stream's playback ID](https://docs.fastpix.io/reference/get-live-stream-playback-id) API documentation.
  ```python
  streamId = "1c5e8abcc2080cba74f5d0ac91c7833e"  # Replace with the actual stream ID
  playbackId = "95ce872d-0b58-44f3-be72-8ed8b97ee2c9"  # Replace with the actual playback ID
  getLiveStreamPlaybackPolicy = client.livestream_playback_ids.get(streamId, playbackId)
  print("Live Stream Playback Policy:", getLiveStreamPlaybackPolicy)
  ```


  Use the `client.livestreams.create_simulcast()` method to create a new simulcast for a live stream. Provide the stream ID and simulcast payload with the URL and stream key. For more details, refer to the [Create a simulcast](https://docs.fastpix.io/reference/create-simulcast-of-stream) API documentation.
  ```python
  simulcastPayload = {
      "url": "rtmps://live.fastpix.io:443/live",
      "streamKey": "46c3457fa8a579b2d4da64125a2b6e83ka09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream key
  }
  streamId = "a09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream ID
  generateSimulcast = client.livestreams.create_simulcast(streamId, simulcastPayload)
  print("Generate Simulcast:", generateSimulcast)
  ```

  Use the `client.livestreams.get_simulcast()` method to retrieve details of a specific simulcast stream. Provide the `streamId` and `simulcastId` of the simulcast you want to fetch. For more details, refer to the [Get a specific simulcast of a stream](https://docs.fastpix.io/reference/get-specific-simulcast-of-stream) API documentation.
  ```python
  streamId = "a09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream ID
  simulcastId = "7269209ff0299319b6321c9a6e7850ff"  # Replace with actual simulcast ID
  getLiveSimulcast = client.livestreams.get_simulcast(streamId, simulcastId)
  print("Live Stream Simulcast Details:", getLiveSimulcast)
  ```

  Use the `client.livestreams.update_simulcast()` method to update the configuration of a simulcast stream. Provide the `streamId`, `simulcastId`, and the fields you want to update. For more details, refer to the [Update a specific simulcast of a stream](https://docs.fastpix.io/reference/update-specific-simulcast-of-stream) API documentation.
  ```python
  streamId = "a09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream ID
  simulcastId = "7269209ff0299319b6321c9a6e7850ff"  # Replace with actual simulcast ID
  updatePayload = {
      "isEnabled": False,  # Disable the simulcast stream (set to True to enable)
      "metadata": {
          "simulcast2": "media"  # Update the metadata as needed
      }
  }
  updateLiveSimulcast = client.livestreams.update_simulcast(streamId, simulcastId, updatePayload)
  print("Updated Live Stream Simulcast:", updateLiveSimulcast)
  ```

  Use the `client.livestreams.delete_simulcast()` method to remove a specific simulcast from a live stream. Provide the `streamId` and `simulcastId` for the simulcast you want to delete. For more details, refer to the [Delete a simulcast](https://docs.fastpix.io/reference/delete-simulcast-of-stream) API documentation.
  ```python
  streamId = "a09f3e958c16ed00e85bfe798abd9845"  # Replace with actual stream ID
  simulcastId = "7269209ff0299319b6321c9a6e7850ff"  # Replace with actual simulcast ID
  deleteLiveSimulcast = client.livestreams.delete_simulcast(streamId, simulcastId)
  print("Deleted Live Stream Simulcast:", deleteLiveSimulcast)
  ```

  For a complete understanding of each API's functionality, including request and response details, parameter descriptions, and additional examples, please refer to the [FastPix API Reference](https://docs.fastpix.io/reference/signingkeys-overview).
  The API reference provides comprehensive documentation for all available endpoints and features, ensuring developers can integrate and utilize FastPix APIs efficiently.


pkgId: 941c839b1511d7808d426a840ea2fb66156dafdefa6dc01bb9d43b3dc1a451c1
name: python-python-toolbox
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: A collection of Python tools for various tasks
url: https://pypi.org/project/python-toolbox/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-toolbox-1.2.0-1.src.rpm
location_href: Packages/python-python-toolbox-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Test can be run by running the ``_test_python_toolbox.py`` script that's
  installed automatically with the Python Toolbox.
  When ``python_toolbox`` isn't installed, you may run ``pytest`` at the repo


pkgId: fc4be61f3fa2d7f17d5615c5db442e1336c576e087671d9a3ac6f22546fd5773
name: python-python-toolkit-vald3nir-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for python-toolkit-vald3nir
url: https://github.com/vald3nir/Python-Toolkit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-toolkit-vald3nir-1.1.0-1.src.rpm
location_href: Packages/python-python-toolkit-vald3nir-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Collection of utility scripts for developing Python projects



      src
      ├── __init__.py
      └── toolkit
          ├── database
          │   ├── firebase
          │   │   ├── firebase.py
          │   │   └── __init__.py
          │   ├── __init__.py
          │   ├── json
          │   │   ├── collectionDB.py
          │   │   └── __init__.py
          │   └── mongodb
          │       ├── __init__.py
          │       ├── mongo_api.py
          │       └── mongo_dao.py
          ├── __init__.py
          ├── protocols
          │   ├── __init__.py
          │   └── mqtt.py
          └── utils
              ├── backup_utils.py
              ├── converter_utils.py
              ├── dataset_utils.py
              ├── date_utils.py
              ├── __init__.py
              ├── io_utils.py
              └── string_utils.py




  https://pypi.org/project/python-toolkit-vald3nir/


pkgId: 6ac415087bddb5e1fc05122e5635fbba1cc1a266a29c36774393f568823e3a1e
name: python-python-utility-scripts-help
arch: noarch
version: 1.0.4
epoch: 0
release: 1
summary: Development documents and examples for python-utility-scripts
url: https://github.com/RedHatQE/python-utility-scripts
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-utility-scripts-1.0.4-1.src.rpm
location_href: Packages/python-python-utility-scripts-help-1.0.4-1.noarch.rpm
checksum_type: sha256
description:
  Repository for various python utility scripts
  * [pyutils-unusedcode](https://github.com/RedHatQE/python-utility-scripts/blob/main/apps/unused_code/README.md)
  * [pyutils-polarion-verify-tc-requirements](https://github.com/RedHatQE/python-utility-scripts/blob/main/apps/polarion/README.md)



  ```bash
  pip3 install python-utility-scripts --user
  ```


  * Clone the [repository](https://github.com/RedHatQE/python-utility-scripts.git)

  ```bash
  git clone https://github.com/RedHatQE/python-utility-scripts.git
  ```

  * Install [poetry](https://github.com/python-poetry/poetry)

  ```bash
  poetry install
  ```


  A config yaml file for various utilities of this repository should be added to
  `~/.config/python-utility-scripts/config.yaml`. Script specific config section details can be found in associated script README.md




  * Export GitHub token

  ```bash
  export GITHUB_TOKEN=<your_github_token>
  ```

  * [release-it](https://github.com/release-it/release-it)

  * Run the following once (execute outside repository dir for example `~/`):

  ```bash
  sudo npm install --global release-it
  npm install --save-dev @j-ulrich/release-it-regex-bumper
  rm -f package.json package-lock.json
  ```


  * Create a release, run from the relevant branch.
  To create a new release, run:

  ```bash
  git checkout main
  git pull
  release-it # Follow the instructions
  ```


pkgId: 0f0b2211fa5a4bca9fa00d86bc143f3d1d142ad8135a12b691a61dba0aa191f4
name: python-python-web3-wallet-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for python-web3-wallet
url: https://pypi.org/project/python-web3-wallet/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-web3-wallet-0.0.3-1.src.rpm
location_href: Packages/python-python-web3-wallet-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Streamlit component that allows you to connect a wallet and trigger send transactions.



  ```sh
  pip install web3-wallet-connect
  ```



  ```python
  import streamlit as st

  from python_web3_wallet import my_component

  c = my_component(recipient="0x...", amount_in_ether="0.01") # Displays RainbowKit wallet


  ```


pkgId: 91be415e448929a8fbb70b9c97378c129168eb2e922a1eeccb35917fecd2e0d1
name: python-python-window-recorder-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for python-window-recorder
url: https://github.com/xjxckk/window-recorder/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-window-recorder-1.0-1.src.rpm
location_href: Packages/python-python-window-recorder-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  Background window recorder

  Installation:
  `pip install python-window-recorder`

  ```
  from window-recorder import Recorder
  from time import sleep

  recorder = Recorder('New Tab - Google Chrome')
  print('Starting recording')
  recorder.start(folder='recordings', filename='test')
  sleep(3)
  print('Stopping recording')
  recorder.stop()
  > Video saved as test_2024-06-29 19-08-11.mp4
  ```


pkgId: 1184cb67d43f067cbd00c14bd7ef9ee1333e592afabef0ceddb2bd92efc91081
name: python-python-yakh-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for python-yakh
url: https://github.com/petereon/yakh
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python-yakh-0.4.0-1.src.rpm
location_href: Packages/python-python-yakh-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  yakh (Yet Another Keypress Handler) tries to handle keypresses from the stdin in the terminal in high-level platform indepdendent manner.



  Yakh can be installed from [PyPI](https://pypi.org/project/python-yakh/) using,
  ```sh
  pip install python-yakh
  ```

  or GitHub itself using poetry,
  ```sh
  poetry add git+https://github.com/petereon/yakh.git
  ```



  ```python
  from yakh import get_key
  from yakh.key import Keys

  key = ''
  while key not in ['q', Keys.ENTER]:
      key = get_key()
      if key.is_printable:
          print(key)
  ```

  yakh is dead-simple, there is only one function `get_key()` which takes no arguments and blocks until a key is pressed.

  For each keypress it creates an instance of [`Key`](./yakh/key/_key.py#L7) which holds:

  - `.key`: characters representing the keypress
  - `.key_codes`: collection of Unicode code point encodings for all the characters (given by `ord` function)
  - `.is_printable`: printability of the characters in the keypress

  Additionally `Key` instances

  -  are comparable with another `Key` instances, `str` instances and *Unicode code point* representations (tuples of integers)
  - come with string representation for purposes of printing and string concatenation, which returns the content of `.key` attribute


  `yakh.key` sub-module contains platform dependent representations of certain keys under `Keys` class. These are available namely for `CTRL` key combinations and some other common keys.

  Full list of keys can be seen [here](./yakh/key/_key.py#L42) and [here](./yakh/key/_key.py#L81).


pkgId: b52a130d43fb443ce689090bea5e300f112775c11477cb21cf190338f0bfd4fb
name: python-python3-capsolver-help
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: Development documents and examples for python3-capsolver
url: https://andreidrang.github.io/python3-capsolver/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python3-capsolver-0.9.4-1.src.rpm
location_href: Packages/python-python3-capsolver-help-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  ![Logo](https://red-panda-dev.xyz/media/images/Capsolver_ugBYrN0.original.png)

  <hr>

  [![PyPI version](https://badge.fury.io/py/python3-capsolver.svg)](https://badge.fury.io/py/python3-capsolver)
  [![Python versions](https://img.shields.io/pypi/pyversions/python3-capsolver.svg?logo=python&logoColor=FBE072)](https://badge.fury.io/py/python3-capsolver)
  [![Downloads](https://static.pepy.tech/badge/python3-capsolver/month)](https://pepy.tech/project/python3-capsolver)

  [![Maintainability](https://api.codeclimate.com/v1/badges/3c30167b5fb37a0775ea/maintainability)](https://codeclimate.com/github/AndreiDrang/python3-capsolver/maintainability)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/323d4eda0fe1477bbea8fe8902b9e97e)](https://www.codacy.com/gh/AndreiDrang/python3-capsolver/dashboard?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=AndreiDrang/python3-capsolver&amp;utm_campaign=Badge_Grade)
  [![codecov](https://codecov.io/gh/AndreiDrang/python3-capsolver/branch/main/graph/badge.svg?token=2L4VVIF4G8)](https://codecov.io/gh/AndreiDrang/python3-capsolver)

  [![Sphinx build](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/sphinx.yml/badge.svg?branch=release)](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/sphinx.yml)
  [![Build](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/build.yml)
  [![Installation](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/install.yml/badge.svg?branch=main)](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/install.yml)
  [![Tests](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/test.yml)
  [![Lint](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/lint.yml/badge.svg?branch=main)](https://github.com/AndreiDrang/python3-capsolver/actions/workflows/lint.yml)


  Python 3 library for [Capsolver](https://dashboard.capsolver.com/passport/register?inviteCode=kQTn-tG07Jb1) service API.

  Tested on UNIX based OS.

  The library is intended for software developers and is used to work with the [Capsolver](https://dashboard.capsolver.com/passport/register?inviteCode=kQTn-tG07Jb1) service API.

  ***

  If you have any questions, please send a message to the [Telegram](https://t.me/pythoncaptcha) chat room.

  Or email python-captcha@pm.me



  We recommend using the latest version of Python. `python3-capsolver` supports Python 3.7+.



  ```bash
  pip install python3-capsolver
  ```



  Is described in the [documentation-website](https://andreidrang.github.io/python3-capsolver/).




  1. You need set ``API_KEY`` in your environment(get this value from you account).
  2. Run command ``make tests``, from root directory.




  Check [releases page](https://github.com/AndreiDrang/python3-capsolver/releases).


  1. On the page - https://dashboard.capsolver.com/overview/user-center
  2. Find it: ![img.png](files/img.png)


pkgId: 5933061db74f79ae2347d03c7b6af73df5c6260c9dacd03dd9549680b128e057
name: python-python3-cyberfusion-queue-support-help
arch: noarch
version: 1.4
epoch: 0
release: 1
summary: Development documents and examples for python3-cyberfusion-queue-support
url: https://pypi.org/project/python3-cyberfusion-queue-support/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python3-cyberfusion-queue-support-1.4-1.src.rpm
location_href: Packages/python-python3-cyberfusion-queue-support-help-1.4-1.noarch.rpm
checksum_type: sha256
description:
  Library to queue actions.

  `QueueSupport` allows you to _queue_ certain actions, such as restarting a service, unlinking a file, and much more.

  For example, suppose the file `/tmp/example.txt` should be chmodded to 0600. You can queue the chmod:

  ```
  >>> from cyberfusion.QueueSupport import Queue
  >>> from cyberfusion.QueueSupport.items.chmod import ChmodItem
  >>> queue = Queue()
  >>> queue.add(ChmodItem(path="/tmp/example.txt", mode=0o600))
  ```

  ... see what the chmod _would_ do with 'preview mode':

  ```
  >>> queue.process(preview=False)
  [<cyberfusion.QueueSupport.outcomes.ChmodItemModeChangeOutcome object at 0x7f947e8ef510>]
  >>> print(queue.process(preview=True)[0])
  Change mode of /tmp/example.txt from 0o644 to 0o600
  ```

  ... then actually run the chmod:

  ```
  >>> print(queue.process(preview=False)[0])
  Change mode of /tmp/example2.txt from 0o644 to 0o600
  ```





  Run the following command to install the package from PyPI:

      pip3 install python3-cyberfusion-queue-support



  Run the following commands to build a Debian package:

      mk-build-deps -i -t 'apt -o Debug::pkgProblemResolver=yes --no-install-recommends -y'
      dpkg-buildpackage -us -uc



  No configuration is supported.





  All project-specific terms are in _italic_.

  After creating a _queue_, _items_ can be added to it.

  ```python
  from cyberfusion.QueueSupport import Queue

  queue = Queue()

  item = ...

  queue.add(item)
  ```

  _Items_ are of a certain type. Such as `ChmodItem` or `SystemdUnitRestartItem`. Items can have attributes, such as a path for an `MkdirItem`, or a unit name for `SystemdUnitEnableItem`.

  ```python
  from cyberfusion.QueueSupport.items.chmod import ChmodItem
  from cyberfusion.QueueSupport.items.systemd_unit_enable import SystemdUnitEnableItem

  item1 = ChmodItem(path="/tmp/example.txt", mode=0o600)
  item2 = SystemdUnitEnableItem(name="httpd.service")
  ```

  Each _item_ type has one or multiple _outcomes_. These should come true for an _item_ of that type to be completed. **For example: for an _item_ of type `UnlinkItem`, the _outcome_ is that the file at the path given with the _item_ is unlinked.**

  When a _queue_ is _processed_, all the _items_ added to it are _fulfilled_, meaning all the _items'_ _outcomes_ come true.

  ```python
  from cyberfusion.QueueSupport import Queue

  from cyberfusion.QueueSupport.items.rmtree import RmTreeItem

  item = RmTreeItem(path="/tmp/dir")

  queue = Queue()

  queue.add(item)



  queue.process(preview=False)
  queue.process(preview=True)  # Only show what the outcomes would be



  item.fulfill()
  ```



  ```mermaid
  graph TD;

    subgraph QueueSupport
      Queue["Queue"]
      Item["Add item"]
      Process["Process (fulfill all items)"]
    end

    Queue --> Item

    subgraph ItemTypes["Item types"]
      ChmodItem["ChmodItem"]
      SystemdUnitEnableItem["SystemdUnitEnableItem"]
      SystemdUnitRestartItem["SystemdUnitRestartItem"]
      MkdirItem["MkdirItem"]
      UnlinkItem["UnlinkItem"]
      RmTreeItem["RmTreeItem"]
      Other["Others..."]
    end

    Item --> ItemTypes
    ItemTypes --> Outcome["Outcome (item's goal)"]

    Process --> Fulfill["Fulfill outcomes for each item"]

    % Example flows for item attributes and outcomes
    ChmodItem -.->|path, mode| Outcome
    SystemdUnitEnableItem -.->|unit name| Outcome
    MkdirItem -.->|path| Outcome
    UnlinkItem -.->|unlink file| Outcome
    RmTreeItem -.->|remove directory| Outcome

    Queue --> Process
    Process --> Fulfill
  ```



  ```python
  from cyberfusion.QueueSupport import Queue
  from cyberfusion.QueueSupport.items.chmod import ChmodItem

  queue = Queue()

  item = ChmodItem(path="/tmp/example.txt", mode=0o600)
  print(item.outcomes)

  queue.add(item)

  preview = True or False

  outcomes = queue.process(preview=preview)

  for outcome in outcomes:
      print(str(outcome))
  ```


pkgId: 99578ec1eca471f82cec59b92536d8037e148d7c92555e41cd367b745cda8cc3
name: python-python3-cyberfusion-wordpress-support-help
arch: noarch
version: 2.0
epoch: 0
release: 1
summary: Development documents and examples for python3-cyberfusion-wordpress-support
url: https://pypi.org/project/python3-cyberfusion-wordpress-support/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-python3-cyberfusion-wordpress-support-2.0-1.src.rpm
location_href: Packages/python-python3-cyberfusion-wordpress-support-help-2.0-1.noarch.rpm
checksum_type: sha256
description:
  Library for WordPress.





  Run the following command to install the package from PyPI:

      pip3 install python3-cyberfusion-wordpress-support

  Next, install the following software:

  * WP-CLI, according to the [documentation](https://make.wordpress.org/cli/handbook/guides/installing/#recommended-installation) or using [Homebrew](https://formulae.brew.sh/formula/wp-cli). WP-CLI is not required to run tests (automatically downloaded on every suite run).
  * MariaDB client (required by WP-CLI), possibly using [Homebrew](https://formulae.brew.sh/formula/mysql-client).



  Run the following commands to build a Debian package:

      mk-build-deps -i -t 'apt -o Debug::pkgProblemResolver=yes --no-install-recommends -y'
      dpkg-buildpackage -us -uc



  No configuration is supported.



  See code.


pkgId: d5c8048f19baf3ef0069ea8c0be4f37af8f0db45ab664ef571bad7f4c04e687f
name: python-pythresh-help
arch: noarch
version: 0.3.8
epoch: 0
release: 1
summary: Development documents and examples for pythresh
url: https://github.com/KulikDM/pythresh
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pythresh-0.3.8-1.src.rpm
location_href: Packages/python-pythresh-help-0.3.8-1.noarch.rpm
checksum_type: sha256
description:
  PyThresh is a comprehensive and scalable **Python toolkit** for
  **thresholding outlier detection likelihood scores** in
  univariate/multivariate data. It has been written to work in tandem with
  PyOD and has similar syntax and data structures. However, it is not
  limited to this single library. PyThresh is meant to threshold
  likelihood scores generated by an outlier detector. It thresholds these
  likelihood scores and replaces the need to set a contamination level or
  have the user guess the amount of outliers that may exist in the dataset
  beforehand. These non-parametric methods were written to reduce the
  user's input/guess work and rather rely on statistics instead to
  threshold outlier likelihood scores. For thresholding to be applied
  correctly, the outlier detection likelihood scores must follow this
  rule: the higher the score, the higher the probability that it is an
  outlier in the dataset. All threshold functions return a binary array
  where inliers and outliers are represented by a 0 and 1 respectively.
  PyThresh includes more than 30 thresholding algorithms. These algorithms
  range from using simple statistical analysis like the Z-score to more
  complex mathematical methods that involve graph theory and topology.
  ************************
   Documentation & Citing
  ************************
  Visit `PyThresh Docs
  <https://pythresh.readthedocs.io/en/latest/?badge=latest>`_ for full
  documentation or see below for a quickstart installation and usage
  example.
  To cite this work you can visit `PyThresh Citation


pkgId: 9e2e4a2fd5282d609e24489fe254fee4507d80b2a7820b89bc50d63b15a91786
name: python-pytincture-help
arch: noarch
version: 0.6.5
epoch: 0
release: 1
summary: Development documents and examples for pytincture
url: https://github.com/pytincture/pytincture
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytincture-0.6.5-1.src.rpm
location_href: Packages/python-pytincture-help-0.6.5-1.noarch.rpm
checksum_type: sha256
description:
  `pyTincture` is a Python framework designed to leverage the capabilities of Pyodide, enabling developers to create sophisticated and user-friendly GUI libraries. This project aims to bridge the gap between Python's powerful backend and intuitive, interactive frontend interfaces.


  - **Pyodide Integration**: Seamlessly integrates with Pyodide to bring Python to the web.
  - **GUI Library Support**: Simplifies the process of creating and managing GUI components in Python.
  - **Cross-Platform Compatibility**: Works across various platforms where Pyodide is supported.
  - **Easy to Use**: User-friendly API that makes GUI development in Python more accessible.


  - Python 3.x
  - Pyodide


  Run the docker image directly from Dockerhub
  ~~~
  docker run -p8070:8070 -i pytincture/pytincture:latest
  ~~~
  Load url in browser
  ~~~
  http://localhost:8070/py_ui
  ~~~



  `pyTincture` is licensed under the MIT License.


pkgId: 8035bdea77300536d2054f2d639743d0d928a69c8ca8164ec1698ff2739bc040
name: python-pytokens-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for pytokens
url: https://github.com/tusharsadhwani/pytokens
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytokens-0.0.0-1.src.rpm
location_href: Packages/python-pytokens-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A Fast, spec compliant Python 3.12+ tokenizer that runs on older Pythons.

  > WORK IN PROGRESS!



  ```bash
  pip install pytokens
  ```



  TODO



  - Create and activate a virtual environment
  - Run `pip install -r requirements-dev.txt` to do an editable install
  - Run `pytest` to run tests



  Run `mypy .`



  Make sure to bump the version in `setup.cfg`.

  Then run the following commands:

  ```bash
  rm -rf build dist
  python setup.py sdist bdist_wheel
  ```

  Then upload it to PyPI using [twine](https://twine.readthedocs.io/en/latest/#installation):

  ```bash
  twine upload dist/*
  ```


pkgId: 10acf506ab7b4eef221a3ce17bf3e4efce70d32a52377e56d3e5da837b6a5af3
name: python-pytokens-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for pytokens
url: https://github.com/tusharsadhwani/pytokens
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytokens-0.1.1-1.src.rpm
location_href: Packages/python-pytokens-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A Fast, spec compliant Python 3.12+ tokenizer that runs on older Pythons.



  ```bash
  pip install pytokens
  ```



  ```bash
  pytokens path/to/file.py
  ```



  - Create and activate a virtual environment
  - Run `pip install -r requirements-dev.txt` to do an editable install
  - Run `pytest` to run tests



  Run `mypy .`



  Make sure to bump the version in `setup.cfg`.

  Then run the following commands:

  ```bash
  rm -rf dist
  python -m build
  ```

  Then upload it to PyPI using [twine](https://twine.readthedocs.io/en/latest/#installation):

  ```bash
  twine upload dist/*
  ```


pkgId: 6b426f5cdfad76a47b8f89d19a3a08fed0849cbcebf7d33294870bc9092e52b2
name: python-pytonapi-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for pytonapi
url: https://github.com/tonkeeper/pytonapi/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytonapi-0.4.4-1.src.rpm
location_href: Packages/python-pytonapi-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  [![TON](https://img.shields.io/badge/TON-grey?logo=TON&logoColor=40AEF0)](https://ton.org)
  [![PyPI](https://img.shields.io/pypi/v/pytonapi.svg?color=FFE873&labelColor=3776AB)](https://pypi.python.org/pypi/pytonapi)
  ![Python Versions](https://img.shields.io/badge/Python-3.7%20--%203.12-black?color=FFE873&labelColor=3776AB)
  [![License](https://img.shields.io/github/license/tonkeeper/pytonapi)](https://github.com/tonkeeper/pytonapi/blob/main/LICENSE)

  ![Image](https://telegra.ph//file/f88bcf9051073973edbd6.jpg)

  ![Downloads](https://pepy.tech/badge/pytonapi)
  ![Downloads](https://pepy.tech/badge/pytonapi/month)
  ![Downloads](https://pepy.tech/badge/pytonapi/week)

  Python SDK for [tonapi.io](https://tonapi.io).\
  Information about the API can be found in the  [documentation](https://docs.tonconsole.com/tonapi/api-v2).\
  To use the API **you need an API key**, you can get it here [tonconsole.com](https://tonconsole.com/).

  <blockquote>
  For creating wallets, transferring TON, Jetton, NFTs, and other operations, recommend using <a href="https://github.com/nessshon/tonutils">tonutils</a> in combination with <code>TonapiClient</code>. For more information, refer to the library documentation.
  </blockquote>





  ```bash
  pip install pytonapi
  ```



  * **Asynchronous**

    ```python
    from pytonapi import AsyncTonapi


    
    async def main():
        
        tonapi = AsyncTonapi(api_key="Your API key")

        
        account_id = "EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess"  # noqa

        
        account = await tonapi.accounts.get_info(account_id=account_id)

        
        print(f"Account Address (raw): {account.address.to_raw()}")
        print(f"Account Address (userfriendly): {account.address.to_userfriendly(is_bounceable=True)}")
        print(f"Account Balance (nanoton): {account.balance.to_nano()}")
        print(f"Account Balance (amount): {account.balance.to_amount()}")


    if __name__ == '__main__':
        import asyncio

        
        asyncio.run(main())

    ```

  * **Synchronous**

    ```python
    from pytonapi import Tonapi


    def main():
        
        tonapi = Tonapi(api_key="Your API key")

        
        account_id = "EQC-3ilVr-W0Uc3pLrGJElwSaFxvhXXfkiQA3EwdVBHNNess"  # noqa

        
        account = tonapi.accounts.get_info(account_id=account_id)

        
        print(f"Account Address (raw): {account.address.to_raw()}")
        print(f"Account Address (userfriendly): {account.address.to_userfriendly(is_bounceable=True)}")
        print(f"Account Balance (nanoton): {account.balance.to_nano()}")
        print(f"Account Balance (amount): {account.balance.to_amount()}")


    if __name__ == '__main__':
        main()
    ```

  * **Additional examples** can be found [examples](https://github.com/tonkeeper/pytonapi/tree/main/examples) folder.



  **TON** - `UQCDrgGaI6gWK-qlyw69xWZosurGxrpRgIgSkVsgahUtxZR0`

  **USDT** (TRC-20) - `TGKmm9H3FApFw8xcgRcZDHSku68vozAjo9`



  We welcome your contributions! If you have ideas for improvement or have identified a bug, please create an issue or
  submit a pull request.



  Supported by  [TONAPI](https://tonapi.io) and [TON Society](https://github.com/ton-society/grants-and-bounties) (Grants
  and Bounties program).



  This repository is distributed under the [MIT License](https://github.com/tonkeeper/pytonapi/blob/main/LICENSE). Feel
  free to use, modify, and distribute the code in accordance
  with the terms of the license.


pkgId: f72989347945b5ae569e939980aedb7ac3f01f11709846c6a9b57b7291f471fd
name: python-pytorch-candle-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for pytorch-candle
url: https://github.com/paraglondhe/pytorch-candle
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytorch-candle-0.0.1-1.src.rpm
location_href: Packages/python-pytorch-candle-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A versatile PyTorch training framework to simplify and enhance the model training process. It includes a trainer class with efficient training methods, famous built in pre-trained architectures, metrics tracking, custom and built-in callbacks support, and much more!


pkgId: 1b347d5629fb046163ad90a565bba5a6f1e70ee588526868f570d55e1c4b0bb1
name: python-pytorch-ie-help
arch: noarch
version: 0.31.4
epoch: 0
release: 1
summary: Development documents and examples for pytorch-ie
url: https://github.com/christophalt/pytorch-ie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytorch-ie-0.31.4-1.src.rpm
location_href: Packages/python-pytorch-ie-help-0.31.4-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/pytorch-ie.svg)][pypi status]
  [![Status](https://img.shields.io/pypi/status/pytorch-ie.svg)][pypi status]
  [![Python Version](https://img.shields.io/pypi/pyversions/pytorch-ie)][pypi status]
  [![License](https://img.shields.io/pypi/l/pytorch-ie)][license]

  [![Read the documentation at https://pytorch-ie.readthedocs.io/](https://img.shields.io/readthedocs/pytorch-ie/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/christophalt/pytorch-ie/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/christophalt/pytorch-ie/branch/main/graph/badge.svg)][codecov]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]

  [pypi status]: https://pypi.org/project/pytorch-ie/
  [read the docs]: https://pytorch-ie.readthedocs.io/
  [tests]: https://github.com/christophalt/pytorch-ie/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/christophalt/pytorch-ie
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  This is an experimental framework that aims to combine the lessons learned from five years of information extraction research.

  -   **Focus on the core task:** The main goal is to develop information extraction methods not dataset loading and evaluation logic. We use external well-maintained libraries for non-core functionality. PyTorch-Lightning for training and logging, Huggingface datasets for dataset reading, and Huggingface evaluate for evaluation (coming soon).
  -   **Sharing is caring:** Being able to quickly and easily share models is key to promote your work and facilitate further research. All models developed in PyTorch-IE can be easily shared via the Huggingface model hub. This further allows to quickly build demos based on Huggingface spaces, gradio or streamlit.
  -   **Unified document format:** A unified document format allows for quick experimentation on any dataset or task.
  -   **Beyond sentence level:** Most information extraction frameworks assume text inputs at a sentence granularity. We do not make any assumption on the granularity but generally aim for document-level information extraction.
  -   **Beyond unstructured text:** Unstructured text is only one possible area for information extraction. We developed the framework to also support information extraction from semi-structured text (e.g. HTML), two-dimensional text (e.g. OCR'd images), and images.
  -   **Character-level annotation and evaluation:** Many information extraction frameworks annotate and evaluate on a token level. We believe that annotation and evaluation should be done on a character level as this also considers the suitability of the tokenizer for the task.
  -   **Make no assumptions on the structure of models:** The last years have seen many different and creative approaches to information extraction and a framework that imposes a structure on those will most certainly be to limiting. With PyTorch-iE you have full control over how a document is prepared for a model and how the model is structured. The logic is self-contained and thus can be easily shared and inspected by others. The only assumption we make is that the input is a document and the output are targets (training) or annotations (inference).



  | Task                                                       | Link                                                                                                                                                                  |
  | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | Named Entity Recognition (Span-based)                      | [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/pie/NER)                               |
  | Joint Named Entity Recognition and Relation Classification | [![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/pie/Joint-NER-and-Relation-Extraction) |



  ```console
  $ pip install pytorch-ie
  ```

  **For even faster prototyping with pre-defined, but fully configurable training pipelines and much more useful tooling, have a look into the [PyTorch-IE-Hydra-Template](https://github.com/ChristophAlt/pytorch-ie-hydra-template).**



  PyTorch-IE builds on three core concepts: the **📃 Document**, the **🔤 ⇔ 🔢 Taskmodule**, and the **🧮 Model**. In a
  nutshell, the Document says how your data is structured, the Model defines your trainable logic and the Taskmodule
  converts from one end to the other. All three concepts are represented as abstract classes that should be used to
  derive use-case specific versions. In the following, they are explained in detail.

  <details>
  <summary>



  </summary>

  The `Document` class is a special `dataclass` that defines the document model. Derivations can contain several
  elements:

  -   **Data fields** like strings to represent one or multiple texts or arrays for image data. These elements can be
      arbitrary python objects.
  -   **Annotation fields** like labeled spans for entities or labeled tuples of spans for relations. These elements have
      to be of a certain container type `AnnotationList` that is dynamically typed with the actual annotation type, e.g.
      `entities: AnnotationList[LabeledSpan]`. Furthermore, annotation elements define one or multiple annotation `targets`.
      An annotation target is either a data element or another annotation container. Internally, targets are used to construct the
      annotation graph, i.e. data elements and annotation containers are the nodes and targets define the edges. The
      annotation graph defines the (de-)serialization order and what is accessible from within an annotation. To
      facilitate the setup of annotation containers, there is the `annotation_field()` method.
  -   **Other fields** to save metadata, ids, etc. They are not constrained in any way, but can not be accessed from within
      annotations.

  <details>

  <summary>



  </summary>

  ```python
  from typing import Optional
  from pytorch_ie.core import Document, AnnotationLayer, annotation_field
  from pytorch_ie.annotations import LabeledSpan, BinaryRelation, Label


  class MyDocument(Document):
      
      text: str
      
      entities: AnnotationLayer[LabeledSpan] = annotation_field(target="text")
      relations: AnnotationLayer[BinaryRelation] = annotation_field(target="entities")
      label: AnnotationLayer[Label] = annotation_field()
      
      doc_id: Optional[str] = None
  ```

  Note that the `label` is a special annotation field that does not define a target because it belongs to the whole document.
  You can also have more complex constructs, like annotation fields that target multiple other fields by using
  `annotation_field(targets)` or `annotation_field(named_targets)`. The latter is useful if you want to access the
  targets by name from within the annotation, see below for an example.

  </details>



  There are several predefined **annotation types** in `pytorch_ie.annotations`, however, feel free to define your own.
  Annotations have to be dataclasses that subclass `pytorch_ie.core.Annotation`. They also need to be hashable and
  immutable. The following is a simple example:

  ```python
  @dataclass(eq=True, frozen=True)
  class SimpleLabeledSpan(Annotation):
      start: int
      end: int
      label: str
  ```

  <details>
  <summary>



  </summary>

  We can expand the above example a little to have a nice string representation:

  ```python
  @dataclass(eq=True, frozen=True)
  class LabeledSpan(Annotation):
      start: int
      end: int
      label: str

      def __str__(self) -> str:
          if self.targets is None:
              return ""
          return str(self.target[self.start : self.end])
  ```

  The content of `self.target` is lazily assigned as soon as the annotation is added to a document.

  Note that this now expects a single `collections.abc.Sequence` as `target`, e.g.:

  ```python
  my_spans: AnnotationLayer[Span] = annotation_field(target="<NAME_OF_THE_SEQUENCE_FIELD>")
  ```

  If we have multiple targets, we need to define target names to access them. For this, we need to set the special
  field `TARGET_NAMES`:

  ```python
  @dataclass(eq=True, frozen=True)
  class Alignment(Annotation):
      TARGET_NAMES = ("text1", "text2")
      start1: int
      end1: int
      start2: int
      end2: int

      def __str__(self) -> str:
          if self.targets is None:
              return ""
          
          span1 = self.named_targets["text1"][self.start1 : self.end1]
          span2 = self.named_targets["text2"][self.start2 : self.end2]
          return f'span1="{span1}" is aligned with span2="{span2}"'
  ```

  This requires to define the annotation container as follows:

  ```python
  class MyDocumentWithAlignment(Document):
      text_a: str
      text_b: str
      
      my_alignments: AnnotationLayer[Alignment] = annotation_field(named_targets={"text1": "text_a", "text2": "text_b"})
  ```

  Note that `text1` and `text2` can also target the same field.

  </details>
  <details>
  <summary>



  </summary>

  As usual for dataclasses, annotations can be converted to json like objects with `.asdict()`. However, they can be
  also created with `MyAnnotation.fromdict(dct, annotation_store)`. Both methods are required because documents and
  their annotations are created on the fly when working with PIE datasets (see below).

  </details>
  </details>
  <details>
  <summary>



  </summary>

  The taskmodule is responsible for converting documents to model inputs and back. For that purpose, it requires the
  user to implement the following methods:

  -   `encode_input`: Taking one document, create one or multiple `TaskEncoding`s. A `TaskEncoding` represents an
      example that will be passed to the model later on. It is a container holding `inputs`, optional `targets`, the
      original `document`, and `metadata`. Note that `encode_input` should not assign a value to `targets`.
  -   `encode_target`: This gets a single `TaskEncoding` and should produce a target encoding that will be assigned
      to `targets` later on. As such, it is called only during training / evaluation, but not for inference. Note that,
      this is allowed to return None. In this case, the respective `TaskEncoding` will not be passed to the model at all.
  -   `collate`: Taking a batch of `TaskEncoding`s, this should produce a batch input for the model. Note that this has to
      work with available targets (training and evaluation) and without them (inference).
  -   `unbatch_output`: This gets a batch output from the model and should rearrange that into a sequence of `TaskOutput`s.
      In that means it can be understood as the opposite to `collate`. The number of `TaskOutput`s should match the
      number of `TaskEncoding`s that got into the batch because we align them later on for easy creation of new annotations.
  -   `create_annotations_from_output`: This gets a single `TaskEncoding` with its corresponding `TaskOutput` and
      should yield tuples each consisting of an annotation field name and an annotation. The annotations will be added
      as predictions to the annotation field with the respective name.
  -   `prepare` (OPTIONAL): This will get the train dataset, i.e. a Sequence or Iterable of Documents, and can be used
      to calculate additional parameters like the list of all available labels, etc.

  You can find some predefined taskmodules for _text-_ and _token classification_, _text classification based relation
  extraction_, _joint entity and relation classification_ and other use cases in the package
  [`pytorch_ie.taskmodules`](src/pytorch_ie/taskmodules). Especially, have a look at the
  [SimpleTransformerTextClassificationTaskModule](src/pytorch_ie/taskmodules/simple_transformer_text_classification.py)
  that is well documented and should provide a good starting point to implement your own one.

  </details>
  <details>
  <summary>



  </summary>

  PyTorch-IE models are meant to do the heavy lifting training and inference. They are
  [Pytorch-Lightning modules](https://pytorch-lightning.readthedocs.io/en/stable/common/lightning_module.html),
  enhanced with some functionality to ease persisting them, see [Reusability and Sharing](#reusability-and-sharing).

  You can find some predefined models for transformer based _text-_ and _token classification_, _sequence generation_,
  and other use cases in the package [`pytorch_ie.models`](src/pytorch_ie/models).

  </details>



  Taskmodules and Models provide some functionality to ease reusability and reproducibility. Especially, they provide
  the methods `save_pretrained()` and `from_pretrained()` that can be used to save their specification, i.e. their
  **config**, and available model wights to disc and exactly re-create them again from that data.

  <details>
  <summary>



  </summary>

  These methods come along
  with integration to the [Huggingface Hub](https://huggingface.co/docs/hub/index). By passing `push_to_hub=True` to
  `save_pretrained()`, the taskmodule / model is directly pushed to the Hub and can be loaded again with the respective
  identifier (see the [Examples](examples) for how to do so). However, to work properly, each taskmodule / model has to
  correctly implement the `_config()` getter method. Per default, it returns all parameters passed to the `__init__`
  method if this calls `save_hyperparameters()` which is very recommended. But you may have created some further
  parameters that should be persisted, for instance a label-to-id mapping. In this case, `_config()` should be
  overwritten to take this into account:

  ```python
  def _config(self) -> Dict[str, Any]:
      
      config = super()._config()
      config["label_to_id"] = self.label_to_id
      return config
  ```

  Furthermore, you can use the property `is_from_pretrained` to know if the taskmodule / model is just loaded or created
  from scratch. This may be useful, for instance, to avoid downloading a model from Huggingface Transformers when you
  in fact want to load your own trained model from disc via `from_pretrained`:

  ```python
  from transformers import AutoConfig, AutoModel

  hf_config = AutoConfig.from_pretrained(model_name_or_path)


  if self.is_from_pretrained:
      self.model = AutoModel.from_config(config=hf_config)

  else:
      self.model = AutoModel.from_pretrained(model_name_or_path, config=hf_config)
  ```

  </details>

  In short, each taskmodule / model implementation should:

  -   call `save_hyperparameters()` in `__init__` to save all constructor arguments,
  -   pass remaining `__init__` kwargs (keyword arguments) to its super to not break some other helpful functionality
      (e.g. `is_from_pretrained`), and
  -   overwrite `_config()` if additional parameters are calculated, e.g. from the dataset.



  **The following examples work out of the box. No further setup like manually downloading a model is needed!**

  **Note:** Setting `num_workers=0` in the pipeline is only necessary when running an example in an
  interactive python session. The reason is that multiprocessing doesn't play well with the interactive python
  interpreter, see [here](https://docs.python.org/3/library/multiprocessing.html#using-a-pool-of-workers)
  for details.



  ```python
  from dataclasses import dataclass

  from pytorch_ie.annotations import LabeledSpan
  from pytorch_ie.auto import AutoPipeline
  from pytorch_ie.core import AnnotationLayer, annotation_field
  from pytorch_ie.documents import TextDocument


  @dataclass
  class ExampleDocument(TextDocument):
      entities: AnnotationLayer[LabeledSpan] = annotation_field(target="text")


  document = ExampleDocument(
      "“Making a super tasty alt-chicken wing is only half of it,” said Po Bronson, general partner at SOSV and managing director of IndieBio."
  )


  ner_pipeline = AutoPipeline.from_pretrained("pie/example-ner-spanclf-conll03", device=-1, num_workers=0)

  ner_pipeline(document)

  for entity in document.entities.predictions:
      print(f"{entity} -> {entity.label}")





  ```

  <details>
  <summary>
  To create the same pipeline as above without `AutoPipeline`
  </summary>

  ```python
  from pytorch_ie.auto import AutoTaskModule, AutoModel
  from pytorch_ie.pipeline import Pipeline

  model_name_or_path = "pie/example-ner-spanclf-conll03"
  ner_taskmodule = AutoTaskModule.from_pretrained(model_name_or_path)
  ner_model = AutoModel.from_pretrained(model_name_or_path)
  ner_pipeline = Pipeline(model=ner_model, taskmodule=ner_taskmodule, device=-1, num_workers=0)
  ```

  </details>

  <details>
  <summary>
  Or, without `Auto` classes at all
  </summary>

  ```python
  from pytorch_ie.pipeline import Pipeline
  from pytorch_ie.models import TransformerSpanClassificationModel
  from pytorch_ie.taskmodules import TransformerSpanClassificationTaskModule

  model_name_or_path = "pie/example-ner-spanclf-conll03"
  ner_taskmodule = TransformerSpanClassificationTaskModule.from_pretrained(model_name_or_path)
  ner_model = TransformerSpanClassificationModel.from_pretrained(model_name_or_path)
  ner_pipeline = Pipeline(model=ner_model, taskmodule=ner_taskmodule, device=-1, num_workers=0)
  ```

  </details>
  <details>
  <summary>



  </summary>

  ```python
  from dataclasses import dataclass

  from pytorch_ie.annotations import BinaryRelation, LabeledSpan
  from pytorch_ie.auto import AutoPipeline
  from pytorch_ie.core import AnnotationLayer, annotation_field
  from pytorch_ie.documents import TextDocument


  @dataclass
  class ExampleDocument(TextDocument):
      entities: AnnotationLayer[LabeledSpan] = annotation_field(target="text")
      relations: AnnotationLayer[BinaryRelation] = annotation_field(target="entities")


  document = ExampleDocument(
      "“Making a super tasty alt-chicken wing is only half of it,” said Po Bronson, general partner at SOSV and managing director of IndieBio."
  )

  re_pipeline = AutoPipeline.from_pretrained("pie/example-re-textclf-tacred", device=-1, num_workers=0)

  for start, end, label in [(65, 75, "PER"), (96, 100, "ORG"), (126, 134, "ORG")]:
      document.entities.append(LabeledSpan(start=start, end=end, label=label))

  re_pipeline(document, batch_size=2)

  for relation in document.relations.predictions:
      print(f"({relation.head} -> {relation.tail}) -> {relation.label}")






  ```

  </details>



  <details>

  <summary>



  </summary>

  ```python
  import pytorch_lightning as pl
  from pytorch_lightning.callbacks import ModelCheckpoint
  from torch.utils.data import DataLoader

  import datasets
  from pytorch_ie.models.transformer_span_classification import TransformerSpanClassificationModel
  from pytorch_ie.taskmodules.transformer_span_classification import (
      TransformerSpanClassificationTaskModule,
  )

  pl.seed_everything(42)

  model_output_path = "./model_output/"
  model_name = "bert-base-cased"
  num_epochs = 10
  batch_size = 32




  dataset = datasets.load_dataset(
      path="pie/conll2003",
  )
  train_docs, val_docs = dataset["train"], dataset["validation"]

  print("train docs: ", len(train_docs))
  print("val docs: ", len(val_docs))


  task_module = TransformerSpanClassificationTaskModule(
      tokenizer_name_or_path=model_name,
      entity_annotation="entities",
      max_length=128,
  )




  task_module.prepare(train_docs)




  task_module.save_pretrained(model_output_path)



  train_dataset = task_module.encode(train_docs, encode_target=True, as_dataset=True)
  val_dataset = task_module.encode(val_docs, encode_target=True, as_dataset=True)


  train_dataloader = DataLoader(
      train_dataset,
      batch_size=batch_size,
      shuffle=True,
      collate_fn=task_module.collate,
  )

  val_dataloader = DataLoader(
      val_dataset,
      batch_size=batch_size,
      shuffle=False,
      collate_fn=task_module.collate,
  )



  model = TransformerSpanClassificationModel(
      model_name_or_path=model_name,
      num_classes=len(task_module.label_to_id),
      t_total=len(train_dataloader) * num_epochs,
      learning_rate=1e-4,
  )















  trainer = pl.Trainer(
      fast_dev_run=False,
      max_epochs=num_epochs,
      gpus=0,
      enable_checkpointing=False,
      
      precision=32,
  )

  trainer.fit(model, train_dataloader, val_dataloader)




  ```

  </details>



  PyTorch-IE works quite well together with Huggingface datasets. Have a look at
  [pie-datasets](https://github.com/ArneBinder/pie-datasets) for helpful tooling and a collection of datasets
  that are already converted to the PIE format.

  <!-- github-only -->

  <!-- TODO ✨📚✨ [Read the full documentation](https://pytorch-ie.readthedocs.io/) -->





  This project is build with [Poetry](https://python-poetry.org/). If not yet done, follow the
  [Poetry installation guide](https://python-poetry.org/docs/#installation) to install it. Then, install all
  dependencies (including for development) for PyTorch-IE by calling the following command from the root of the
  repository:

  ```bash
  poetry install --with dev
  ```

  NOTE: If the installation gets stuck, try if disabling experimental parallel installer helps
  ([source](https://github.com/python-poetry/poetry/issues/3352#issuecomment-732761629)):
  `poetry config experimental.new-installer false`



  We use [Nox](https://nox.thea.codes/en/stable/) to execute any tests and code quality tooling in a reproducible way.

  To get a list of available toolchains, call:

  ```bash
  poetry run nox -l
  ```

  To run a specific command from that list, call:

  ```bash
  poetry run nox -s <command>
  ```

  Note: To run the nox commands in the same, reproducible setup that is specified by the lock file, we call them via
  `poetry run <nox-command>`.

  For instance, to run static type checking with `mypy`, call:

  ```bash
  poetry run nox -s mypy-3.9
  ```

  To run all commands that also run on GitHub CI, call:

  ```bash
  poetry run nox
  ```

  You can also start a shell with Poetry's virtual environment activated by calling:

  ```bash
  poetry shell
  ```

  This allows you to run above commands without the `poetry run` prefix.



  Call this to update individual packages:

  ```bash
  poetry update <package>
  ```

  Then, commit the modified lock file to persist the state.



  Since this project is based on the [Cookiecutter template](https://cookiecutter-hypermodern-python.readthedocs.io), we can follow
  [their release steps](https://cookiecutter-hypermodern-python.readthedocs.io/en/2022.6.3.post1/guide.html#how-to-make-a-release):

  1. Create the release branch:
     `git switch --create release main`
  2. Increase the version:
     `poetry version <PATCH|MINOR|MAJOR>`,
     e.g. `poetry version patch` for a patch release
  3. Commit the changes:
     `git commit --message="release <NEW VERSION>" pyproject.toml`,
     e.g. `git commit --message="release 0.13.0" pyproject.toml`
  4. Push the changes to GitHub:
     `git push origin release`
  5. Create a PR for that `release` branch on GitHub.
  6. Wait until checks passed successfully.
  7. Integrate the PR into the main branch. This triggers the GitHub Action that
     creates all relevant release artefacts and also uploads them to PyPI.
  8. Cleanup: Delete the `release` branch.



  -   This package is based on the [sourcery-ai/python-best-practices-cookiecutter](https://github.com/sourcery-ai/python-best-practices-cookiecutter) and [cjolowicz/cookiecutter-hypermodern-python](https://github.com/cjolowicz/cookiecutter-hypermodern-python) project templates.



  If you find the framework useful please consider citing it:

  ```bibtex
  @misc{binder2024pytorchie,
        title={PyTorch-IE: Fast and Reproducible Prototyping for Information Extraction},
        author={Arne Binder and Leonhard Hennig and Christoph Alt},
        year={2024},
        eprint={2406.00007},
        archivePrefix={arXiv},
        primaryClass={cs.IR}
  }
  ```

  [license]: https://github.com/christophalt/pytorch-ie/blob/main/LICENSE


pkgId: 4f3b28c88a0fb1432f92b5dddd7ac4d7e79bc02823b8acc61c4ab33247b3842b
name: python-pytorch-ignite-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for pytorch-ignite
url: https://github.com/pytorch/ignite
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytorch-ignite-0.5.1-1.src.rpm
location_href: Packages/python-pytorch-ignite-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <!-- ![Ignite Logo](assets/logo/ignite_logo_mixed.svg) -->

  <img src="https://raw.githubusercontent.com/pytorch/ignite/master/assets/logo/ignite_logo_mixed.svg" width=512>

  <!-- [![image](https://travis-ci.com/pytorch/ignite.svg?branch=master)](https://travis-ci.com/pytorch/ignite) -->

  | ![image](https://img.shields.io/badge/-Tests:-black?style=flat-square) [![image](https://github.com/pytorch/ignite/actions/workflows/unit-tests.yml/badge.svg?branch=master)](https://github.com/pytorch/ignite/actions/workflows/unit-tests.yml) [![image](https://github.com/pytorch/ignite/actions/workflows/gpu-tests.yml/badge.svg)](https://github.com/pytorch/ignite/actions/workflows/gpu-tests.yml) [![image](https://codecov.io/gh/pytorch/ignite/branch/master/graph/badge.svg)](https://codecov.io/gh/pytorch/ignite) [![image](https://img.shields.io/badge/dynamic/json.svg?label=docs&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpytorch-ignite%2Fjson&query=%24.info.version&colorB=brightgreen&prefix=v)](https://pytorch.org/ignite/index.html) |
  |:---
  | ![image](https://img.shields.io/badge/-Stable%20Releases:-black?style=flat-square) [![image](https://anaconda.org/pytorch/ignite/badges/version.svg)](https://anaconda.org/pytorch/ignite) ・ [![image](https://img.shields.io/badge/dynamic/json.svg?label=PyPI&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fpytorch-ignite%2Fjson&query=%24.info.version&colorB=brightgreen&prefix=v)](https://pypi.org/project/pytorch-ignite/) [![image](https://static.pepy.tech/badge/pytorch-ignite)](https://pepy.tech/project/pytorch-ignite) ・ [![image](https://img.shields.io/badge/docker-hub-blue)](https://hub.docker.com/u/pytorchignite) |
  | ![image](https://img.shields.io/badge/-Nightly%20Releases:-black?style=flat-square) [![image](https://anaconda.org/pytorch-nightly/ignite/badges/version.svg)](https://anaconda.org/pytorch-nightly/ignite) [![image](https://img.shields.io/badge/PyPI-pre%20releases-brightgreen)](https://pypi.org/project/pytorch-ignite/#history)|
  | ![image](https://img.shields.io/badge/-Community:-black?style=flat-square) [![Twitter](https://img.shields.io/badge/news-twitter-blue)](https://twitter.com/pytorch_ignite) [![discord](https://img.shields.io/badge/chat-discord-blue?logo=discord)](https://discord.gg/djZtm3EmKj) [![numfocus](https://img.shields.io/badge/NumFOCUS-affiliated%20project-green)](https://numfocus.org/sponsored-projects/affiliated-projects) |
  | ![image](https://img.shields.io/badge/-Supported_PyTorch/Python_versions:-black?style=flat-square) [![link](https://img.shields.io/badge/-check_here-blue)](https://github.com/pytorch/ignite/actions?query=workflow%3A%22PyTorch+version+tests%22)|

  </div>



  Ignite is a high-level library to help with training and evaluating neural networks in PyTorch flexibly and transparently.

  <div align="center">

  <a href="https://colab.research.google.com/github/pytorch/ignite/blob/master/assets/tldr/teaser.ipynb">
   <img alt="PyTorch-Ignite teaser"
        src="https://raw.githubusercontent.com/pytorch/ignite/master/assets/tldr/pytorch-ignite-teaser.gif"
        width=532>
  </a>

  _Click on the image to see complete code_

  </div>



  - [Less code than pure PyTorch](https://raw.githubusercontent.com/pytorch/ignite/master/assets/ignite_vs_bare_pytorch.png)
    while ensuring maximum control and simplicity

  - Library approach and no program's control inversion - _Use ignite where and when you need_

  - Extensible API for metrics, experiment managers, and other components

  <!-- ############################################################################################################### -->



  - [Table of Contents](#table-of-contents)
  - [Why Ignite?](#why-ignite)
    - [Simplified training and validation loop](#simplified-training-and-validation-loop)
    - [Power of Events & Handlers](#power-of-events--handlers)
      - [Execute any number of functions whenever you wish](#execute-any-number-of-functions-whenever-you-wish)
      - [Built-in events filtering](#built-in-events-filtering)
      - [Stack events to share some actions](#stack-events-to-share-some-actions)
      - [Custom events to go beyond standard events](#custom-events-to-go-beyond-standard-events)
    - [Out-of-the-box metrics](#out-of-the-box-metrics)
  - [Installation](#installation)
    - [Nightly releases](#nightly-releases)
    - [Docker Images](#docker-images)
      - [Using pre-built images](#using-pre-built-images)
  - [Getting Started](#getting-started)
  - [Documentation](#documentation)
    - [Additional Materials](#additional-materials)
  - [Examples](#examples)
    - [Tutorials](#tutorials)
    - [Reproducible Training Examples](#reproducible-training-examples)
  - [Communication](#communication)
    - [User feedback](#user-feedback)
  - [Contributing](#contributing)
  - [Projects using Ignite](#projects-using-ignite)
  - [Citing Ignite](#citing-ignite)
  - [About the team & Disclaimer](#about-the-team--disclaimer)

  <!-- ############################################################################################################### -->



  Ignite is a **library** that provides three high-level features:

  - Extremely simple engine and event system
  - Out-of-the-box metrics to easily evaluate models
  - Built-in handlers to compose training pipeline, save artifacts and log parameters and metrics



  No more coding `for/while` loops on epochs and iterations. Users instantiate engines and run them.

  <details>
  <summary>
  Example
  </summary>

  ```python
  from ignite.engine import Engine, Events, create_supervised_evaluator
  from ignite.metrics import Accuracy



  def train_step(engine, batch):
      
      
      

  trainer = Engine(train_step)


  evaluator = create_supervised_evaluator(model, metrics={"accuracy": Accuracy()})

  def validation():
      state = evaluator.run(validation_data_loader)
      
      print(trainer.state.epoch, state.metrics)


  trainer.add_event_handler(Events.EPOCH_COMPLETED, validation)


  trainer.run(training_data_loader, max_epochs=100)
  ```

  </details>



  The cool thing with handlers is that they offer unparalleled flexibility (compared to, for example, callbacks). Handlers can be any function: e.g. lambda, simple function, class method, etc. Thus, we do not require to inherit from an interface and override its abstract methods which could unnecessarily bulk up your code and its complexity.



  <details>
  <summary>
  Examples
  </summary>

  ```python
  trainer.add_event_handler(Events.STARTED, lambda _: print("Start training"))


  mydata = [1, 2, 3, 4]
  logger = ...

  def on_training_ended(data):
      print(f"Training is ended. mydata={data}")
      
      logger.info("Training is ended")


  trainer.add_event_handler(Events.COMPLETED, on_training_ended, mydata)

  trainer.add_event_handler(Events.COMPLETED, lambda engine: print(engine.state.times))

  @trainer.on(Events.ITERATION_COMPLETED)
  def log_something(engine):
      print(engine.state.output)
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  ```python

  @trainer.on(Events.EPOCH_COMPLETED(every=5))
  def run_validation():
      


  @trainer.on(Events.EPOCH_STARTED(once=20))
  def change_training_variable():
      


  @trainer.on(Events.ITERATION_COMPLETED(event_filter=first_x_iters))
  def log_gradients():
      
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  Events can be stacked together to enable multiple calls:

  ```python
  @trainer.on(Events.COMPLETED | Events.EPOCH_COMPLETED(every=10))
  def run_validation():
      
  ```

  </details>



  <details>
  <summary>
  Examples
  </summary>

  Custom events related to backward and optimizer step calls:

  ```python
  from ignite.engine import EventEnum


  class BackpropEvents(EventEnum):
      BACKWARD_STARTED = 'backward_started'
      BACKWARD_COMPLETED = 'backward_completed'
      OPTIM_STEP_COMPLETED = 'optim_step_completed'

  def update(engine, batch):
      
      loss = criterion(y_pred, y)
      engine.fire_event(BackpropEvents.BACKWARD_STARTED)
      loss.backward()
      engine.fire_event(BackpropEvents.BACKWARD_COMPLETED)
      optimizer.step()
      engine.fire_event(BackpropEvents.OPTIM_STEP_COMPLETED)
      

  trainer = Engine(update)
  trainer.register_events(*BackpropEvents)

  @trainer.on(BackpropEvents.BACKWARD_STARTED)
  def function_before_backprop(engine):
      
  ```

  - Complete snippet is found [here](https://pytorch.org/ignite/faq.html#creating-custom-events-based-on-forward-backward-pass).
  - Another use-case of custom events: [trainer for Truncated Backprop Through Time](https://pytorch.org/ignite/contrib/engines.html#ignite.contrib.engines.create_supervised_tbptt_trainer).

  </details>



  - [Metrics](https://pytorch.org/ignite/metrics.html#complete-list-of-metrics) for various tasks:
    Precision, Recall, Accuracy, Confusion Matrix, IoU etc, ~20 [regression metrics](https://pytorch.org/ignite/metrics.html#complete-list-of-metrics).

  - Users can also [compose their metrics](https://pytorch.org/ignite/metrics.html#metric-arithmetics) with ease from
    existing ones using arithmetic operations or torch methods.

  <details>
  <summary>
  Example
  </summary>

  ```python
  precision = Precision(average=False)
  recall = Recall(average=False)
  F1_per_class = (precision * recall * 2 / (precision + recall))
  F1_mean = F1_per_class.mean()  # torch mean method
  F1_mean.attach(engine, "F1")
  ```

  </details>

  <!-- ############################################################################################################### -->



  From [pip](https://pypi.org/project/pytorch-ignite/):

  ```bash
  pip install pytorch-ignite
  ```

  From [conda](https://anaconda.org/pytorch/ignite):

  ```bash
  conda install ignite -c pytorch
  ```

  From source:

  ```bash
  pip install git+https://github.com/pytorch/ignite
  ```



  From pip:

  ```bash
  pip install --pre pytorch-ignite
  ```

  From conda (this suggests to install [pytorch nightly release](https://anaconda.org/pytorch-nightly/pytorch) instead of stable
  version as dependency):

  ```bash
  conda install ignite -c pytorch-nightly
  ```





  Pull a pre-built docker image from [our Docker Hub](https://hub.docker.com/u/pytorchignite) and run it with docker v19.03+.

  ```bash
  docker run --gpus all -it -v $PWD:/workspace/project --network=host --shm-size 16G pytorchignite/base:latest /bin/bash
  ```

  <details>

  <summary>
  List of available pre-built images
  </summary>

  Base

  - `pytorchignite/base:latest`
  - `pytorchignite/apex:latest`
  - `pytorchignite/hvd-base:latest`
  - `pytorchignite/hvd-apex:latest`
  - `pytorchignite/msdp-apex:latest`

  Vision:

  - `pytorchignite/vision:latest`
  - `pytorchignite/hvd-vision:latest`
  - `pytorchignite/apex-vision:latest`
  - `pytorchignite/hvd-apex-vision:latest`
  - `pytorchignite/msdp-apex-vision:latest`

  NLP:

  - `pytorchignite/nlp:latest`
  - `pytorchignite/hvd-nlp:latest`
  - `pytorchignite/apex-nlp:latest`
  - `pytorchignite/hvd-apex-nlp:latest`
  - `pytorchignite/msdp-apex-nlp:latest`

  </details>

  For more details, see [here](docker).

  <!-- ############################################################################################################### -->



  Few pointers to get you started:

  - [Quick Start Guide: Essentials of getting a project up and running](https://pytorch-ignite.ai/tutorials/beginner/01-getting-started/)
  - [Concepts of the library: Engine, Events & Handlers, State, Metrics](https://pytorch-ignite.ai/concepts/)
  - Full-featured template examples (coming soon)

  <!-- ############################################################################################################### -->



  - Stable API documentation and an overview of the library: https://pytorch.org/ignite/
  - Development version API documentation: https://pytorch.org/ignite/master/
  - [FAQ](https://pytorch.org/ignite/faq.html),
    ["Questions on Github"](https://github.com/pytorch/ignite/issues?q=is%3Aissue+label%3Aquestion+) and
    ["Questions on Discuss.PyTorch"](https://discuss.pytorch.org/c/ignite).
  - [Project's Roadmap](https://github.com/pytorch/ignite/wiki/Roadmap)



  - [Distributed Training Made Easy with PyTorch-Ignite](https://labs.quansight.org/blog/2021/06/distributed-made-easy-with-ignite/)
  - [PyTorch Ecosystem Day 2021 Breakout session presentation](https://colab.research.google.com/drive/1qhUgWQ0N2U71IVShLpocyeY4AhlDCPRd)
  - [Tutorial blog post about PyTorch-Ignite](https://labs.quansight.org/blog/2020/09/pytorch-ignite/)
  - [8 Creators and Core Contributors Talk About Their Model Training Libraries From PyTorch Ecosystem](https://neptune.ai/blog/model-training-libraries-pytorch-ecosystem?utm_source=reddit&utm_medium=post&utm_campaign=blog-model-training-libraries-pytorch-ecosystem)
  - Ignite Posters from Pytorch Developer Conferences:
    - [2021](https://drive.google.com/file/d/1YXrkJIepPk_KltSG1ZfWRtA5IRgPFz_U)
    - [2019](https://drive.google.com/open?id=1bqIl-EM6GCCCoSixFZxhIbuF25F2qTZg)
    - [2018](https://drive.google.com/open?id=1_2vzBJ0KeCjGv1srojMHiJRvceSVbVR5)

  <!-- ############################################################################################################### -->





  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/TextCNN.ipynb) [Text Classification using Convolutional Neural
    Networks](https://github.com/pytorch/ignite/blob/master/examples/notebooks/TextCNN.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/VAE.ipynb) [Variational Auto
    Encoders](https://github.com/pytorch/ignite/blob/master/examples/notebooks/VAE.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FashionMNIST.ipynb) [Convolutional Neural Networks for Classifying Fashion-MNIST
    Dataset](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FashionMNIST.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_nvidia_apex.ipynb) [Training Cycle-GAN on Horses to
    Zebras with Nvidia/Apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_nvidia_apex.ipynb) - [ logs on W&B](https://app.wandb.ai/vfdev-5/ignite-cyclegan-apex)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_torch_cuda_amp.ipynb) [Another training Cycle-GAN on Horses to
    Zebras with Native Torch CUDA AMP](https://github.com/pytorch/ignite/blob/master/examples/notebooks/CycleGAN_with_torch_cuda_amp.ipynb) - [logs on W&B](https://app.wandb.ai/vfdev-5/ignite-cyclegan-torch-amp)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/EfficientNet_Cifar100_finetuning.ipynb) [Finetuning EfficientNet-B0 on
    CIFAR100](https://github.com/pytorch/ignite/blob/master/examples/notebooks/EfficientNet_Cifar100_finetuning.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar10_Ax_hyperparam_tuning.ipynb) [Hyperparameters tuning with
    Ax](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar10_Ax_hyperparam_tuning.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb) [Basic example of LR finder on
    MNIST](https://github.com/pytorch/ignite/blob/master/examples/notebooks/FastaiLRFinder_MNIST.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb) [Benchmark mixed precision training on Cifar100:
    torch.cuda.amp vs nvidia/apex](https://github.com/pytorch/ignite/blob/master/examples/notebooks/Cifar100_bench_amp.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb) [MNIST training on a single
    TPU](https://github.com/pytorch/ignite/blob/master/examples/notebooks/MNIST_on_TPU.ipynb)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1E9zJrptnLJ_PKhmaP5Vhb6DTVRvyrKHx) [CIFAR10 Training on multiple TPUs](https://github.com/pytorch/ignite/tree/master/examples/cifar10)
  - [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pytorch/ignite/blob/master/examples/notebooks/HandlersTimeProfiler_MNIST.ipynb) [Basic example of handlers
    time profiling on MNIST training example](https://github.com/pytorch/ignite/blob/master/examples/notebooks/HandlersTimeProfiler_MNIST.ipynb)



  Inspired by [torchvision/references](https://github.com/pytorch/vision/tree/master/references),
  we provide several reproducible baselines for vision tasks:

  - [ImageNet](examples/references/classification/imagenet) - logs on Ignite Trains server coming soon ...
  - [Pascal VOC2012](examples/references/segmentation/pascal_voc2012) - logs on Ignite Trains server coming soon ...

  Features:

  - Distributed training: native or horovod and using [PyTorch native AMP](https://pytorch.org/docs/stable/notes/amp_examples.html)



  The easiest way to create your training scripts with PyTorch-Ignite:

  - https://code-generator.pytorch-ignite.ai/

  <!-- ############################################################################################################### -->



  - [GitHub issues](https://github.com/pytorch/ignite/issues): questions, bug reports, feature requests, etc.

  - [Discuss.PyTorch](https://discuss.pytorch.org/c/ignite), category "Ignite".

  - [PyTorch-Ignite Discord Server](https://discord.gg/djZtm3EmKj): to chat with the community

  - [GitHub Discussions](https://github.com/pytorch/ignite/discussions): general library-related discussions, ideas, Q&A, etc.



  We have created a form for ["user feedback"](https://github.com/pytorch/ignite/issues/new/choose). We
  appreciate any type of feedback, and this is how we would like to see our
  community:

  - If you like the project and want to say thanks, this the right
    place.
  - If you do not like something, please, share it with us, and we can
    see how to improve it.

  Thank you!

  <!-- ############################################################################################################### -->



  Please see the [contribution guidelines](https://github.com/pytorch/ignite/blob/master/CONTRIBUTING.md) for more information.

  As always, PRs are welcome :)

  <!-- ############################################################################################################### -->



  <details>

  <summary>
  Research papers
  </summary>

  - [BatchBALD: Efficient and Diverse Batch Acquisition for Deep Bayesian Active Learning](https://github.com/BlackHC/BatchBALD)
  - [A Model to Search for Synthesizable Molecules](https://github.com/john-bradshaw/molecule-chef)
  - [Localised Generative Flows](https://github.com/jrmcornish/lgf)
  - [Extracting T Cell Function and Differentiation Characteristics from the Biomedical Literature](https://github.com/hammerlab/t-cell-relation-extraction)
  - [Variational Information Distillation for Knowledge Transfer](https://github.com/amzn/xfer/tree/master/var_info_distil)
  - [XPersona: Evaluating Multilingual Personalized Chatbot](https://github.com/HLTCHKUST/Xpersona)
  - [CNN-CASS: CNN for Classification of Coronary Artery Stenosis Score in MPR Images](https://github.com/ucuapps/CoronaryArteryStenosisScoreClassification)
  - [Bridging Text and Video: A Universal Multimodal Transformer for Video-Audio Scene-Aware Dialog](https://github.com/ictnlp/DSTC8-AVSD)
  - [Adversarial Decomposition of Text Representation](https://github.com/text-machine-lab/adversarial_decomposition)
  - [Uncertainty Estimation Using a Single Deep Deterministic Neural Network](https://github.com/y0ast/deterministic-uncertainty-quantification)
  - [DeepSphere: a graph-based spherical CNN](https://github.com/deepsphere/deepsphere-pytorch)
  - [Norm-in-Norm Loss with Faster Convergence and Better Performance for Image Quality Assessment](https://github.com/lidq92/LinearityIQA)
  - [Unified Quality Assessment of In-the-Wild Videos with Mixed Datasets Training](https://github.com/lidq92/MDTVSFA)
  - [Deep Signature Transforms](https://github.com/patrick-kidger/Deep-Signature-Transforms)
  - [Neural CDEs for Long Time-Series via the Log-ODE Method](https://github.com/jambo6/neuralCDEs-via-logODEs)
  - [Volumetric Grasping Network](https://github.com/ethz-asl/vgn)
  - [Mood Classification using Listening Data](https://github.com/fdlm/listening-moods)
  - [Deterministic Uncertainty Estimation (DUE)](https://github.com/y0ast/DUE)
  - [PyTorch-Hebbian: facilitating local learning in a deep learning framework](https://github.com/Joxis/pytorch-hebbian)
  - [Stochastic Weight Matrix-Based Regularization Methods for Deep Neural Networks](https://github.com/rpatrik96/lod-wmm-2019)
  - [Learning explanations that are hard to vary](https://github.com/gibipara92/learning-explanations-hard-to-vary)
  - [The role of disentanglement in generalisation](https://github.com/mmrl/disent-and-gen)
  - [A Probabilistic Programming Approach to Protein Structure Superposition](https://github.com/LysSanzMoreta/Theseus-PP)
  - [PadChest: A large chest x-ray image dataset with multi-label annotated reports](https://github.com/auriml/Rx-thorax-automatic-captioning)

  </details>

  <details>

  <summary>
  Blog articles, tutorials, books
  </summary>

  - [State-of-the-Art Conversational AI with Transfer Learning](https://github.com/huggingface/transfer-learning-conv-ai)
  - [Tutorial on Transfer Learning in NLP held at NAACL 2019](https://github.com/huggingface/naacl_transfer_learning_tutorial)
  - [Deep-Reinforcement-Learning-Hands-On-Second-Edition, published by Packt](https://github.com/PacktPublishing/Deep-Reinforcement-Learning-Hands-On-Second-Edition)
  - [Once Upon a Repository: How to Write Readable, Maintainable Code with PyTorch](https://towardsdatascience.com/once-upon-a-repository-how-to-write-readable-maintainable-code-with-pytorch-951f03f6a829)
  - [The Hero Rises: Build Your Own SSD](https://allegro.ai/blog/the-hero-rises-build-your-own-ssd/)
  - [Using Optuna to Optimize PyTorch Ignite Hyperparameters](https://medium.com/pytorch/using-optuna-to-optimize-pytorch-ignite-hyperparameters-626ffe6d4783)
  - [PyTorch Ignite - Classifying Tiny ImageNet with EfficientNet](https://towardsdatascience.com/pytorch-ignite-classifying-tiny-imagenet-with-efficientnet-e5b1768e5e8f)

  </details>

  <details>

  <summary>
  Toolkits
  </summary>

  - [Project MONAI - AI Toolkit for Healthcare Imaging](https://github.com/Project-MONAI/MONAI)
  - [DeepSeismic - Deep Learning for Seismic Imaging and Interpretation](https://github.com/microsoft/seismic-deeplearning)
  - [Nussl - a flexible, object-oriented Python audio source separation library](https://github.com/nussl/nussl)
  - [PyTorch Adapt - A fully featured and modular domain adaptation library](https://github.com/KevinMusgrave/pytorch-adapt)
  - [gnina-torch: PyTorch implementation of GNINA scoring function](https://github.com/RMeli/gnina-torch)

  </details>

  <details>

  <summary>
  Others
  </summary>

  - [Implementation of "Attention is All You Need" paper](https://github.com/akurniawan/pytorch-transformer)
  - [Implementation of DropBlock: A regularization method for convolutional networks in PyTorch](https://github.com/miguelvr/dropblock)
  - [Kaggle Kuzushiji Recognition: 2nd place solution](https://github.com/lopuhin/kaggle-kuzushiji-2019)
  - [Unsupervised Data Augmentation experiments in PyTorch](https://github.com/vfdev-5/UDA-pytorch)
  - [Hyperparameters tuning with Optuna](https://github.com/optuna/optuna-examples/blob/main/pytorch/pytorch_ignite_simple.py)
  - [Logging with ChainerUI](https://chainerui.readthedocs.io/en/latest/reference/module.html#external-library-support)
  - [FixMatch experiments in PyTorch and Ignite (CTA dataaug policy)](https://github.com/vfdev-5/FixMatch-pytorch)
  - [Kaggle Birdcall Identification Competition: 1st place solution](https://github.com/ryanwongsa/kaggle-birdsong-recognition)
  - [Logging with Aim - An open-source experiment tracker](https://aimstack.readthedocs.io/en/latest/quick_start/integrations.html#integration-with-pytorch-ignite)

  </details>

  See other projects at ["Used by"](https://github.com/pytorch/ignite/network/dependents?package_id=UGFja2FnZS02NzI5ODEwNA%3D%3D)

  If your project implements a paper, represents other use-cases not
  covered in our official tutorials, Kaggle competition's code, or just
  your code presents interesting results and uses Ignite. We would like to
  add your project to this list, so please send a PR with brief
  description of the project.

  <!-- ############################################################################################################### -->



  If you use PyTorch-Ignite in a scientific publication, we would appreciate citations to our project.

  ```
  @misc{pytorch-ignite,
    author = {V. Fomin and J. Anmol and S. Desroziers and J. Kriss and A. Tejani},
    title = {High-level library to help with training neural networks in PyTorch},
    year = {2020},
    publisher = {GitHub},
    journal = {GitHub repository},
    howpublished = {\url{https://github.com/pytorch/ignite}},
  }
  ```

  <!-- ############################################################################################################### -->



  PyTorch-Ignite is a [NumFOCUS Affiliated Project](https://www.numfocus.org/), operated and maintained by volunteers in the PyTorch community in their capacities as individuals
  (and not as representatives of their employers). See the ["About us"](https://pytorch-ignite.ai/about/community/#about-us)
  page for a list of core contributors. For usage questions and issues, please see the various channels
  [here](#communication). For all other questions and inquiries, please send an email
  to contact@pytorch-ignite.ai.


pkgId: 9531589321f6be44276d7c51c59e1198c766182968b45b43bb05f77aacf3d358
name: python-pytorch-lightning-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for pytorch-lightning
url: https://github.com/Lightning-AI/lightning
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytorch-lightning-2.4.0-1.src.rpm
location_href: Packages/python-pytorch-lightning-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="https://pl-public-data.s3.amazonaws.com/assets_lightning/pytorch-lightning.png" width="400px">

  **The lightweight PyTorch wrapper for high-performance AI research.
  Scale your models, not the boilerplate.**

  ______________________________________________________________________

  <p align="center">
    <a href="https://www.pytorchlightning.ai/">Website</a> •
    <a href="#key-features">Key Features</a> •
    <a href="#how-to-use">How To Use</a> •
    <a href="https://lightning.ai/docs/pytorch/stable/">Docs</a> •
    <a href="#examples">Examples</a> •
    <a href="#community">Community</a> •
    <a href="https://lightning.ai/">Lightning AI</a> •
    <a href="https://github.com/Lightning-AI/lightning/blob/master/LICENSE">License</a>
  </p>

  <!-- DO NOT ADD CONDA DOWNLOADS... README CHANGES MUST BE APPROVED BY EDEN OR WILL -->

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytorch-lightning)](https://pypi.org/project/pytorch-lightning/)
  [![PyPI Status](https://badge.fury.io/py/pytorch-lightning.svg)](https://badge.fury.io/py/pytorch-lightning)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/pytorch-lightning)](https://pepy.tech/project/pytorch-lightning)
  [![Conda](https://img.shields.io/conda/v/conda-forge/pytorch-lightning?label=conda&color=success)](https://anaconda.org/conda-forge/pytorch-lightning)
  [![DockerHub](https://img.shields.io/docker/pulls/pytorchlightning/pytorch_lightning.svg)](https://hub.docker.com/r/pytorchlightning/pytorch_lightning)
  [![codecov](https://codecov.io/gh/Lightning-AI/pytorch-lightning/graph/badge.svg?token=SmzX8mnKlA)](https://codecov.io/gh/Lightning-AI/pytorch-lightning)

  [![ReadTheDocs](https://readthedocs.org/projects/pytorch-lightning/badge/?version=2.4.0)](https://lightning.ai/docs/pytorch/stable/)[![Discord](https://img.shields.io/discord/1077906959069626439?style=plastic)](https://discord.gg/VptPCZkGNa)
  [![license](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/Lightning-AI/lightning/blob/master/LICENSE)

  <!--
  [![CodeFactor](https://www.codefactor.io/repository/github/Lightning-AI/lightning/badge)](https://www.codefactor.io/repository/github/Lightning-AI/lightning)
  -->

  </div>



  ______________________________________________________________________



  Lightning disentangles PyTorch code to decouple the science from the engineering.
  ![PT to PL](https://lightning.ai/docs/pytorch/stable/_static/images/general/pl_quick_start_full_compressed.gif)

  ______________________________________________________________________



  Lightning structures PyTorch code with these principles:

  <div align="center">
    <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/philosophies.jpg" max-height="250px">
  </div>

  Lightning forces the following structure to your code which makes it reusable and shareable:

  - Research code (the LightningModule).
  - Engineering code (you delete, and is handled by the Trainer).
  - Non-essential research code (logging, etc... this goes in Callbacks).
  - Data (use PyTorch DataLoaders or organize them into a LightningDataModule).

  Once you do this, you can train on multiple-GPUs, TPUs, CPUs, HPUs and even in 16-bit precision without changing your code!

  [Get started in just 15 minutes](https://lightning.ai/docs/pytorch/latest/starter/introduction.html)

  ______________________________________________________________________



  Lightning is rigorously tested across multiple CPUs, GPUs and TPUs and against major Python and PyTorch versions.

  <details>
    <summary>Current build statuses</summary>

  <center>

  |       System / PyTorch ver.        |                                                    1.12                                                     | 1.13                                                                                                        | 2.0                                                                                                         | 2.1                                                                                                               |
  | :--------------------------------: | :---------------------------------------------------------------------------------------------------------: | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
  |        Linux py3.9 \[GPUs\]        |                                                                                                             |                                                                                                             |                                                                                                             | ![Build Status](https://dev.azure.com/Lightning-AI/lightning/_apis/build/status%2Fpytorch-lightning%20%28GPUs%29) |
  |        Linux py3.9 \[TPUs\]        |                                                                                                             |                                                                                                             | ![Test PyTorch - TPU](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml/badge.svg)  |                                                                                                                   |
  |  Linux (multiple Python versions)  | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)       |
  |   OSX (multiple Python versions)   | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)       |
  | Windows (multiple Python versions) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg) | ![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)       |

  </center>
  </details>

  ______________________________________________________________________





  Simple installation from PyPI

  ```bash
  pip install pytorch-lightning
  ```

  <!--  -->



  ```python
  import os
  import torch
  from torch import nn
  import torch.nn.functional as F
  from torchvision.datasets import MNIST
  from torch.utils.data import DataLoader, random_split
  from torchvision import transforms
  import pytorch_lightning as pl
  ```



  A LightningModule defines a full *system* (ie: a GAN, autoencoder, BERT or a simple Image Classifier).

  ```python
  class LitAutoEncoder(pl.LightningModule):
      def __init__(self):
          super().__init__()
          self.encoder = nn.Sequential(nn.Linear(28 * 28, 128), nn.ReLU(), nn.Linear(128, 3))
          self.decoder = nn.Sequential(nn.Linear(3, 128), nn.ReLU(), nn.Linear(128, 28 * 28))

      def forward(self, x):
          
          embedding = self.encoder(x)
          return embedding

      def training_step(self, batch, batch_idx):
          
          x, _ = batch
          x = x.view(x.size(0), -1)
          z = self.encoder(x)
          x_hat = self.decoder(z)
          loss = F.mse_loss(x_hat, x)
          self.log("train_loss", loss)
          return loss

      def configure_optimizers(self):
          optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
          return optimizer
  ```

  **Note: Training_step defines the training loop. Forward defines how the LightningModule behaves during inference/prediction.**



  ```python
  dataset = MNIST(os.getcwd(), download=True, transform=transforms.ToTensor())
  train, val = random_split(dataset, [55000, 5000])

  autoencoder = LitAutoEncoder()
  trainer = pl.Trainer()
  trainer.fit(autoencoder, DataLoader(train), DataLoader(val))
  ```



  Lightning has over [40+ advanced features](https://lightning.ai/docs/pytorch/stable/common/trainer.html#trainer-flags) designed for professional AI research at scale.

  Here are some examples:

  <div align="center">
    <img src="https://pl-bolts-doc-images.s3.us-east-2.amazonaws.com/features_2.jpg" max-height="600px">
  </div>

  <details>
    <summary>Highlighted feature code snippets</summary>

  ```python


  trainer = Trainer(max_epochs=1, accelerator="gpu", devices=8)


  trainer = Trainer(max_epochs=1, accelerator="gpu", devices=8, num_nodes=32)
  ```

  <summary>Train on TPUs without code changes</summary>

  ```python

  trainer = Trainer(accelerator="tpu", devices=8)
  ```

  <summary>16-bit precision</summary>

  ```python

  trainer = Trainer(precision=16)
  ```

  <summary>Experiment managers</summary>

  ```python
  from pytorch_lightning import loggers


  trainer = Trainer(logger=TensorBoardLogger("logs/"))


  trainer = Trainer(logger=loggers.WandbLogger())


  trainer = Trainer(logger=loggers.CometLogger())


  trainer = Trainer(logger=loggers.MLFlowLogger())


  trainer = Trainer(logger=loggers.NeptuneLogger())


  ```

  <summary>EarlyStopping</summary>

  ```python
  es = EarlyStopping(monitor="val_loss")
  trainer = Trainer(callbacks=[es])
  ```

  <summary>Checkpointing</summary>

  ```python
  checkpointing = ModelCheckpoint(monitor="val_loss")
  trainer = Trainer(callbacks=[checkpointing])
  ```

  <summary>Export to torchscript (JIT) (production use)</summary>

  ```python

  autoencoder = LitAutoEncoder()
  torch.jit.save(autoencoder.to_torchscript(), "model.pt")
  ```

  <summary>Export to ONNX (production use)</summary>

  ```python
  autoencoder = LitAutoEncoder()
  input_sample = torch.randn((1, 64))
  with tempfile.NamedTemporaryFile(suffix=".onnx", delete=False) as tmpfile:
      autoencoder.to_onnx(tmpfile.name, input_sample, export_params=True)
  ```

  </details>



  For complex/professional level work, you have optional full control of the optimizers.

  ```python
  class LitAutoEncoder(pl.LightningModule):
      def __init__(self):
          super().__init__()
          self.automatic_optimization = False

      def training_step(self, batch, batch_idx):
          
          opt_a, opt_b = self.optimizers(use_pl_optimizer=True)

          loss_a = ...
          self.manual_backward(loss_a, opt_a)
          opt_a.step()
          opt_a.zero_grad()

          loss_b = ...
          self.manual_backward(loss_b, opt_b, retain_graph=True)
          self.manual_backward(loss_b, opt_b)
          opt_b.step()
          opt_b.zero_grad()
  ```

  ______________________________________________________________________



  - Models become hardware agnostic
  - Code is clear to read because engineering code is abstracted away
  - Easier to reproduce
  - Make fewer mistakes because lightning handles the tricky engineering
  - Keeps all the flexibility (LightningModules are still PyTorch modules), but removes a ton of boilerplate
  - Lightning has dozens of integrations with popular machine learning tools.
  - [Tested rigorously with every new PR](https://github.com/Lightning-AI/lightning/tree/master/tests). We test every combination of PyTorch and Python supported versions, every OS, multi GPUs and even TPUs.
  - Minimal running speed overhead (about 300 ms per epoch compared with pure PyTorch).

  ______________________________________________________________________





  - [CPC transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#cpc-transforms)
  - [Moco v2 transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#moco-v2-transforms)
  - [SimCLR transforms](https://lightning-bolts.readthedocs.io/en/stable/transforms/self_supervised.html#simclr-transforms)



  - [GPT-2](https://lightning-bolts.readthedocs.io/en/stable/models/convolutional.html#gpt-2)
  - [UNet](https://lightning-bolts.readthedocs.io/en/stable/models/convolutional.html#unet)



  - [DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#dqn-loss)
  - [Double DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#double-dqn-loss)
  - [Per DQN Loss](https://lightning-bolts.readthedocs.io/en/stable/losses.html#per-dqn-loss)



  - [Basic GAN](https://lightning-bolts.readthedocs.io/en/stable/models/gans.html#basic-gan)
  - [DCGAN](https://lightning-bolts.readthedocs.io/en/stable/models/gans.html#dcgan)



  - [Logistic Regression](https://lightning-bolts.readthedocs.io/en/stable/models/classic_ml.html#logistic-regression)
  - [Linear Regression](https://lightning-bolts.readthedocs.io/en/stable/models/classic_ml.html#linear-regression)

  ______________________________________________________________________



  The PyTorch Lightning community is maintained by

  - [10+ core contributors](https://lightning.ai/docs/pytorch/stable/community/governance.html) who are all a mix of professional engineers, Research Scientists, and Ph.D. students from top AI labs.
  - 680+ active community contributors.

  Want to help us build Lightning and reduce boilerplate for thousands of researchers? [Learn how to make your first contribution here](https://devblog.pytorchlightning.ai/quick-contribution-guide-86d977171b3a)

  PyTorch Lightning is also part of the [PyTorch ecosystem](https://pytorch.org/ecosystem/) which requires projects to have solid testing, documentation and support.



  If you have any questions please:

  1. [Read the docs](https://lightning.ai/docs/pytorch/stable).
  1. [Search through existing Discussions](https://github.com/Lightning-AI/lightning/discussions), or [add a new question](https://github.com/Lightning-AI/lightning/discussions/new)
  1. [Join our Discord community](https://discord.gg/VptPCZkGNa).


pkgId: d7ad587ff16a1a720804721823600507c50e3e4b8ede96eb1c106ab3d124e1e2
name: python-pytorch360convert-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for pytorch360convert
url: https://github.com/ProGamerGov/pytorch360convert
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytorch360convert-0.1.0-1.src.rpm
location_href: Packages/python-pytorch360convert-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This PyTorch-based library provides powerful and differentiable image transformation utilities for converting between different panoramic image formats:

  - **Equirectangular (360°) Images**
  - **Cubemap Representations**
  - **Perspective Projections**

  Built as an improved PyTorch implementation of the original [py360convert](https://github.com/sunset1995/py360convert) project, this library offers flexible, CPU & GPU-accelerated functions.


  <div align="left">
   <img src="https://github.com/ProGamerGov/pytorch360convert/blob/main/examples/output_equirectangular.jpg?raw=true" width="710px">
  </div>

  * Equirectangular format


  <div align="left">
   <img src="https://github.com/ProGamerGov/pytorch360convert/blob/main/examples/output_cubic.jpg?raw=true" width="710px">
  </div>

  * Cubemap 'dice' format




  - Python 3.7+
  - PyTorch




  ```bash
  pip install torch
  ```

  Clone the repository:

  ```bash
  git clone https://github.com/ProGamerGov/pytorch360convert.git
  cd pytorch360convert
  pip install .
  ```




  - Lossless conversion between image formats.
  - Supports different cubemap input formats (horizon, list, dict, dice).
  - Configurable sampling modes (bilinear, nearest).
  - CPU and torch.float16 support.
  - GPU acceleration.
  - Differentiable transformations for deep learning pipelines.







  First we'll setup some helper functions:

  ```bash
  pip install torchvision pillow
  ```


  ```python
  import torch
  from torchvision.transforms import ToTensor, ToPILImage
  from PIL import Image

  def load_image_to_tensor(image_path: str) -> torch.Tensor:
      """Load an image as a PyTorch tensor."""
      return ToTensor()(Image.open(image_path).convert('RGB'))

  def save_tensor_as_image(tensor: torch.Tensor, save_path: str) -> None:
      """Save a PyTorch tensor as an image."""
      ToPILImage()(tensor).save(save_path)

  ```



  Coverting equirectangular images into cubemaps is easy. For simplicitly, we'll use the 'dice' format, which places all cube faces into a single 4x3 grid image.

  ```python
  from pytorch360convert import e2c


  equi_image = load_image_to_tensor("360_panorama.jpg")


  cubemap = e2c(
      equi_image,                   # CHW format
      face_w=1024,                  # Width of each cube face
      mode='bilinear',              # Sampling interpolation
      cube_format='dice'            # Output cubemap layout
  )


  save_tensor_as_image(cubemap, "cubemap.jpg")
  ```



  We can also convert cubemaps into equirectangular images, like so. Note that we use the same cubemap we created above and the same cubemap format used to make it.

  ```python
  from pytorch360convert import c2e


  equi_image = load_image_to_tensor("cubemap.jpg")


  equirectangular = c2e(
      cubemap,              # Cubemap tensor(s)
      h=2048,               # Output height
      w=4096,               # Output width
      mode='bilinear',      # Sampling interpolation
      cube_format='dice'    # Input cubemap layout
  )

  save_tensor_as_image(equirectangular, "equirectangular.jpg")
  ```



  ```python
  from pytorch360convert import e2p


  perspective_view = e2p(
      equi_image,                   # Equirectangular image
      fov_deg=(90, 60),             # Horizontal and vertical FOV
      u_deg=45,                     # Horizontal rotation
      v_deg=15,                     # Vertical rotation
      out_hw=(720, 1280),           # Output image dimensions
      mode='bilinear'               # Sampling interpolation
  )

  save_tensor_as_image(perspective_view, "perspective.jpg")
  ```





  Converts an equirectangular image to a cubemap projection.

  - **Parameters**:
    - `e_img` (torch.Tensor): Equirectangular CHW image tensor.
    - `face_w` (int, optional): Cube face width. Default: 256.
    - `mode` (str, optional): Sampling interpolation mode. Options are 'bilinear' and 'nearest'. Default: 'bilinear'
    - `cube_format` (str, optional): Input cubemap format. Options are 'dict', 'list', 'horizon', and 'dice'. Default: 'dice'
    - `channels_first` (bool, optional): Input cubemap channel format (CHW or HWC). Defaults to the PyTorch standard of 'True'

  - **Returns**: Cubemap representation of the input image as a tensor, list of tensors, or dict or tensors.


  Converts a cubemap projection to an equirectangular image.

  - **Parameters**:
    - `cubemap` (torch.Tensor): Cubemap image tensor, list of tensors, or dict of tensors. Note that tensors should be in the shape of: 'CHW'.
    - `h` (int): Output image height.
    - `w` (int): Output image width.
    - `mode` (str, optional): Sampling interpolation mode. Options are 'bilinear' and 'nearest'. Default: 'bilinear'
    - `cube_format` (str, optional): Input cubemap format. Options are 'dict', 'list', 'horizon', and 'dice'. Default: 'dice'
    - `channels_first` (bool, optional): Input cubemap channel format (CHW or HWC). Defaults to the PyTorch standard of 'True'

  - **Returns**: Equirectangular projection of the input cubemap as a tensor.


  Extracts a perspective view from an equirectangular image.

  - **Parameters**:
    - `e_img` (torch.Tensor): Equirectangular CHW image tensor.
    - `fov_deg` (float or tuple): Field of view in degrees. If using a tuple, adhere to the following format: (h_fov_deg, v_fov_deg)
    - `u_deg` (float): Horizontal viewing angle in range [-pi, pi]. (- Left / + Right).
    - `v_deg` (float): Vertical viewing angle in range [-pi/2, pi/2]. (- Down/ + Up).
    - `out_hw` (tuple): Output image dimensions in the shape of '(height, width)'.
    - `in_rot_deg` (float, optional): Inplane rotation angle. Default: 0
    - `mode` (str, optional): Sampling interpolation mode. Options are 'bilinear' and 'nearest'. Default: 'bilinear'
    - `channels_first` (bool, optional): Input cubemap channel format (CHW or HWC). Defaults to the PyTorch standard of 'True'

  - **Returns**: Perspective view of the equirectangular image as a tensor.




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




  If you use this library in your research or project, please refer to the included CITATION.cff file or cite it as follows:


  ```bibtex
  @misc{egan2024pytorch360convert,
    title={PyTorch 360° Image Conversion Toolkit},
    author={Egan, Ben},
    year={2024},
    publisher={GitHub},
    howpublished={\url{https://github.com/ProGamerGov/pytorch360convert}}
  }
  ```


  ```
  Egan, B. (2024). PyTorch 360° Image Conversion Toolkit [Computer software]. GitHub. https://github.com/ProGamerGov/pytorch360convert
  ```


pkgId: 2eba17b05847a005b01eb3fb2ab5f69778676595d14b620073e1bb047a820da9
name: python-pytorch360convert-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for pytorch360convert
url: https://github.com/ProGamerGov/pytorch360convert
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytorch360convert-0.1.2-1.src.rpm
location_href: Packages/python-pytorch360convert-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/pytorch360convert)](https://pypi.org/project/pytorch360convert/)




  This PyTorch-based library provides powerful and differentiable image transformation utilities for converting between different panoramic image formats:

  - **Equirectangular (360°) Images**
  - **Cubemap Representations**
  - **Perspective Projections**

  Built as an improved PyTorch implementation of the original [py360convert](https://github.com/sunset1995/py360convert) project, this library offers flexible, CPU & GPU-accelerated functions.


  <div align="left">
   <img src="https://github.com/ProGamerGov/pytorch360convert/blob/main/examples/output_equirectangular.jpg?raw=true" width="710px">
  </div>

  * Equirectangular format


  <div align="left">
   <img src="https://github.com/ProGamerGov/pytorch360convert/blob/main/examples/output_cubic.jpg?raw=true" width="710px">
  </div>

  * Cubemap 'dice' format




  - Python 3.7+
  - PyTorch




  You can easily install the library using pip:

  ```bash
  pip install pytorch360convert
  ```

  Or you can install it from source like this:

  ```bash
  pip install torch
  ```

  Clone the repository:

  ```bash
  git clone https://github.com/ProGamerGov/pytorch360convert.git
  cd pytorch360convert
  pip install .
  ```




  - Lossless conversion between image formats.
  - Supports different cubemap input formats (horizon, list, dict, dice).
  - Configurable sampling modes (bilinear, nearest).
  - CPU and torch.float16 support.
  - GPU acceleration.
  - Differentiable transformations for deep learning pipelines.







  First we'll setup some helper functions:

  ```bash
  pip install torchvision pillow
  ```


  ```python
  import torch
  from torchvision.transforms import ToTensor, ToPILImage
  from PIL import Image

  def load_image_to_tensor(image_path: str) -> torch.Tensor:
      """Load an image as a PyTorch tensor."""
      return ToTensor()(Image.open(image_path).convert('RGB'))

  def save_tensor_as_image(tensor: torch.Tensor, save_path: str) -> None:
      """Save a PyTorch tensor as an image."""
      ToPILImage()(tensor).save(save_path)

  ```



  Coverting equirectangular images into cubemaps is easy. For simplicitly, we'll use the 'dice' format, which places all cube faces into a single 4x3 grid image.

  ```python
  from pytorch360convert import e2c


  equi_image = load_image_to_tensor("360_panorama.jpg")


  cubemap = e2c(
      equi_image,                   # CHW format
      face_w=1024,                  # Width of each cube face
      mode='bilinear',              # Sampling interpolation
      cube_format='dice'            # Output cubemap layout
  )


  save_tensor_as_image(cubemap, "cubemap.jpg")
  ```



  We can also convert cubemaps into equirectangular images, like so. Note that we use the same cubemap we created above and the same cubemap format used to make it.

  ```python
  from pytorch360convert import c2e


  equi_image = load_image_to_tensor("cubemap.jpg")


  equirectangular = c2e(
      cubemap,              # Cubemap tensor(s)
      h=2048,               # Output height
      w=4096,               # Output width
      mode='bilinear',      # Sampling interpolation
      cube_format='dice'    # Input cubemap layout
  )

  save_tensor_as_image(equirectangular, "equirectangular.jpg")
  ```



  ```python
  from pytorch360convert import e2p


  perspective_view = e2p(
      equi_image,                   # Equirectangular image
      fov_deg=(90, 60),             # Horizontal and vertical FOV
      u_deg=45,                     # Horizontal rotation
      v_deg=15,                     # Vertical rotation
      out_hw=(720, 1280),           # Output image dimensions
      mode='bilinear'               # Sampling interpolation
  )

  save_tensor_as_image(perspective_view, "perspective.jpg")
  ```





  Converts an equirectangular image to a cubemap projection.

  - **Parameters**:
    - `e_img` (torch.Tensor): Equirectangular CHW image tensor.
    - `face_w` (int, optional): Cube face width. Default: `256`.
    - `mode` (str, optional): Sampling interpolation mode. Options are `bilinear` and `nearest`. Default: `bilinear`
    - `cube_format` (str, optional): The desired output cubemap format. Options are `dict`, `list`, `horizon`, `stack`, and `dice`. Default: `dice`
      - `stack`: Stack of 6 faces (torch.Tensor), in the order of:  `['Front', 'Right', 'Back', 'Left', 'Top', 'Bottom']`.
      - `list`: List of 6 faces (List[torch.Tensor]), in the order of: `['Front', 'Right', 'Back', 'Left', 'Top', 'Bottom']`.
      - `dict`: Dictionary with keys pointing to face tensors: (Dict[str, torch.Tensor]). Keys are: `['Front', 'Right', 'Back', 'Left', 'Top', 'Bottom']`
      - `dice`: A cubemap in a `dice` layout (`torch.Tensor`).
      - `horizon`: A cubemap in a `horizon` layout (`torch.Tensor`).
    - `channels_first` (bool, optional): Input cubemap channel format (CHW or HWC). Defaults to the PyTorch CHW standard of `True`.

  - **Returns**: Cubemap representation of the input image as a tensor, list of tensors, or dict or tensors.


  Converts a cubemap projection to an equirectangular image.

  - **Parameters**:
    - `cubemap` (torch.Tensor, list of torch.Tensor, or dict of torch.Tensor): Cubemap image tensor, list of tensors, or dict of tensors. Note that tensors should be in the shape of: `CHW`. Inputs should match the corresponding `cube_format`.
    - `h` (int, optional): Output image height. If set to None, `<cube_face_width> * 2` will be used. Default: `None`.
    - `w` (int, optional): Output image width. If set to None, `<cube_face_width> * 4` will be used. Default: `None`.
    - `mode` (str, optional): Sampling interpolation mode. Options are `bilinear` and `nearest`. Default: `bilinear`
    - `cube_format` (str, optional): Input cubemap format. Options are `dict`, `list`, `horizon`, `stack`, and `dice`. Default: `dice`
      - `stack`: Stack of 6 faces (torch.Tensor), in the order of:  `['Front', 'Right', 'Back', 'Left', 'Top', 'Bottom']`.
      - `list`: List of 6 faces (List[torch.Tensor]), in the order of: `['Front', 'Right', 'Back', 'Left', 'Top', 'Bottom']`.
      - `dict`: Dictionary with keys pointing to face tensors: (Dict[str, torch.Tensor]). Keys are expected to be: `['Front', 'Right', 'Back', 'Left', 'Top', 'Bottom']`
      - `dice`: A cubemap in a `dice` layout (`torch.Tensor`).
      - `horizon`: A cubemap in a `horizon` layout (`torch.Tensor`).
    - `channels_first` (bool, optional): Input cubemap channel format (CHW or HWC). Defaults to the PyTorch CHW standard of `True`.

  - **Returns**: Equirectangular projection of the input cubemap as a tensor.


  Extracts a perspective view from an equirectangular image.

  - **Parameters**:
    - `e_img` (torch.Tensor): Equirectangular CHW image tensor.
    - `fov_deg` (float or tuple): Field of view in degrees. If using a tuple, adhere to the following format: (h_fov_deg, v_fov_deg)
    - `u_deg` (float): Horizontal viewing angle in range [-pi, pi]. (- Left / + Right).
    - `v_deg` (float): Vertical viewing angle in range [-pi/2, pi/2]. (- Down/ + Up).
    - `out_hw` (tuple): Output image dimensions in the shape of `(height, width)`.
    - `in_rot_deg` (float, optional): Inplane rotation angle. Default: 0
    - `mode` (str, optional): Sampling interpolation mode. Options are `bilinear` and `nearest`. Default: `bilinear`
    - `channels_first` (bool, optional): Input cubemap channel format (CHW or HWC). Defaults to the PyTorch CHW standard of `True`.

  - **Returns**: Perspective view of the equirectangular image as a tensor.




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




  If you use this library in your research or project, please refer to the included CITATION.cff file or cite it as follows:


  ```bibtex
  @misc{egan2024pytorch360convert,
    title={PyTorch 360° Image Conversion Toolkit},
    author={Egan, Ben},
    year={2024},
    publisher={GitHub},
    howpublished={\url{https://github.com/ProGamerGov/pytorch360convert}}
  }
  ```


  ```
  Egan, B. (2024). PyTorch 360° Image Conversion Toolkit [Computer software]. GitHub. https://github.com/ProGamerGov/pytorch360convert
  ```


pkgId: c771fab304cd2ad6ce8b600c81712fc1e3bb27dcf139a18dd7b774d1c6598e4a
name: python-pytortilla-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for pytortilla
url: https://github.com/tacofoundation/tortilla-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytortilla-0.1.2-1.src.rpm
location_href: Packages/python-pytortilla-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/user-attachments/assets/16d84f7d-dee7-40d9-9990-d0f31bd1b028" width="20%" style="float: right; margin-left: 10px;">





  TODO



  Read the full specification [here](TODO).




  You can install the Tortilla reader using `pip`:

  ```bash
  pip install pytortilla
  ```




  The `tortilla` reader only support four methods: `create`, `edit`, `load`, and `compile`.



  Create a Tortilla file from a list of local files.

  ```python
  import pytortilla

  files = ["path/to/local/A.tif", "path/to/local/B.tif", "path/to/local/C.tif"]

  tortilla_file = pytortilla.create(
      files=files,
      output= "path/to/local/demo.tortilla"
  )
  ```



  Load local and remote Tortilla files. For remote files, the server must support the HTTP `Range` header method.


  ```python
  import pytortilla




  tortilla_file = pytortilla.load(
      file="path/to/local/demo.tortilla"
  )


  tortilla_file = pytortilla.load(
      file="https://huggingface.co/datasets/tacofoundation/example/resolve/main/soy_una.tortilla"
  )


  ```



  Create small subsets of the Tortilla file. For instance, if you have a Tortilla file with 1000 items, you can create a new Tortilla file with only the first 100 items.

  ```python
  import pytortilla


  metadata = pytortilla.load(file="https://huggingface.co/datasets/tacofoundation/example/resolve/main/soy_una.tortilla")



  subset = pytortilla.compile(
      dataset=metadata.iloc[40:50],
      output="soy_una_feliz.tortilla"
  )
  ```


pkgId: 615809be3f6709b0038ffd236a59e4a360dc109f4cd9ced9a08d50f7e9f318df
name: python-pytransform3d-help
arch: noarch
version: 3.10.0
epoch: 0
release: 1
summary: Development documents and examples for pytransform3d
url: https://github.com/dfki-ric/pytransform3d
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytransform3d-3.10.0-1.src.rpm
location_href: Packages/python-pytransform3d-help-3.10.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/logo.png" />

  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/dfki-ric/pytransform3d/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/dfki-ric/pytransform3d/tree/main)
  [![codecov](https://codecov.io/gh/dfki-ric/pytransform3d/branch/main/graph/badge.svg?token=jB10RM3Ujj)](https://codecov.io/gh/dfki-ric/pytransform3d)
  [![Paper DOI](http://joss.theoj.org/papers/10.21105/joss.01159/status.svg)](https://doi.org/10.21105/joss.01159)
  [![Release DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.2553450.svg)](https://doi.org/10.5281/zenodo.2553450)



  A Python library for transformations in three dimensions.

  pytransform3d offers...

  * operations like concatenation and inversion for most common representations
    of rotation (orientation) and translation (position)
  * conversions between those representations
  * clear documentation of transformation conventions
  * tight coupling with matplotlib to quickly visualize (or animate)
    transformations
  * the TransformManager which manages complex chains of transformations
    (with export to graph visualization as PNG, additionally requires pydot)
  * the TransformEditor which allows to modify transformations graphically
    (additionally requires PyQt4/5)
  * the UrdfTransformManager which is able to load transformations from
    [URDF](https://wiki.ros.org/urdf) files (additionally requires lxml)
  * a matplotlib-like interface to Open3D's visualizer to display and animate
    geometries and transformations (additionally requires Open3D)

  pytransform3d is used in various domains, for example:

  * specifying motions of a robot
  * learning robot movements from human demonstration
  * sensor fusion for human pose estimation
  * collision detection for robots

  The API documentation can be found
  [here](https://dfki-ric.github.io/pytransform3d/).

  I gave a talk at EuroSciPy 2023 about pytransform3d. Slides are available
  [here](https://github.com/AlexanderFabisch/pytransform3d_euroscipy2023/).



  Use pip to install the package from PyPI:

  ```bash
  pip install 'pytransform3d[all]'
  ```

  or conda:

  ```bash
  conda install -c conda-forge pytransform3d
  ```

  Take a look at the
  [installation instructions](https://dfki-ric.github.io/pytransform3d/install.html)
  in the documentation for more details.



  The following plots and visualizations have been generated with pytransform3d.
  The code for most examples can be found in
  [the documentation](https://dfki-ric.github.io/pytransform3d/_auto_examples/index.html).

  Left: [Nao robot](https://www.softbankrobotics.com/emea/en/nao) with URDF
  from [Bullet3](https://github.com/bulletphysics/bullet3).
  Right: [Kuka iiwa](https://www.kuka.com/en-de/products/robot-systems/industrial-robots/lbr-iiwa).
  The animation is based on pytransform3d's visualization interface to
  [Open3D](http://www.open3d.org/).

  <img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/animation_nao.gif" height=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/animation_kuka.gif" height=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/animation_dynamics.gif" height=200px/>

  Visualizations based on [Open3D](http://www.open3d.org/).

  <img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/photogrammetry.png" height=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/kuka_trajectories.png" height=200px/>

  Various plots based on Matplotlib.

  <img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/example_plot_box.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/cylinders.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/paper/plot_urdf.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/transform_manager_mesh.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/accelerate_cylinder.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/example_plot_screw.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/rotations_axis_angle.png" width=200px/><img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/doc/source/_static/concatenate_uncertain_transforms.png" width=200px/>

  Transformation editor based on Qt.

  <img src="https://raw.githubusercontent.com/dfki-ric/pytransform3d/main/paper/app_transformation_editor.png" height=300px/>



  This is just one simple example. You can find more examples in the subfolder
  `examples/`.

  ```python
  import numpy as np
  import matplotlib.pyplot as plt
  from pytransform3d import rotations as pr
  from pytransform3d import transformations as pt
  from pytransform3d.transform_manager import TransformManager


  rng = np.random.default_rng(0)

  ee2robot = pt.transform_from_pq(
      np.hstack((np.array([0.4, -0.3, 0.5]),
                 pr.random_quaternion(rng))))
  cam2robot = pt.transform_from_pq(
      np.hstack((np.array([0.0, 0.0, 0.8]), pr.q_id)))
  object2cam = pt.transform_from(
      pr.active_matrix_from_intrinsic_euler_xyz(np.array([0.0, 0.0, -0.5])),
      np.array([0.5, 0.1, 0.1]))

  tm = TransformManager()
  tm.add_transform("end-effector", "robot", ee2robot)
  tm.add_transform("camera", "robot", cam2robot)
  tm.add_transform("object", "camera", object2cam)

  ee2object = tm.get_transform("end-effector", "object")

  ax = tm.plot_frames_in("robot", s=0.1)
  ax.set_xlim((-0.25, 0.75))
  ax.set_ylim((-0.5, 0.5))
  ax.set_zlim((0.0, 1.0))
  plt.show()
  ```

  ![output](https://dfki-ric.github.io/pytransform3d/_images/sphx_glr_plot_transform_manager_001.png)



  The API documentation can be found
  [here](https://dfki-ric.github.io/pytransform3d/).

  The documentation can be found in the directory `doc`.
  To build the documentation, run e.g. (on linux):

  ```bash
  cd doc
  make html
  ```

  The HTML documentation is now located at `doc/build/html/index.html`.
  Execute the following command in the main folder of the repository
  to install the dependencies:

  ```bash
  pip install -e '.[doc]'
  ```



  You can use pytest to run the tests of this project in the root directory:

  ```bash
  pytest
  ```

  A coverage report will be located at `htmlcov/index.html`.
  Note that you have to install `pytest` to run the tests and `pytest-cov` to
  obtain the code coverage report.



  If you wish to report bugs, please use the
  [issue tracker](https://github.com/dfki-ric/pytransform3d/issues) at
  Github. If you would like to contribute to pytransform3d, just open an issue
  or a [pull request](https://github.com/dfki-ric/pytransform3d/pulls).
  The target branch for pull requests is the develop branch.
  The development branch will be merged to main for new releases.
  If you have questions about the software, you should ask them in the
  [discussion section](https://github.com/dfki-ric/pytransform3d/discussions).

  The recommended workflow to add a new feature, add documentation, or fix a bug
  is the following:

  * Push your changes to a branch (e.g. `feature/x`, `doc/y`, or `fix/z`) of your
    fork of the pytransform3d repository.
  * Open a pull request to the latest development branch. There is usually an
    open merge request from the latest development branch to the main branch.
  * When the latest development branch is merged to the main branch, a new
    release will be made.

  Note that there is a
  [checklist](https://github.com/dfki-ric/pytransform3d/wiki#checklist-for-new-features)
  for new features.

  It is forbidden to directly push to the main branch. Each new version
  has its own development branch from which a pull request will be opened to the
  main branch. Only the maintainer of the software is allowed to merge a
  development branch to the main branch.



  The library is distributed under the
  [3-Clause BSD license](https://github.com/dfki-ric/pytransform3d/blob/main/LICENSE).



  If you use pytransform3d for a scientific publication, I would appreciate
  citation of the following paper:

  Fabisch, A. (2019). pytransform3d: 3D Transformations for Python.
  Journal of Open Source Software, 4(33), 1159,
  [![Paper DOI](http://joss.theoj.org/papers/10.21105/joss.01159/status.svg)](https://doi.org/10.21105/joss.01159)

  Bibtex entry:

  ```bibtex
  @article{Fabisch2019,
    doi = {10.21105/joss.01159},
    url = {https://doi.org/10.21105/joss.01159},
    year = {2019},
    publisher = {The Open Journal},
    volume = {4},
    number = {33},
    pages = {1159},
    author = {Alexander Fabisch},
    title = {pytransform3d: 3D Transformations for Python},
    journal = {Journal of Open Source Software}
  }
  ```


pkgId: 75aaa452845461fc541356257f8d0df6119322cb9e31f9fd94b33d3acf5e1de2
name: python-pytrinamic-help
arch: noarch
version: 0.2.13
epoch: 0
release: 1
summary: Development documents and examples for pytrinamic
url: https://github.com/trinamic/PyTrinamic
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pytrinamic-0.2.13-1.src.rpm
location_href: Packages/python-pytrinamic-help-0.2.13-1.noarch.rpm
checksum_type: sha256
description:
  PyTrinamic is a Python package to set up and control TRINAMIC modules, evaluation boards and ICs via serial, USB or CAN interfaces.

  The package is intended to automate tasks that are typically done manually with TRINAMICs [TMCL-IDE](https://www.analog.com/en/resources/evaluation-hardware-and-software/motor-motion-control-software/tmcl-ide.html).



  Use pip to install PyTrinamic.

  ```
  pip install pytrinamic
  ```



  Please have a look at the [code examples on GitHub](https://github.com/analogdevicesinc/PyTrinamic/tree/master/examples).



  Version 0.2.0 of PyTrinamic introduces several changes to the API. For those who want to convert code that uses an older version of PyTrinamic, we wrote a short [migration guide](https://github.com/analogdevicesinc/PyTrinamic/blob/master/docs/migration_guide.md).

  All previous versions of PyTrinamic will still be available on PyPI and can be installed via: `pip install pytrinamic==0.1.27`.



  Pull requests are welcome. For any major changes or questions regarding implementation, please open an issue to ask or discuss first.



  PyTrinamic is licensed under the MIT License.


pkgId: bb17fcb305d11cabd3647e5368306521835e59eec1d85187359608253b20cb4b
name: python-pyuow-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for pyuow
url: https://github.com/S-M-A-D/PyUoW
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyuow-0.6.1-1.src.rpm
location_href: Packages/python-pyuow-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  1. [Installation](#installation)
  2. [Usage examples](#usage-examples)
     - [Simple unit](#simple-unit-usage-example)
     - [Unit of Work manager](#example-with-unit-of-work-manager)
     - [SqlAlchemy based Unit of Work manager](#example-with-sqlalchemy-based-unit-of-work-manager)
  3. [Async compatibility](#async-compatibility)


pkgId: e833e330622f52bbabf88314925c5e5df7c64762674aeefecd6cc02c1c9af8e8
name: python-pyupgrade-help
arch: noarch
version: 3.19.1
epoch: 0
release: 1
summary: Development documents and examples for pyupgrade
url: https://github.com/asottile/pyupgrade
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyupgrade-3.19.1-1.src.rpm
location_href: Packages/python-pyupgrade-help-3.19.1-1.noarch.rpm
checksum_type: sha256
description:
  A tool (and pre-commit hook) to automatically upgrade syntax for newer
  versions of the language.

  ```bash
  pip install pyupgrade
  ```

  See [pre-commit](https://github.com/pre-commit/pre-commit) for instructions
  Sample `.pre-commit-config.yaml`:
  ```yaml
  -   repo: https://github.com/asottile/pyupgrade
      rev: v3.19.1
      hooks:
      -   id: pyupgrade
  ```


  ```diff
  -set(())
  +set()
  -set([])
  +set()
  -set((1,))
  +{1}
  -set((1, 2))
  +{1, 2}
  -set([1, 2])
  +{1, 2}
  -set(x for x in y)
  +{x for x in y}
  -set([x for x in y])
  +{x for x in y}
  ```

  ```diff
  -dict((a, b) for a, b in y)
  +{a: b for a, b in y}
  -dict([(a, b) for a, b in y])
  +{a: b for a, b in y}
  ```

  ```diff
  -defaultdict(lambda: [])
  +defaultdict(list)
  -defaultdict(lambda: list())
  +defaultdict(list)
  -defaultdict(lambda: {})
  +defaultdict(dict)
  -defaultdict(lambda: dict())
  +defaultdict(dict)
  -defaultdict(lambda: ())
  +defaultdict(tuple)
  -defaultdict(lambda: tuple())
  +defaultdict(tuple)
  -defaultdict(lambda: set())
  +defaultdict(set)
  -defaultdict(lambda: 0)
  +defaultdict(int)
  -defaultdict(lambda: 0.0)
  +defaultdict(float)
  -defaultdict(lambda: 0j)
  +defaultdict(complex)
  -defaultdict(lambda: '')
  +defaultdict(str)
  ```

  ```diff
  -'{0} {1}'.format(1, 2)
  +'{} {}'.format(1, 2)
  -'{0}' '{1}'.format(1, 2)
  +'{}' '{}'.format(1, 2)
  ```

  Availability:
  - Unless `--keep-percent-format` is passed.
  ```diff
  -'%s %s' % (a, b)
  +'{} {}'.format(a, b)
  -'%r %2f' % (a, b)
  +'{!r} {:2f}'.format(a, b)
  -'s s' % {'a': 1, 'b': 2}
  +'{a} {b}'.format(a=1, b=2)
  ```

  ```diff
  -u'foo'
  +'foo'
  -u"foo"
  +'foo'
  -u'''foo'''
  +'''foo'''
  ```

  ```diff
   
  -'\d'
  +r'\d'
   
  -'\n\d'
  +'\n\\d'
  -u'\d'
  +r'\d'
   
  -'\N'
  +r'\N'
  ```

  In python3.8+, comparison to literals becomes a `SyntaxWarning` as the success
  of those comparisons is implementation specific (due to common object caching).
  ```diff
  -x is 5
  +x == 5
  -x is not 5
  +x != 5
  -x is 'foo'
  +x == 'foo'
  ```

  ```diff
  -'foo'.encode()
  +b'foo'
  -'foo'.encode('ascii')
  +b'foo'
  -'foo'.encode('utf-8')
  +b'foo'
  -u'foo'.encode()
  +b'foo'
  -'\xa0'.encode('latin1')
  +b'\xa0'
  ```

  A fix for [python-modernize/python-modernize#178]
  ```diff
   
   print(())
   
   print((1,))
   
   sum((i for i in range(3)), [])
   
  -print(("foo"))
  +print("foo")
  ```
  [python-modernize/python-modernize#178]: https://github.com/python-modernize/python-modernize/issues/178

  ```diff
  -isinstance(x, (int, int))
  +isinstance(x, int)
  -issubclass(y, (str, str))
  +issubclass(y, str)
   try:
       raises()
  -except (Error1, Error1, Error2):
  +except (Error1, Error2):
       pass
  ```

  Rewrites [deprecated unittest method aliases](https://docs.python.org/3/library/unittest.html#deprecated-aliases) to their non-deprecated forms.
  ```diff
   from unittest import TestCase
   class MyTests(TestCase):
       def test_something(self):
  -        self.failUnlessEqual(1, 1)
  +        self.assertEqual(1, 1)
  -        self.assertEquals(1, 1)
  +        self.assertEqual(1, 1)
  ```

  ```diff
   class C(Base):
       def f(self):
  -        super(C, self).f()
  +        super().f()
  ```


  ```diff
  -class C(object): pass
  +class C: pass
  -class C(B, object): pass
  +class C(B): pass
  ```

  ```diff
   class C:
  -    __metaclass__ = type
  ```

  ```diff
  -str()
  +''
  -str("foo")
  +"foo"
  ```

  ```diff
  -"foo".encode("utf-8")
  +"foo".encode()
  ```

  as of [PEP 3120], the default encoding for python source is UTF-8
  ```diff
  -# coding: utf-8
   x = 1
  ```
  [PEP 3120]: https://www.python.org/dev/peps/pep-3120/

  Availability:
  - by default removes `nested_scopes`, `generators`, `with_statement`,
    `absolute_import`, `division`, `print_function`, `unicode_literals`
  - `--py37-plus` will also remove `generator_stop`
  ```diff
  -from __future__ import with_statement
  ```

  ```diff
  -from io import open
  -from six.moves import map
  -from builtins import object  # python-future
  ```

  Availability:
  - `--py36-plus` (and others) will replace imports
  see also [reorder-python-imports](https://github.com/asottile/reorder_python_imports#removing--rewriting-obsolete-six-imports)
  some examples:
  ```diff
  -from collections import deque, Mapping
  +from collections import deque
  +from collections.abc import Mapping
  ```
  ```diff
  -from typing import Sequence
  +from collections.abc import Sequence
  ```
  ```diff
  -from typing_extensions import Concatenate
  +from typing import Concatenate
  ```

  Availability:
  - [Unless `--keep-mock` is passed on the commandline](https://github.com/asottile/pyupgrade/issues/314).
  ```diff
  -from mock import patch
  +from unittest.mock import patch
  ```

  ```diff
   def f():
  -    for x in y:
  -        yield x
  +    yield from y
  -    for a, b in c:
  -        yield (a, b)
  +    yield from c
  ```

  ```diff
   import sys
  -if sys.version_info < (3,):  # also understands `six.PY2` (and `not`), `six.PY3` (and `not`)
  -    print('py2')
  -else:
  -    print('py3')
  +print('py3')
  ```
  Availability:
  - `--py36-plus` will remove Python <= 3.5 only blocks
  - `--py37-plus` will remove Python <= 3.6 only blocks
  - so on and so forth
  ```diff
   
   import sys
  -if sys.version_info < (3, 6):
  -    print('py3.5')
  -else:
  -    print('py3.6+')
  +print('py3.6+')
  -if sys.version_info <= (3, 5):
  -    print('py3.5')
  -else:
  -    print('py3.6+')
  +print('py3.6+')
  -if sys.version_info >= (3, 6):
  -    print('py3.6+')
  -else:
  -    print('py3.5')
  +print('py3.6+')
  ```
  Note that `if` blocks without an `else` will not be rewritten as it could introduce a syntax error.

  ```diff
  -six.text_type
  +str
  -six.binary_type
  +bytes
  -six.class_types
  +(type,)
  -six.string_types
  +(str,)
  -six.integer_types
  +(int,)
  -six.unichr
  +chr
  -six.iterbytes
  +iter
  -six.print_(...)
  +print(...)
  -six.exec_(c, g, l)
  +exec(c, g, l)
  -six.advance_iterator(it)
  +next(it)
  -six.next(it)
  +next(it)
  -six.callable(x)
  +callable(x)
  -six.moves.range(x)
  +range(x)
  -six.moves.xrange(x)
  +range(x)
  -from six import text_type
  -text_type
  +str
  -@six.python_2_unicode_compatible
   class C:
       def __str__(self):
           return u'C()'
  -class C(six.Iterator): pass
  +class C: pass
  -class C(six.with_metaclass(M, B)): pass
  +class C(B, metaclass=M): pass
  -@six.add_metaclass(M)
  -class C(B): pass
  +class C(B, metaclass=M): pass
  -isinstance(..., six.class_types)
  +isinstance(..., type)
  -issubclass(..., six.integer_types)
  +issubclass(..., int)
  -isinstance(..., six.string_types)
  +isinstance(..., str)
  -six.b('...')
  +b'...'
  -six.u('...')
  +'...'
  -six.byte2int(bs)
  +bs[0]
  -six.indexbytes(bs, i)
  +bs[i]
  -six.int2byte(i)
  +bytes((i,))
  -six.iteritems(dct)
  +dct.items()
  -six.iterkeys(dct)
  +dct.keys()
  -six.itervalues(dct)
  +dct.values()
  -next(six.iteritems(dct))
  +next(iter(dct.items()))
  -next(six.iterkeys(dct))
  +next(iter(dct.keys()))
  -next(six.itervalues(dct))
  +next(iter(dct.values()))
  -six.viewitems(dct)
  +dct.items()
  -six.viewkeys(dct)
  +dct.keys()
  -six.viewvalues(dct)
  +dct.values()
  -six.create_unbound_method(fn, cls)
  +fn
  -six.get_unbound_function(meth)
  +meth
  -six.get_method_function(meth)
  +meth.__func__
  -six.get_method_self(meth)
  +meth.__self__
  -six.get_function_closure(fn)
  +fn.__closure__
  -six.get_function_code(fn)
  +fn.__code__
  -six.get_function_defaults(fn)
  +fn.__defaults__
  -six.get_function_globals(fn)
  +fn.__globals__
  -six.raise_from(exc, exc_from)
  +raise exc from exc_from
  -six.reraise(tp, exc, tb)
  +raise exc.with_traceback(tb)
  -six.reraise(*sys.exc_info())
  +raise
  -six.assertCountEqual(self, a1, a2)
  +self.assertCountEqual(a1, a2)
  -six.assertRaisesRegex(self, e, r, fn)
  +self.assertRaisesRegex(e, r, fn)
  -six.assertRegex(self, s, r)
  +self.assertRegex(s, r)
   
  -six.ensure_binary('...')
  +b'...'
  -six.ensure_str('...')
  +'...'
  -six.ensure_text('...')
  +'...'
  ```

  ```diff
  -with io.open('f.txt') as f:
  +with open('f.txt') as f:
  ```

  ```diff
  -open("foo", "U")
  +open("foo")
  -open("foo", "Ur")
  +open("foo")
  -open("foo", "Ub")
  +open("foo", "rb")
  -open("foo", "rUb")
  +open("foo", "rb")
  -open("foo", "r")
  +open("foo")
  -open("foo", "rt")
  +open("foo")
  -open("f", "r", encoding="UTF-8")
  +open("f", encoding="UTF-8")
  -open("f", "wt")
  +open("f", "w")
  ```

  ```diff
   
   
   
   
   
   
   def throw():
  -    raise EnvironmentError('boom')
  +    raise OSError('boom')
   def catch():
       try:
           throw()
  -    except EnvironmentError:
  +    except OSError:
           handle_error()
  ```

  Availability:
  - `--py310-plus` for `socket.timeout`
  - `--py311-plus` for `asyncio.TimeoutError`
  ```diff
   def throw(a):
       if a:
  -        raise asyncio.TimeoutError('boom')
  +        raise TimeoutError('boom')
       else:
  -        raise socket.timeout('boom')
  +        raise TimeoutError('boom')
   def catch(a):
       try:
           throw(a)
  -    except (asyncio.TimeoutError, socket.timeout):
  +    except TimeoutError:
           handle_error()
  ```

  ```diff
  -def f(x: Text) -> None:
  +def f(x: str) -> None:
  ```

  ```diff
  -foo, bar, baz = [fn(x) for x in items]
  +foo, bar, baz = (fn(x) for x in items)
  ```

  ```diff
  -import xml.etree.cElementTree as ET
  +import xml.etree.ElementTree as ET
  -from xml.etree.cElementTree import XML
  +from xml.etree.ElementTree import XML
  ```

  ```diff
  -type('')
  +str
  -type(b'')
  +bytes
  -type(0)
  +int
  -type(0.)
  +float
  ```

  Availability:
  - `--py36-plus` is passed on the commandline.
  ```diff
  -NT = typing.NamedTuple('NT', [('a', int), ('b', Tuple[str, ...])])
  +class NT(typing.NamedTuple):
  +    a: int
  +    b: Tuple[str, ...]
  -D1 = typing.TypedDict('D1', a=int, b=str)
  +class D1(typing.TypedDict):
  +    a: int
  +    b: str
  -D2 = typing.TypedDict('D2', {'a': int, 'b': str})
  +class D2(typing.TypedDict):
  +    a: int
  +    b: str
  ```

  Availability:
  - `--py36-plus` is passed on the commandline.
  ```diff
  -'{foo} {bar}'.format(foo=foo, bar=bar)
  +f'{foo} {bar}'
  -'{} {}'.format(foo, bar)
  +f'{foo} {bar}'
  -'{} {}'.format(foo.bar, baz.womp)
  +f'{foo.bar} {baz.womp}'
  -'{} {}'.format(f(), g())
  +f'{f()} {g()}'
  -'{x}'.format(**locals())
  +f'{x}'
  ```
  _note_: `pyupgrade` is intentionally timid and will not create an f-string
  if it would make the expression longer or if the substitution parameters are
  sufficiently complicated (as this can decrease readability).

  Availability:
  - `--py37-plus` is passed on the commandline.
  ```diff
  -output = subprocess.run(['foo'], universal_newlines=True)
  +output = subprocess.run(['foo'], text=True)
  ```

  Availability:
  - `--py37-plus` is passed on the commandline.
  ```diff
  -output = subprocess.run(['foo'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  +output = subprocess.run(['foo'], capture_output=True)
  ```

  Availability:
  - `--py38-plus` is passed on the commandline.
  ```diff
   import functools
  -@functools.lru_cache()
  +@functools.lru_cache
   def expensive():
  ```

  Availability:
  - `--py38-plus` is passed on the commandline.
  ```diff
  -' '.join(shlex.quote(arg) for arg in cmd)
  +shlex.join(cmd)
  ```

  Availability:
  - `--py39-plus` is passed on the commandline.
  ```diff
   import functools
  -@functools.lru_cache(maxsize=None)
  +@functools.cache
   def expensive():
  ```

  Availability:
  - File imports `from __future__ import annotations`
      - Unless `--keep-runtime-typing` is passed on the commandline.
  - `--py39-plus` is passed on the commandline.
  ```diff
  -def f(x: List[str]) -> None:
  +def f(x: list[str]) -> None:
  ```

  Availability:
  - File imports `from __future__ import annotations`
      - Unless `--keep-runtime-typing` is passed on the commandline.
  - `--py310-plus` is passed on the commandline.
  ```diff
  -def f() -> Optional[str]:
  +def f() -> str | None:
  ```
  ```diff
  -def f() -> Union[int, str]:
  +def f() -> int | str:
  ```

  Availability:
  - File imports `from __future__ import annotations`
      - Unless `--keep-runtime-typing` is passed on the commandline.
  - `--py313-plus` is passed on the commandline.
  ```diff
  -def f() -> Generator[int, None, None]:
  +def f() -> Generator[int]:
       yield 1
  ```
  ```diff
  -async def f() -> AsyncGenerator[int, None]:
  +async def f() -> AsyncGenerator[int]:
       yield 1
  ```

  Availability:
  - File imports `from __future__ import annotations`
  ```diff
  -def f(x: 'queue.Queue[int]') -> C:
  +def f(x: queue.Queue[int]) -> C:
  ```

  Availability:
  - `--py311-plus` is passed on the commandline.
  ```diff
   import datetime
  -datetime.timezone.utc
  +datetime.UTC
  ```


pkgId: 326c213a49646db195697d23649e2b38df592f15baa0d00a54c8005385bb3896
name: python-pyustc-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for pyustc
url: https://github.com/USTC-XeF2/pyustc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyustc-0.0.2-1.src.rpm
location_href: Packages/python-pyustc-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/pyustc.svg)](https://pypi.python.org/pypi/pyustc)
  ![code size](https://img.shields.io/github/languages/code-size/USTC-XeF2/pyustc)
  ![last commit](https://img.shields.io/github/last-commit/USTC-XeF2/pyustc)
  [![commits since last release](https://img.shields.io/github/commits-since/USTC-XeF2/pyustc/latest.svg)](https://github.com/USTC-XeF2/pyustc/releases)

  A Python package that allows for quick use of USTC network services.



  ```bash
  pip install pyustc
  ```

  If you want to use the default validate code processer, you need to install `pytesseract` as well:

  ```bash
  pip install pytesseract
  ```

  And you also need to install `tesseract` on your system from [here](https://github.com/tesseract-ocr/tesseract/releases/latest).



  The project is based on the Unified Identity Authentication System of USTC, here is an example of how to login:

  ```python
  from pyustc import Passport

  passport = Passport()
  passport.login('username', 'password')
  ```

  If you have already logged in, you can save the token so that you don't need to login again next time:

  ```python
  passport.save_token('token.json')
  ```

  And then you can login next time with the saved token

  ```python
  passport = Passport('token.json')
  ```

  After you have logged in, you can use the `passport` object to access other services. For example, you can get your personal information:

  ```python
  info = passport.get_info()
  ```

  Or you can use the `EduSystem` to get your course table:

  ```python
  from pyustc import EduSystem

  es = EduSystem(passport)
  table = es.get_course_table()
  for course in table.courses:
      print(course)
  ```



  [MIT](https://github.com/USTC-XeF2/pyustc/blob/main/LICENSE)


pkgId: 6241f9e9d456cf796b70492d37484ba146ccc7f2ceb21fbdccce38864d0a736b
name: python-pyutplugins-help
arch: noarch
version: 3.1.1
epoch: 0
release: 1
summary: Development documents and examples for pyutplugins
url: https://pypi.org/project/pyutplugins/
rpm_license: GNU AFFERO GENERAL PUBLIC LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyutplugins-3.1.1-1.src.rpm
location_href: Packages/python-pyutplugins-help-3.1.1-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://github.com/hasii2011/code-ally-basic/blob/master/developer/agpl-license-web-badge-version-2-256x48.png "AGPL")

  [![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)
  [![CircleCI](https://dl.circleci.com/status-badge/img/gh/hasii2011/pyutplugins/tree/master.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/hasii2011/pyutplugins/tree/master)
  [![PyPI version](https://badge.fury.io/py/pyutplugins.svg)](https://badge.fury.io/py/pyutplugins)

  [![CircleCI](https://dl.circleci.com/insights-snapshot/gh/hasii2011/pyutplugins/master/main/badge.svg?window=30d)](https://app.circleci.com/insights/github/hasii2011/pyutplugins/workflows/main/overview?branch=master&reporting-window=last-30-days&insights-snapshot=true)



  **TBD**



  **TBD**


  This project uses [buildlackey](https://github.com/hasii2011/buildlackey) for day to day development builds

  ___

  Written by <a href="mailto:email@humberto.a.sanchez.ii@gmail.com?subject=Hello Humberto">Humberto A. Sanchez II</a>  (C) 2023

  ___

  I am concerned about GitHub's Copilot project

  ![](https://github.com/hasii2011/code-ally-basic/blob/master/developer/SillyGitHub.png)

  I urge you to read about the
  [Give up GitHub](https://GiveUpGitHub.org) campaign from
  [the Software Freedom Conservancy](https://sfconservancy.org).

  While I do not advocate for all the issues listed there I do not like that
  a company like Microsoft may profit from open source projects.

  I continue to use GitHub because it offers the services I need for free.  But, I continue
  to monitor their terms of service.

  Any use of this project's code by GitHub Copilot, past or present, is done
  without my permission.  I do not consent to GitHub's use of this project's
  code in Copilot.


pkgId: 6908ee8dfb52249a84690816848a47f8086f47abfefca4dc11d9643f2f8afa5f
name: python-pyvd-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for pyvd
url: https://pypi.org/project/pyvd/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyvd-0.4.4-1.src.rpm
location_href: Packages/python-pyvd-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  `pyvd` calculates birth and mortality rates from UN WPP projections for a single country.



  0. Install
  ```bash
  pip install pyvd
  ```
  1. In a python terminal or script, calculate demography (e.g., birth rates by year)
  ```python
  pop_input = make_pop_dat('IND')
  year_vec = pop_input[0, :] - pyvd.constants.BASE_YEAR
  year_init = pyvd.constants.BASE_YEAR - pyvd.constants.BASE_YEAR
  pop_mat = pop_input[1:, :] + 0.1
  pop_init = [np.interp(year_init, year_vec, pop_mat[idx, :])
              for idx in range(pop_mat.shape[0])]
  vd_tup = demog_vd_calc(year_vec, year_init, pop_mat, pop_init)
  ```


  You can learn about the data [here](https://population.un.org/wpp/). We combine both the retrospective (past) and projection (future) estimate, using the medium variant for the projects.


  - Subnational estimates

rpm_license:
  MIT License  Copyright (c) 2024 Katherine Rosenfeld  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: b50984f7c4604715e53c420f222843ed3c7cac78a3a7cb2de528a0f5e8023497
name: python-pyven-help
arch: noarch
version: 100
epoch: 0
release: 1
summary: Development documents and examples for pyven
url: https://pypi.org/project/pyven/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyven-100-1.src.rpm
location_href: Packages/python-pyven-help-100-1.noarch.rpm
checksum_type: sha256
description:
  Manage development of multiple Python projects




  Build a Docker image with automatic tag.


  Run project using a suitable venv from the pool.


  Pin requires to their minimum allowed versions.


  Generate setuptools files for a project.arid project.


  Release project to PyPI, with manylinux wheels as needed.


  Show all XXX/TODO/FIXME comments in project.


  Run project unit tests and more, also suitable for CI.


  Check last release can be installed from PyPI and its tests still pass, for use by CI.


pkgId: f1738bc7416995ecf31f5327d86a2cca3753f4d44942f1151b087c37dce52e5d
name: python-pyvichan-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for pyvichan
url: http://github.com/bibanon/pyvichan
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyvichan-0.4.4-1.src.rpm
location_href: Packages/python-pyvichan-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  The Bibliotheca Anonoma's **complete Python Wrapper for the Vichan API.**
  Uses requests, respects if-modified-since headers on updating threads.
  Caches thread objects. Fun stuff.
  An absolute must if you want to interface with or scrape from 8chan or other vichan-based imageboards/textboards,
  using a Python script._
  `Hosted Documentation <http://py8chan.readthedocs.org/en/latest/index.html>`_
  `Github Repository <https://github.com/bibanon/pyvichan>`_
  You can install this library `straight from
  PyPi <https://pypi.python.org/pypi/pyvichan>`_ with::
      pip install pyvichan
  **Getting Help**
  If you want help, or you have some trouble using this library, our primary IRC channel
  is `#bibanon on irc.rizon.net <http://qchat2.rizon.net/?channels=bibanon>`_. Simply head
  in there and talk to dan or antonizoon. Otherwise, you can put a issue on our `Github
  Issue Tracker <https://github.com/bibanon/pyvichan>`_ and we'll respond as soon as

rpm_license:
  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE Version 2, December 2004  Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>  Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed.  DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. You just DO WHAT THE FUCK YOU WANT TO.


pkgId: 0110fe5ad89e505d9f36b40a2352d0484e8c0cb471d3969018d0fa78752a74ab
name: python-pyvlasiator-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for pyvlasiator
url: https://pypi.org/project/pyvlasiator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyvlasiator-0.1.4-1.src.rpm
location_href: Packages/python-pyvlasiator-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://badge.fury.io/py/pyvlasiator">
      <img src="https://badge.fury.io/py/pyvlasiator.svg" alt="PyPI version" height="18">
    </a>
    <a href="https://github.com/henry2004y/pyvlasiator/actions">
      <img src="https://github.com/henry2004y/pyvlasiator/actions/workflows/CI.yml/badge.svg">
    </a>
    <a href="https://henry2004y.github.io/pyvlasiator/">
      <img src="https://img.shields.io/badge/docs-dev-blue">
    </a>
    <a href="LICENSE">
      <img src="https://img.shields.io/badge/license-MIT-blue">
    </a>
    <a href="https://app.codecov.io/gh/henry2004y/pyvlasiator/">
      <img src="https://img.shields.io/codecov/c/github/henry2004y/pyvlasiator">
    </a>
  </p>

  Lightweight Python package for processing Vlasiator data.



  `pyvlasiator` can be installed via

  ```bash
  python -m pip install pyvlasiator
  ```



  `pyvlasiator` can be used to process VLSV files generated from Vlasiator.

  ```python
  from pyvlasiator.vlsv import Vlsv

  file = "test.vlsv"
  meta = Vlsv(file)
  ```

  Plotting is supported via Matplotlib. For more detailed usage, please refer to the [documentation](https://henry2004y.github.io/pyvlasiator/).



  `pyvlasiator` was created by Hongyang Zhou. It is licensed under the terms of the MIT license.


pkgId: 6a84fd0a597747e1dabaa30ccdcd04985110283ad72d5cd07ee6ad61e90586a8
name: python-pywa-help
arch: noarch
version: 2.4.0
epoch: 0
release: 1
summary: Development documents and examples for pywa
url: https://pypi.org/project/pywa/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywa-2.4.0-1.src.rpm
location_href: Packages/python-pywa-help-2.4.0-1.noarch.rpm
checksum_type: sha256
description:
  > [Get Started](https://pywa.readthedocs.io/en/latest/content/getting-started.html)
  • [WhatsApp Client](https://pywa.readthedocs.io/en/latest/content/client/overview.html)
  • [Handlers](https://pywa.readthedocs.io/en/latest/content/handlers/overview.html)
  • [Listeners](https://pywa.readthedocs.io/en/latest/content/listeners/overview.html)
  • [Filters](https://pywa.readthedocs.io/en/latest/content/filters/overview.html)
  • [Updates](https://pywa.readthedocs.io/en/latest/content/updates/overview.html)
  • [Flows](https://pywa.readthedocs.io/en/latest/content/flows/overview.html)


pkgId: 0d484c42210de2f847c81fa8ac24e8038772125e740af10579aaba19f9bcea12
name: python-pywatemsedem-help
arch: noarch
version: 0.0.1a9
epoch: 0
release: 1
summary: Development documents and examples for pywatemsedem
url: https://pypi.org/project/pywatemsedem/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywatemsedem-0.0.1a9-1.src.rpm
location_href: Packages/python-pywatemsedem-help-0.0.1a9-1.noarch.rpm
checksum_type: sha256
description:
  The pywatemsedem package is a Python wrapper for.
  `WaTEM/SEDEM <https://watem-sedem.github.io/watem-sedem/>`_.
  The aim of the pywatemsedem package is to:
   - Automate GIS IO processing.
   - Provide tools to interact with WaTEM/SEDEM.
   - Run WaTEM/SEDEM
  The package is implemented in Python and best used with the tutorial
  notebooks available on this page.


pkgId: 909b5049afbef4d4af1e48d8dd3b3f550858852cb18604d479dc5bba544e81c0
name: python-pywatershed-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for pywatershed
url: https://pypi.org/project/pywatershed/
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywatershed-2.0.0-1.src.rpm
location_href: Packages/python-pywatershed-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![ci-badge](https://github.com/ec-usgs/pywatershed/workflows/CI/badge.svg?branch=develop)](https://github.com/ec-usgs/pywatershed/actions?query=workflow%3ACI)
  [![codecov-badge](https://codecov.io/gh/ec-usgs/pywatershed/branch/main/graph/badge.svg)](https://codecov.io/gh/ec-usgs/pywatershed)
  [![Documentation Status](https://readthedocs.org/projects/pywatershed/badge/?version=latest)](https://pywatershed.readthedocs.io/en/latest/?badge=latest)
  [![asv](http://img.shields.io/badge/benchmarked%20by-asv-green.svg?style=flat)](https://github.com/ec-usgs/pywatershed)
  [![Formatted with Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  [![Available on pypi](https://img.shields.io/pypi/v/pywatershed.svg)](https://pypi.python.org/pypi/pywatershed)
  [![PyPI Status](https://img.shields.io/pypi/status/pywatershed.svg)](https://pypi.python.org/pypi/pywatershed)
  [![PyPI Versions](https://img.shields.io/pypi/pyversions/pywatershed.svg)](https://pypi.python.org/pypi/pywatershed)

  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/pywatershed/badges/version.svg)](https://anaconda.org/conda-forge/pywatershed)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/pywatershed/badges/platforms.svg)](https://anaconda.org/conda-forge/pywatershed)

  [![DOI:10.5066/P13EWPEV](https://img.shields.io/badge/DOI-10.5066/P13EWPEV-b4a9fe.svg)](https://doi.org/10.5066/P13EWPEV)

  [![WholeTale](https://raw.githubusercontent.com/whole-tale/wt-design-docs/master/badges/wholetale-explore.svg)](https://dashboard.wholetale.org/run/64ae29e8a887f48b9f173678?tab=metadata)


  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
  **Table of Contents**

  - [About](#about)
  - [Installation](#installation)
  - [Getting started / Example notebooks](#getting-started--example-notebooks)
  - [Community engagement](#community-engagement)
  - [How to Cite](#how-to-cite)
  - [Disclaimer](#disclaimer)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->



  Welcome to the pywatershed repository!

  Pywatershed is Python package for simulating hydrologic processes motivated by
  the need to modernize important, legacy hydrologic models at the USGS,
  particularly the
  [Precipitation-Runoff Modeling System](https://www.usgs.gov/software/precipitation-runoff-modeling-system-prms)
  (PRMS, Markstrom et al., 2015) and its role in
  [GSFLOW](https://www.usgs.gov/software/gsflow-coupled-groundwater-and-surface-water-flow-model>)
  (Markstrom et al., 2008).
  The goal of modernization is to make these legacy models more flexible as process
  representations, to support testing of alternative hydrologic process
  conceptualizations, and to facilitate the incorporation of cutting edge
  modeling techniques and data sources. Pywatershed is a place for experimentation
  with software design, process representation, and data fusion in the context
  of well-established hydrologic process modeling.

  For more information on the goals and status of pywatershed, please see the [pywatershed docs](https://pywatershed.readthedocs.io/).




  `pywatershed` uses Python 3.10 or 3.11.

  The `pywatershed` package is [available on
  PyPI](https://pypi.org/project/pywatershed/) but installation of all
  dependencies sets (lint, test, optional, doc, and all) may not be reliable on
  all platforms.

  The `pywatershed` package is [available on
  conda-forge](https://anaconda.org/conda-forge/pywatershed). The installation
  is the quickest way to get up and running by provides only the minimal set of
  dependencies (not including Jupyter nor all packages needed for running the
  example notebooks, also not suitable for development purposes).

  We recommend the following installation procedures to get fully-functional
  environments for running `pywatershed` and its example notebooks. We strongly
  recommend using [Mamba](https://mamba.readthedocs.io/en/latest/)to first
  instal dependencies from the `environment_y_jupyter.yml` file in the
  repository before installing `pywatershed` itself. Mamba will be much faster
  than Ananconda (but the conda command could also be used).

  If you wish to use the stable release, you will use `main` in place of
  `<branch>` in the following commands. If you want to follow development, you'll
  use `develop` instead.

  Without using `git` (directly), you may:
  ```
  curl -L -O https://raw.githubusercontent.com/EC-USGS/pywatershed/<branch>/environment_w_jupyter.yml
  mamba env create -f environment_w_jupyter.yml
  conda activate pws
  pip install git+https://github.com/EC-USGS/pywatershed.git@<branch>
  ```

  Or to use `git` and to be able to develop:

  ```
  git clone https://github.com/EC-USGS/pywatershed.git
  cd pywatershed
  mamba env create -f environment_w_jupyter.yml
  activate pws
  pip install -e .
  ```

  (If you want to name the environment other than the default `pws`, use the
  command
  `mamba env update --name your_env_name --file environment_w_jupyter.yml --prune`
  you will also need to activate this environment by name.)


  We install the `environment_w_jupyter.yml` to provide all known dependencies
  including those for running the example notebooks. (The `environment.yml`
  does not contain Jupyter or JupyterLab because this interferes with installation
  on WholeTale, see Getting Started section below.)




  Please note that you can browse the API reference, developer info, and index
  in the [pywatershed docs]((https://pywatershed.readthedocs.io/)). But
  *the best way to get started with pywatershed is to dive into the example
  notebooks*.

  For introductory example notebooks, look in the
  [`examples/`](https://github.com/EC-USGS/pywatershed/tree/main/examples>)
  directory in the repository. Numbered starting at 00, these are meant to be
  completed in order. Numbered starting at 00, these are meant to be completed
  in order. Notebook outputs are not saved in Github. But you can run these
  notebooks locally or using WholeTale (an NSF funded project supporting logins
  from many institutions, free but sign-up or log-in required)
  where the pywatershed environment is all ready to go:

  [![WholeTale](https://raw.githubusercontent.com/whole-tale/wt-design-docs/master/badges/wholetale-explore.svg)](https://dashboard.wholetale.org)

    * [Run latest release in WholeTale](https://dashboard.wholetale.org/run/64ae29e8a887f48b9f173678?tab=metadata)
    * [Run the develop branch in WholeTale](https://dashboard.wholetale.org/run/64ae25c3a887f48b9f1735c8?tab=metadata)

  WholeTale will give you a JupyterLab running in the root of this
  repository. You can navigate to `examples/` and then open and run the notebooks
  of your choice.  The develop container may require the user to update the
  repository (`git pull origin`) to stay current with development.

  Non-numbered notebooks in `examples/` cover additional topics. These
  notebooks are not yet covered by testing and you may encounter some
  issues. In `examples/developer/` there are notebooks of interest to
  developers who may want to learn about running the software tests.




  We value your feedback! Please use [discussions](https://github.com/EC-USGS/pywatershed/discussions)
  or [issues](https://github.com/EC-USGS/pywatershed/issues) on Github.
  For more in-depth contributions, please start by reading over
  the pywatershed
  [DEVELOPER.md](https://github.com/EC-USGS/pywatershed/blob/develop/DEVELOPER.md) and
  [CONTRIBUTING.md](https://github.com/EC-USGS/pywatershed/blob/develop/CONTRIBUTING.md)
  guidelines.

  Thank you for your interest.



  McCreight, J. L., Langevin, C. D., Hughes, J. D., & Bonelli, W. P. (2024). pywatershed (Version 2.0.0) [Computer software]. [https://doi.org/10.5066/P13EWPEV](https://doi.org/10.5066/P13EWPEV)



  This software has been approved for release by the U.S. Geological Survey (USGS). Although the
  software has been subjected to rigorous review, the USGS reserves the right to update the
  software as needed pursuant to further analysis and review. No warranty, expressed or implied,
  is made by the USGS or the U.S. Government as to the functionality of the software and related
  material nor shall the fact of release constitute any such warranty. Furthermore, the software
  is released on condition that neither the USGS nor the U.S. Government shall be held liable
  for any damages resulting from its authorized or unauthorized use.


pkgId: d9c51d400455050f4f0d78aa39694806be14d6ee1fe8c4eab5d123b29093c097
name: python-pywebfs-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for pywebfs
url: https://github.com/joknarf/pywebfs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywebfs-0.6.2-1.src.rpm
location_href: Packages/python-pywebfs-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Pypi version](https://img.shields.io/pypi/v/pywebfs.svg)](https://pypi.org/project/pywebfs/)
  ![example](https://github.com/joknarf/pywebfs/actions/workflows/python-publish.yml/badge.svg)
  [![Licence](https://img.shields.io/badge/licence-MIT-blue.svg)](https://shields.io/)
  [![](https://pepy.tech/badge/pywebfs)](https://pepy.tech/project/pywebfs)
  [![Python versions](https://img.shields.io/badge/python-3.6+-blue.svg)](https://shields.io/)


  Simple Python HTTP(S) File Server


  ```
  $ pip install pywebfs
  ```



  * start http server sharing current directory listening on 0.0.0.0 port 8080
  ```
  $ pywebfs
  ```

  * Browse/Download/Search files using browser `http://<yourserver>:8080`
  ![image](https://github.com/user-attachments/assets/2ef30c9d-5cd9-421a-ab81-12dc2e9ef651)

  * search text in files (grep)
  ![image](https://github.com/user-attachments/assets/2cb17905-ff55-4773-9c7c-d654c2d2f99f)


  ```
  $ pywebfs --dir /mydir --title "my fileserver" --listen 0.0.0.0 --port 8080
  $ pywebfs -d /mydir -t "my fileserver" -l 0.0.0.0 -p 8080
  ```


  ```
  $ pywebfs --dir /mydir --user myuser [--password mypass]
  $ pywebfs -d /mydir -u myuser [-P mypass]
  ```
  Generated password is given if no `--pasword` option



  * Generate auto-signed certificate and start https server
  ```
  $ pywebfs --dir /mydir --gencert
  $ pywebfs -d /mydir --g
  ```

  * Start https server using existing certificate
  ```
  $ pywebfs --dir /mydir --cert /pathto/host.cert --key /pathto/host.key
  $ pywebfs -d /mydir -c /pathto/host.cert -k /pathto/host.key
  ```

rpm_license:
  MIT License  Copyright (c) 2024 joknarf  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: 83f99b94a2a3a66c66292f49643928a4500a28b4fbe3abce9de3dbe339b2638e
name: python-pywebfs-help
arch: noarch
version: 1.0.14
epoch: 0
release: 1
summary: Development documents and examples for pywebfs
url: https://github.com/joknarf/pywebfs
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywebfs-1.0.14-1.src.rpm
location_href: Packages/python-pywebfs-help-1.0.14-1.noarch.rpm
checksum_type: sha256
description:
  [![Pypi version](https://img.shields.io/pypi/v/pywebfs.svg)](https://pypi.org/project/pywebfs/)
  ![example](https://github.com/joknarf/pywebfs/actions/workflows/python-publish.yml/badge.svg)
  [![Licence](https://img.shields.io/badge/licence-MIT-blue.svg)](https://shields.io/)
  [![](https://pepy.tech/badge/pywebfs)](https://pepy.tech/project/pywebfs)
  [![Python versions](https://img.shields.io/badge/python-3.6+-blue.svg)](https://shields.io/)


  Simple Python HTTP(S) File Server


  ```
  $ pip install pywebfs
  ```



  * start http server sharing current directory listening on 0.0.0.0 port 8080
  ```
  $ pywebfs
  ```

  * Browse/Download/Search files using browser `http://<yourserver>:8080`
  ![image](https://github.com/user-attachments/assets/d77ff596-1e31-4e3f-ac52-042106f9e838)

  * search text in files (grep)
  ![image](https://github.com/user-attachments/assets/f0cf4dda-2724-4137-967f-561cd12e60d5)



  * Serve static files
  * Download folder as zip file
  * Filter files
  * Search files recursively multiple word any order (disable feature with --nosearch)
  * Search text in files recursively
  * Basic Auth support (single user)
  * HTTPS support
  * HTTPS self-signed certificate generator
  * Display owner/group/permissions (POSIX) (disable feature with --noperm)
  * Can be started as a daemon (POSIX)


  ```
  $ pywebfs --dir /mydir --title "my fileserver" --listen 0.0.0.0 --port 8080
  $ pywebfs -d /mydir -t "my fileserver" -l 0.0.0.0 -p 8080
  ```


  ```
  $ pywebfs --dir /mydir --user myuser [--password mypass]
  $ pywebfs -d /mydir -u myuser [-P mypass]
  ```
  Generated password is given if no `--pasword` option



  * Generate auto-signed certificate and start https server
  ```
  $ pywebfs --dir /mydir --gencert
  $ pywebfs -d /mydir --g
  ```

  * Start https server using existing certificate
  ```
  $ pywebfs --dir /mydir --cert /pathto/host.cert --key /pathto/host.key
  $ pywebfs -d /mydir -c /pathto/host.cert -k /pathto/host.key
  ```



  ```
  $ pywebfs start
  $ pywebfs status
  $ pywebfs stop
  ```
  * log of server are stored in `~/.pywebfs/pwfs_<listen>:<port>.log`



  As built on python http.server, read in the python3 documentation:

  >Warning
  >http.server is not recommended for production. It only implements basic security checks.

rpm_license:
  MIT License  Copyright (c) 2024 joknarf  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: 420fa20bf0b4d49a47909340824faf7beada6a72c45098ac3bd449768a09240f
name: python-pywebscrapr-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for pywebscrapr
url: https://github.com/infinitode/pywebscrapr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywebscrapr-0.1.4-1.src.rpm
location_href: Packages/python-pywebscrapr-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  ![Python Version](https://img.shields.io/badge/python-3.12-blue.svg)
  [![Code Size](https://img.shields.io/github/languages/code-size/infinitode/pywebscrapr)](https://github.com/infinitode/pywebscrapr)
  ![Downloads](https://pepy.tech/badge/pywebscrapr)
  ![License Compliance](https://img.shields.io/badge/license-compliance-brightgreen.svg)
  ![PyPI Version](https://img.shields.io/pypi/v/pywebscrapr)

  An open-source Python library for web scraping tasks. Includes support for both text and image scraping.


  - Added new parameters to `scrape_text` to allow automatic removal of duplicates or similar text, and another to specify the type of textual content to scrape (`text`, `content`, `unseen`, `links`).


  - Added support for handling of different types of images on websites. Also now checks for invalid images, with added error handling.



  Changes in version 0.1.2:
  - `min` and `max` width and height parameters can now be specified when working with image scraping, allowing you to quickly exclude smaller resolution images, or images that are extremely large and take up too much space.
  - PyWebScrapr now uses BeautifulSoup4's `SoupStrainer`, making extracting content from webpages much faster.



  You can install PyWebScrapr using pip:

  ```bash
  pip install pywebscrapr
  ```



  PyWebScrapr supports the following Python versions:

  - Python 3.6
  - Python 3.7
  - Python 3.8
  - Python 3.9
  - Python 3.10
  - Python 3.11
  - Python 3.12/Later (Preferred)

  Please ensure that you have one of these Python versions installed before using PyWebScrapr. PyWebScrapr may not work as expected on lower versions of Python than the supported.



  - **Text Scraping**: Extract textual content from specified URLs.
  - **Image Scraping**: Download images from specified URLs.

  <sub>*for a full list check out the [PyWebScrapr official documentation](https://infinitode-docs.gitbook.io/documentation/package-documentation/pywebscrapr-package-documentation).</sub>





  ```python
  from pywebscrapr import scrape_text


  links_file = 'links.txt'
  links_array = ['https://example.com/page1', 'https://example.com/page2']


  scrape_text(links_file=links_file, links_array=links_array, output_file='output.txt')
  ```



  ```python
  from pywebscrapr import scrape_images


  links_file = 'image_links.txt'
  links_array = ['https://example.com/image1.jpg', 'https://example.com/image2.png']


  scrape_images(links_file=links_file, links_array=links_array, save_folder='images')
  ```



  Contributions are welcome! If you encounter any issues, have suggestions, or want to contribute to PyWebScrapr, please open an issue or submit a pull request on [GitHub](https://github.com/infinitode/pywebscrapr).



  PyWebScrapr is released under the terms of the **MIT License (Modified)**. Please see the [LICENSE](https://github.com/infinitode/pywebscrapr/blob/main/LICENSE) file for the full text.

  **Modified License Clause**

  The modified license clause grants users the permission to make derivative works based on the PyWebScrapr software. However, it requires any substantial changes to the software to be clearly distinguished from the original work and distributed under a different name.


pkgId: 387989eacd6a8fd06bda9d9e3a970cd3995178701c6afa712ed3c7795093e9bc
name: python-pywikibot-help
arch: noarch
version: 9.6.1
epoch: 0
release: 1
summary: Development documents and examples for pywikibot
url: https://www.mediawiki.org/wiki/Manual:Pywikibot
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywikibot-9.6.1-1.src.rpm
location_href: Packages/python-pywikibot-help-9.6.1-1.noarch.rpm
checksum_type: sha256
description:
      git clone https://gerrit.wikimedia.org/r/pywikibot/core.git
      cd core
      git submodule update --init
      pip install -r requirements.txt
      python pwb.py <script_name>
  Or to install using PyPI (excluding scripts)
      pip install pywikibot
      pwb <scriptname>
  Our `installation
  guide <https://www.mediawiki.org/wiki/Manual:Pywikibot/Installation>`_
  has more details for advanced usage.


pkgId: e5e1729b63765fa48c377f6cb35253961e22e4dcb3e2501a217a9e7a9ee5d860
name: python-pywordle-cli-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for pywordle-cli
url: https://pypi.org/project/pywordle-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pywordle-cli-0.1.1-1.src.rpm
location_href: Packages/python-pywordle-cli-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  The easiest way to install and start playing is by using `pip`:
  ```bash
  pip install pywordle-cli
  ```
  Once installed, you can start the game by typing:
  ```bash
  wordle


pkgId: f2bace751764133caeb0ee78eb738081cdc9f0ece2fcf558522a8445bbba79e9
name: python-pyxbox-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for pyxbox
url: https://gitee.com/CN-AntAI/pyxbox
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyxbox-0.1.8-1.src.rpm
location_href: Packages/python-pyxbox-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  万能工具库集合


  ![tools.png](http://tva1.sinaimg.cn/large/9aec9ebdgy1h0afusad7hj2e6k2dinpg.jpg)






  自动化发送业务通知、用户注册验证、密码重置等邮件。


  - 用户注册后，发送带有验证链接的欢迎邮件。
  - 用户请求密码重置时，发送带有重置链接的邮件。
  - 定期向用户发送业务更新或促销信息。




  处理视频和图片文件，如格式转换、下载等。


  - 将用户上传的视频文件转换为指定格式并保存。
  - 下载网络上的图片或视频资源供进一步处理或备份。
  - 将图片资源转换为Base64编码，用于Web页面的内联显示。




  模拟不同的浏览器访问，防止被网站识别为爬虫。


  - 在进行网页爬取时，随机更换用户代理，降低被封IP的风险。
  - 进行浏览器兼容性测试，确保Web应用在不同环境下正常工作。




  配置和管理网络代理，访问受地域限制或需要匿名访问的资源。


  - 访问某些只对特定国家或地区开放的在线服务。
  - 在进行网络爬虫开发时，使用代理池减少被封禁的风险。




  提供多样化的工具函数，以支持日常开发中的文件操作、网络请求、日期时间处理等。


  - 开发Web应用时，创建静态资源服务器以快速测试前端资源。
  - 在自动化脚本中，检查文件是否存在，或获取文件的最后修改时间。
  - 需要进行日期时间的转换，如将时间戳转换为可读的日期格式。




  处理微博相关的数据，如用户ID和MID的转换。


  - 在微博数据分析或爬虫项目中，将微博用户ID转换为MID，或反之，以适应不同的数据源格式。
  - 对微博链接进行解析，提取用户ID或MID，用于用户信息的获取或分析。



  1. 安装：`pip install pyxbox`
  2. 更新：`pip install -U pyxbox`
  3. 卸载：`pip uninstall pyxbox`





  - 新增b站bv和av的转码
  - 获取弹幕字节流的转码


  > 更新时间为：2023年8月17日
  - 新增微博的帖子id与mid相互转换


pkgId: 5acfcc9888d6d13a2990164016f305d56ca6f6ea36a78bda5932f91b9ea282c6
name: python-pyxbrain-help
arch: noarch
version: 1.1.30
epoch: 0
release: 1
summary: Development documents and examples for pyxbrain
url: https://pypi.org/project/pyxbrain/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyxbrain-1.1.30-1.src.rpm
location_href: Packages/python-pyxbrain-help-1.1.30-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center"><a name="readme-top">

  <img src="./image/README/logo.png" width="120" height="120" alt="XBrain">
  <h1>XBrain</h1>

  通过装饰器将函数接入OpenAI的Chat

  📘[详细文档](https://xbrain.notion.site/)|🎞️[介绍视频](https://www.bilibili.com/video/BV1c52FY4E51/?share_source=copy_web&vd_source=c28e503b050f016c21660b69e391d391)|🗨[English](https://github.com/yuruotong1/xbrain/blob/master/README_EN.md)

  </div>



  OpenAI的Funciton Call很有用，但每次都需要在 chat 接口中引用Json或者Pydantic Model，而XBrain只需要在Python函数上放一个装饰器，就能自动将函数接入到 chat 中。




  - [快速开始：新手上手指南，适合第一次接触的开发者](https://xbrain.notion.site/xbrain-11d42182d0a98003b272d5555c6e9448)
  - [常见问题：你想知道的答案都在这里](https://xbrain.notion.site/b274c33d808a4ddea32244c3fd41719c)
  - [开发者指南：欢迎加入我们](https://xbrain.notion.site/12842182d0a9803bb5dcdbfe71826915?pvs=4)



  安装xbrain:

  `pip install pyxbrain`

  在你的项目目录下创建一个`demo.py`文件，写入以下代码：

  ```python
  from pydantic import BaseModel
  from xbrain.core import xbrain_tool
  class GenerateTag(BaseModel):
      """创建一个新的插件"""
      pass

  @xbrain_tool.Tool(model=GenerateTag)
  def generate_tag():
      print("hello")
  ```

  在`__init__.py`文件中导入`demo.py`：

  ```python
  from demo import *
  ```

  在项目入口处配置并运行xbrain，此时`demo.py`中的`generate_tag`函数被成功接入了xbrain中：

  ```python
  from xbrain.core.chat import run
  from xbrain.utils.config import Config
  config = Config()
  config.set_openai_config(base_url="https://api.openai-next.com/v1", api_key="xxxxx", model="gpt-4o-2024-08-06")
  messages = []
  messages.append({"role": "user", "content": "配置tag"})
  res = run(messages, user_prompt="从文章中提炼出关键信息")
  ```



  你可以通过 Fork 项目、提交 PR 或在 Issue 中提出你的想法和建议。具体操作可参考[贡献指南](https://xbrain.notion.site/12842182d0a9803bb5dcdbfe71826915)。


  > 强烈推荐阅读 [《提问的智慧》](https://github.com/ryanhanwu/How-To-Ask-Questions-The-Smart-Way)、[《如何向开源社区提问题》](https://github.com/seajs/seajs/issues/545) 和 [《如何有效地报告 Bug》](http://www.chiark.greenend.org.uk/%7Esgtatham/bugs-cn.html)、[《如何向开源项目提交无法解答的问题》](https://zhuanlan.zhihu.com/p/25795393)，更好的问题更容易获得帮助。

  <a href="https://github.com/yuruotong1/xbrain/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=yuruotong1/xbrain" />
  </a>


pkgId: b23a45fd86ce1bb239b70da695b89061af0c049ddd1f8b469e1f6a2b6cb03ed8
name: python-pyxel-input-manager-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for pyxel-input-manager
url: https://pypi.org/project/pyxel-input-manager/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyxel-input-manager-0.0.5-1.src.rpm
location_href: Packages/python-pyxel-input-manager-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  A simple input manager for Pyxel.



  - Bind keys to actions
  - Easy integration with Pyxel
  - Lightweight and simple to use



  You can install the Pyxel Input Manager via pip:

  ```sh
  pip install pyxel-input-manager
  ```

  <!-- Make sure you have Python 3.11 or higher. -->



  ```sh
  python -m pyxel_input_manager demo
  ```

  or

  ```sh
  pyxel-input-manager demo
  ```



  To use the Pyxel Input Manager in your Pyxel project, you can import and initialize it as follows:

  ```python
  import pyxel
  from pyxel_input_manager import InputMap, InputEvent, AnalogBinding


  input_map = InputMap({
      "jump": [pyxel.KEY_SPACE],  # Digital input
      "move": AnalogBinding(pyxel.GAMEPAD1_AXIS_LEFTX)  # Analog input
  })


  input_event = InputEvent(input_map)

  def update():
      
      input_event.update_states()

      
      if input_event.is_action_just_pressed("jump"):
          player.jump()

      move_value = input_event.get_analog_value("move")
      player.move(move_value)
  ```

  <!-- ## Contributing

  If you would like to contribute to this project, please feel free to submit a pull request. For major changes, please open an issue first to discuss what you would like to change. -->



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


pkgId: 4bc51783c8f3b8b552124176492aa6f9e21011dfac9697d948d7b700d38a1b19
name: python-pyxel-reload-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for pyxel-reload
url: https://pypi.org/project/pyxel-reload/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyxel-reload-0.2.0-1.src.rpm
location_href: Packages/python-pyxel-reload-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  A hot-reloading development tool for [Pyxel](https://github.com/kitao/pyxel) games that automatically refreshes your game when code or asset files change.



  - Hot reloading of Python code changes
  - Automatic reloading when .pyxres asset files change
  - Error display in both console and game window
  - Simple integration with existing Pyxel games



  Install via pip:

  ```bash
  pip install pyxel-reload
  ```



  1. Ensure your game file has an `update` and `draw` function

  ```python
  import pyxel

  pyxel.init(160, 120)

  def update():
      if pyxel.btnp(pyxel.KEY_Q):
          pyxel.quit()

  def draw():
      pyxel.cls(0)
      pyxel.text(10, 10, "Hello, Pyxel!", pyxel.frame_count % 16)

  pyxel.run(update, draw)
  ```

  2. Run your game with pyxel-reload:

  ```bash
  pyxel-reload game
  ```

  Where `game` is the name of your Python module (without the .py extension).

  3. Make changes to your code or .pyxres files and see them reload automatically!



  When errors occur during reload:
  - Error details are displayed in the console
  - A basic error message appears in the game window
  - The game continues running and will reload once errors are fixed

  ![](error-overlay.png)

rpm_license:
  MIT License  Copyright (c) 2024 Reiner Gerecke  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: 2949af1279230a2a706d67b299c3c7e04eeb7395cbe75dd700965a23dfdb2160
name: python-pyxtream-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for pyxtream
url: https://github.com/superolmo/pyxtream
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyxtream-0.7.2-1.src.rpm
location_href: Packages/python-pyxtream-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  PyXtream loads the xtream IPTV content from a provider server. Groups, Channels, Series are all organized in dictionaries. Season and Episodes are retrieved as needed. It includes functions for searching streams and downloading.

  This library was originally designed to work with Hypnotix at https://github.com/linuxmint/hypnotix



  Installing pyxtream is done using pip3.

  ```shell
  pip3 install pyxtream
  ```

  Optionally, to use the REST Api service, install also Flask via the following command or manually.

  ```shell
  pip3 install pyxtream[REST_API]
  ```






  Integrating in your application is simple. Initialization and loading of IPTV channels and groups is done with the following code.

  ```python
  from pyxtream import XTream
  xt = XTream(servername, username, password, url)
  if xt.authData != {}:
      xt.load_iptv()
  else:
      print("Could not connect")
  ```

  Once completed, all the data can be found in xTream.groups, xTream.channels, xTream.movies, xTream.series. Series do not contains the information for all the Seasons and Episodes. Those are loaded separately when needed by calling the following function using a Series object from xTream.series array of dictionaries.

  ```python
  xt.get_series_info_by_id(series_obj)
  ```

  At this point, the series_obj will have both Seasons and Episodes populated.

  If you have installed Flask, the REST Api will be turned ON automatically. At this point, there is no method to turn it off. Maybe in a future version.



  Please modify the functional_test.py file with your provider information, then start the application.

  ```shell
  python3 functional_test.py
  ```

  The functional test will allow you to authenticate on startup, load and search streams. If Flask is installed, a simple website will be available at http://localhost:5000 to allow you to search and play streams.



  - xtreamPOC - https://github.com/sght500/xtreamPOC - Project is a Proof of Concept (POC) that leverages pyxtream, MPV, and NiceGUI to demonstrate the use of Xtream Portal Codes.

  So far there is no ready to use Transport Stream library for playing live stream.

  - This is the library to convert TS to MP4
    - https://github.com/videojs/mux.js/

  - More on above, but same problem. XMLHttpRequest waits until the whole TS file is completely loaded. It does not work for live video streams
    - https://developpaper.com/play-ts-video-directly-on-the-web/

  - This below will allow me to process chunks of data
    - https://stackoverflow.com/questions/37402716/handle-xmlhttprequest-response-with-large-data






  Below are the classes used in the module. They are heavily influenced by the application Hypnotix.

  - XTream.Channels
  - XTream.Groups
  - XTream.Episode
  - XTream.Series
  - XTream.Season



  xTream.groups[{},{},...]

  xTream.channels[{},{},...]

  xTream.series[{},{},...]

  xTream.movies[{},{},...]



  - xTream.authenticate()
  - xTream.load_iptv()
  - XTream.get_series_info_by_id(get_series: dict)
  - xTream.search_stream(keyword: str, ignore_case: bool = True, return_type: str = "LIST")
  - xTream.download_video(stream_id: int)
  - xTream.vodInfoByID(vod_id)
  - xTream.liveEpgByStream(stream_id)
  - xTream.liveEpgByStreamAndLimit(stream_id, limit)
  - xTream.allLiveEpgByStream(stream_id)
  - xTream.allEpg()


  - Increment the MAJOR version when you make incompatible API changes.
  - Increment the MINOR version when you add functionality in a backwards-compatible manner.
  - Increment the PATCH version when you make backwards-compatible bug fixes.



  | Date | Version | Description |
  | ----------- | -----| ----------- |
  | 2024-09-02 | 0.7.2 | - Added missing request package to setup.py<br>- Refactored the search stream function and now, it can search for a specific stream type<br>- Refactored the download stream function<br>- Refactored the _get_request function and removed the call to the sleep function<br>- Added functional test to get series json output from a series_id<br>- Added functional test to get EPG for a specific stream ID<br>- Added xtream account expiration date printed on the console during authentication<br>- Improved results with the Flask HTML page and differentiating between movies and series<br>- Improved code readability|
  | 2024-05-21 | 0.7.1 | - Fixed missing jsonschema package<br>- Fixed provider name in functional_test<br>- Improved print out of connection attempts<br>- Added method to read latest changes in functional_test
  | 2023-11-08 | 0.7.0 | - Added Schema Validator<br>- Added Channel Age<br>- Added list of movies added in the last 30 and 7 days<br>- Updated code based on PyLint<br>- Fixed Flask package to be optional [richard-de-vos](https://github.com/richard-de-vos)|
  | 2023-02-06 | 0.6.0 | - Added methods to change connection header, to turn off reload timer, and to enable/disable Flask debug mode<br>- Added a loop when attempting to connect to the provider <br>- Cleaned up some print lines|
  | 2021-08-19 | 0.5.0 | - Added method to gracefully handle connection errors<br>- Added setting to not load adult content<br>- Added sorting by stream name<br>- Changed the handling of special characters in streams<br>- Changed print formatting<br>- Changed index.html webpage to HTML5 and Bootstrap 5|
  | 2021-06-19 | 0.4.0 | - Updated to follow PEP8<br>- Updated Docstrings |
  | 2021-06-19 | 0.3.0 | - Added enhanced Home Page with Search Button and Player<br>- Added case insensitive search<br>- Improved handling of provider missing fields |
  | 2021-06-11 | 0.2.1 | - Fixed bug in the way it reload from cache |
  | 2021-06-08 | 0.2.0 | - Added searching<br>- Added video download<br>- Added REST Api<br>- Fixed cache-path issue |
  | 2021-06-05 | 0.1.2 | - Fixed Server Name |
  | 2021-06-04 | 0.1.1 | - Updated README.md |
  | 2021-06-04 | 0.1.0 | - Initial Release |


pkgId: 3c1cf3f54623e08a10a5ae2b329b2dc7db09304556cb98fa431dc042eac2320a
name: python-pyzefir-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for pyzefir
url: https://pypi.org/project/pyzefir/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pyzefir-0.5.0-1.src.rpm
location_href: Packages/python-pyzefir-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  Pyzefir is used to build and configure a specific class of mathematical optimization models that represent a given
  energy system. This System is clearly defined by identifying sources, transmission infrastructure and energy customers.
  The processes provided in the model are the acquisition, transfer and processing of various types of energy to meet
  the needs of consumers.

  In the model, we distinguish between the supply side (energy sources) and the demand side (energy consumers).
  The key relationship that must occur in the model is the balance relation, which assumes that in each analyzed hour the
  volume of energy supplied to customers is equal to their energy demand.

  The tool aims to find the solution of the optimization by determining how – with the given scenario
  assumptions – the technological structure of the given energy system will change over the next years.
  Subjects to optimize are the total cost of maintenance (operating costs), modernization (investment costs)
  and operation (variable costs) of a given energy system.

  The elements of the energy system represented in the tool are energy carriers, energy sources, energy storage facilities,
  transmission infrastructure elements and energy consumers.



  Install repository from global pip index
  ```bash
  pip install pyzefir
  ```


  Check if make is already installed
  ```bash
  make --version
  ```

  If not, install make
  ```bash
  sudo apt install make
  ```



  Install virtual environment and all dependencies
  ```bash
  make install
  ```
  If you are developing pyZefir it is recommended to use editable mode.
  ```bash
  make install EDITABLE=yes
  ```
  which  allows you to install a package in such a way that any changes made to
  the source code are immediately reflected in the installed package without the
  need to reinstall it.

  Run linters check (black, pylama)
  ```bash
  make lint
  ```
  Run unit and fast integration tests (runs lint stage before)
  ```bash
  Make unit
  ```
  Run integration tests (runs lint and unit stages before)
  ```bash
  make test
  ```
  Remove temporary files such as .venv, .mypy_cache, .pytest_cache etc.
  ```bash
  make clean
  ```



  You can create virtual environment using make:

  ```bash
  make install
  ```

  or manually:
  ```bash

  python -m venv .venv
  source .venv/bin/active


  pip install .
  pip install .[dev]


  pre-commit install
  ```


  Run input structure creator
  ```bash
  structure-creator --help

  Usage: structure-creator [OPTIONS]
  Options:
    -i, --input_path PATH     Input data for the creator.  [required]
    -o, --output_path PATH    Path to dump the results.  [required]
    -s, --scenario_name TEXT  Name of the scenario.  [required]
    -h, --n_hours INTEGER     N_HOURS constant.
    -y, --n_years INTEGER     N_YEARS constant.
    --help                    Show this message and exit.
  ```


  ```bash
  structure-creator -i pyzefir\resources\structure_creator_resources -o pyzefir\results -s base_scenario -h 8760 -y 20
  ```


  ```markdown
  .
  └── structure_creator_resources/
      ├── lbs/
      │   ├── boiler_coal_new_lkt.xlsx
      │   ├── boiler_gas_lkt.xlsx
      │   └── ...
      ├── scenarios/
      │   └── base_scenario/
      │       ├── fractions/
      │       │   ├── boiler_coal_new_lkt.xlsx
      │       │   ├── boiler_gas_lkt.xlsx
      │       │   └── ...
      │       ├── cost_parameters.xlsx
      │       ├── fuel_parameters.xlsx
      │       ├── generation_fraction.xlsx
      │       ├── n_consumers.xlsx
      │       ├── relative_emission_limits.xlsx
      │       ├── technology_cap_limits.xlsx
      │       ├── technology_type_cap_limits.xlsx
      │       └── yearly_demand.xlsx
      ├── aggregates.xlsx
      ├── configuration.xlsx
      ├── emissions.xlsx
      ├── subsystems.xlsx
      └── transmission_fees.xlsx
  ```



  1. Prepare `config.ini` file (look at `config_example.ini` file in project directory)

  :information_source: The section `create` of `config.ini` file is used for `structure creator` only, so if you're not going
  to use `structure-creator` do not add the section.

  2. Run `pyzefir`
  ```bash
  pyzefir --help

  Options:
    -c, --config PATH         Path to *.ini file.  [required]
    -hcd, --hash-commit-dump  Flag to include hash commit information. (only in
                              development mode)
    --help                    Show this message and exit.
  ```


  ```bash
  pyzefir -c pyzefir/config_basic.ini
  pyzefir -c pyzefir/config_basic.ini --hash-commit-dump
  ```


  ```markdown

  XLSX input
  .
  └── /pyzefir resources/
      ├── /scenarios/
      │   ├── scenario_1.xlsx
      │   ├── scenario_2.xlsx
      │   └── ...
      ├── capacity_factors.xlsx
      ├── conversion_rate.xlsx
      ├── demand_chunks.xlsx
      ├── fuels.xlsx
      ├── generator_types.xlsx
      ├── initial_state.xlsx
      ├── storage_types.xlsx
      └── structure.xlsx

  CSV input

  .
  └── /pyzefir resources/
      ├── /capacity_factors/
      │   └── Profiles.csv
      ├── /conversion_rate/
      │   ├── HEAT_PUMP.csv
      │   ├── BOILER_COAL.csv
      │   └── ...
      ├── /demand_chunks/
      │   ├── Demand_Chunks.csv
      │   ├── chunk_period_1.csv
      │   ├── chunk_period_2.csv
      │   └── ...
      ├── /demand_types/
      │   ├── family.csv
      │   ├── multifamily.csv
      │   └── ...
      ├── /fuels/
      │   ├── Emission_Per_Unit.csv
      │   └── Energy_Per_Unit.csv
      ├── /generator_types/
      │   ├── Efficiency.csv
      │   ├── Emission_Reduction.csv
      │   ├── Generator_Type_Energy_Carrier.csv
      │   ├── Generator_Type_Energy_Type.csv
      │   ├── Generator_Types.csv
      │   └── Power_Utilization.csv
      ├── /initial_state/
      │   ├── Technology.csv
      │   └── TechnologyStack.csv
      ├── /storage_types/
      │   └── Parameters.csv
      ├── /structure/
      │   ├── Aggregates.csv
      │   ├── Buses.csv
      │   ├── DSR.csv
      │   ├── Emission_Fees_Emission_Types.csv
      │   ├── Emission_Types.csv
      │   ├── Energy_Types.csv
      │   ├── Generator_Binding.csv
      │   ├── Generator_Emission_Fees.csv
      │   ├── Generators.csv
      │   ├── Lines.csv
      │   ├── Power_Reserve.csv
      │   ├── Storages.csv
      │   ├── Technology_Bus.csv
      │   ├── TechnologyStack_Aggregate.csv
      │   ├── TechnologyStack_Buses_out.csv
      │   ├── TechnologyStack_Buses.csv
      │   └── Transmission_Fees.csv
      └── /scenario/
          ├── /scenario_name/
          │   ├── Constants.csv
          │   ├── Cost_Parameters.csv
          │   ├── Curtailment_Cost.csv
          │   ├── Element_Energy_Evolution_Limits.csv
          │   ├── Emission_Fees.csv
          │   ├── Energy_Source_Evolution_Limits.csv
          │   ├── Fractions.csv
          │   ├── Fuel_Availability.csv
          │   ├── Fuel_Prices.csv
          │   ├── Generation_Fraction.csv
          │   ├── N_Consumers.csv
          │   ├── Relative_Emission_Limits.csv
          │   └── Yearly_Demand.csv
          └── /another_scenario_name/
              └── ....
  ```

rpm_license:
  The MIT License (MIT)  Copyright (c) 2023-2024 Narodowe Centrum Badań Jądrowych  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: 0053462a8585be2352de375dfdf934ec3f54fded15876c7fa650f91562582d2e
name: python-qBitrr2-help
arch: noarch
version: 4.10.6
epoch: 0
release: 1
summary: Development documents and examples for qBitrr2
url: https://github.com/Feramance/qBitrr
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qBitrr2-4.10.6-1.src.rpm
location_href: Packages/python-qBitrr2-help-4.10.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/qbitrr)](https://github.com/Feramance/Qbitrr/blob/master/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/qBitrr2?label=PyPI)](https://pypi.org/project/qBitrr2/)
  [![Downloads](https://img.shields.io/pypi/dm/qbitrr2)](https://pypi.org/project/qBitrr2/)
  [![Pulls](https://img.shields.io/docker/pulls/feramance/qbitrr.svg)](https://hub.docker.com/r/feramance/qbitrr)

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qbitrr)
  [![Platforms](https://img.shields.io/badge/platform-linux--64%20%7C%20osx--64%20%7C%20win--32%20%7C%20win--64-lightgrey)](https://github.com/Feramance/qBitrr/releases/latest)

  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Feramance/qBitrr/master.svg)](https://results.pre-commit.ci/latest/github/Feramance/qBitrr/master)
  [![CodeQL](https://github.com/Feramance/qBitrr/actions/workflows/codeql.yml/badge.svg?branch=master)](https://github.com/Feramance/qBitrr/actions/workflows/codeql.yml)
  [![Create a Release](https://github.com/Feramance/qBitrr/actions/workflows/release.yml/badge.svg?branch=master)](https://github.com/Feramance/qBitrr/actions/workflows/release.yml)
  [![Nightly Build](https://github.com/Feramance/qBitrr/actions/workflows/nightly.yml/badge.svg?branch=master)](https://github.com/Feramance/qBitrr/actions/workflows/nightly.yml)

  [![Code Style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)

  A simple script to monitor [qBit](https://github.com/qbittorrent/qBittorrent) and communicate with [Radarr](https://github.com/Radarr/Radarr) and [Sonarr](https://github.com/Sonarr/Sonarr)



  I am starting development on qBitrr+ which will be C# based for better overall performance and will also include a WebUI for better refined control on setting and what to search/upgrade etc. Hoping this will be the be all and end all application to manage your Radarr/Sonarr, Overseerr/Ombi and qBittorrent instances in one UI. This is still in it's very early stages and will likely be a couple months before a concrete alpha is rolled out (from start of February 2024). Once I have something solid I will remove this notice and  add a link to the new qBitrr+, in the meantime I will be sharing periodic updates on my [Patreon](https://patreon.com/qBitrr)



  - Monitor qBit for Stalled/bad entries and delete them then blacklist them on Arrs (Option to also trigger a re-search action).
  - Monitor qBit for completed entries and tell the appropriate Arr instance to import it:
    - `qbitrr DownloadedMoviesScan` for Radarr
    - `qbitrr DownloadedEpisodesScan` for Sonarr
  - Skip files in qBit entries by extension, folder or regex.
  - Monitor completed folder and clean it up.
  - Usage of [ffprobe](https://github.com/FFmpeg/FFmpeg) to ensure downloaded entries are valid media.
  - Trigger periodic Rss Syncs on the appropriate Arr instances.
  - Trigger Queue update on appropriate Arr instances.
  - Search requests from [Overseerr](https://github.com/sct/overseerr) or [Ombi](https://github.com/Ombi-app/Ombi).
  - Auto add/remove trackers
  - Set per tracker values
  - **Sonarr v4 support**
  - **Radarr v4 and v5 support**
  - Monitor Arr's to trigger missing episode searches.
  - Searches Radarr missing movies based on Minimum Availability
  - Customizable searching by series or singular episodes
  - Optionally searches year by year is ascending or descending order (config option available)
  - Search for CF Score unmet and cancel torrents base on CF Score or Quality unmet search
  - Set minimum free space in download directory and pause torrent downloads accordingly
  - Change quality profile temporarily for missing items until found



  Some things to know before using it.

  - **Latest supported qbittorrent version is 4.6.7**
  - qBittorrent >= 4.5.x
  - [Sonarr](https://github.com/Sonarr/Sonarr) and [Radarr](https://github.com/Radarr/Radarr) both setup to add tags to all downloads.
  - qBit set to create sub-folders for tag.




  - `python -m pip install qBitrr2` (I would recommend in a dedicated [venv](https://docs.python.org/3.3/library/venv.html) but that's out of scope.

  Alternatively:
  - Download the [latest release](https://github.com/Feramance/Qbitrr/releases/latest)



  1. Activate your venv
  2. Run `qBitrr2`  to generate a config file
  3. Edit the config file (located at `~/config/config.toml` (~ is your current directory)
  4. Run `qBitrr2` if installed through pip again to start the script

  Alternatively:
  1. Unzip the downloaded release and run it
  2. Run `qBitrr`  to generate a config file
  3. Edit the config file (located at `~/config/config.toml` (~ is your current directory)
  4. Run `qBitrr` if installed through pip again to start the script



  1. Activate your venv
  2. Run `python -m pip install -U qBitrr2`

  Alternatively:
  1. Download on the [latest release](https://github.com/Feramance/Qbitrr/releases/latest)
  2. Unzip the downloaded release and run it
  3. Run `qBitrr`  to generate a config file
  4. Edit the config file (located at `~/config/config.toml` (~ is your current directory)
  5. Run `qBitrr` if installed through pip again to start the script

  ***There is no auto-update feature, you will need to manually download the latest release and replace the old one.***





  - The docker image can be found on [DockerHub](https://hub.docker.com/r/feramance/qbitrr) or [Github](https://github.com/Feramance/qBitrr/pkgs/container/qbitrr)



  ```bash
  docker run -d \
    --name=qbitrr \
    -e TZ=Europe/London \
    -v /etc/localtime:/etc/localtime:ro \
    -v /path/to/appdata/qbitrr:/config \
    -v /path/to/completed/downloads/folder:/completed_downloads:rw \
    --restart unless-stopped \
    feramance/qbitrr:latest
  ```



  ```yaml
  version: "3"
  services:
    qbitrr:
      image: feramance/qbitrr:latest
      user: 1000:1000 # Required to ensure the container is run as the user who has perms to see the 2 mount points and the ability to write to the CompletedDownloadFolder mount
      tty: true # Ensure the output of docker-compose logs qBitrr are properly colored.
      restart: unless-stopped
      
      environment:
        - TZ=Europe/London
      volumes:
        - /etc/localtime:/etc/localtime:ro
        - /path/to/appdata/qbitrr:/config  # Config folder for qBitrr
        - /path/to/completed/downloads/folder:/completed_downloads:rw # The script will ALWAYS require write permission in this folder if mounted, this folder is used to monitor completed downloads and if not present will cause the script to ignore downloaded file monitoring.
        
        
        

      logging: # this script will generate a LOT of logs - so it is up to you to decide how much of it you want to store
        driver: "json-file"
        options:
          max-size: "50m"
          max-file: 3
      depends_on: # Not needed but this ensures qBitrr only starts if the dependencies are up and running
        - qbittorrent
        - radarr-1080p
        - radarr-4k
        - sonarr-1080p
        - sonarr-anime
        - overseerr
        - ombi
  ```



  - The script will always expect a completed config.toml file
  - When you first start the container a "config.rename_me.toml" will be added to `/path/to/appdata/qbitrr`
    - Make sure to rename it to 'config.toml' then edit it to your desired values



  Please do not hesitate to open an issue for feature requests or any suggestions you may have. I plan on periodically adding any features I might feel I want to add but welcome to other suggestions I might not have thought of yet.



  When reporting an issue, please ensure that log files are enabled while running qBitrr and attach them to the issue. Thank you.


pkgId: 786762da13c1bdbde64015ca9a9d3222eda191528cf13fd5b11d53e0eb6a9b81
name: python-qa-metrics-help
arch: noarch
version: 0.2.26
epoch: 0
release: 1
summary: Development documents and examples for qa-metrics
url: https://github.com/zli12321/qa_metrics
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qa-metrics-0.2.26-1.src.rpm
location_href: Packages/python-qa-metrics-help-0.2.26-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version qa-metrics](https://img.shields.io/pypi/v/qa-metrics.svg)](https://pypi.org/project/qa-metrics/)
  [![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1Ke23KIeHFdPWad0BModmcWKZ6jSbF5nI?usp=sharing)

  > A fast and lightweight Python package for evaluating question-answering models and prompting of black-box and open-source large language models.

  > `pip install qa-metrics` is all you need!



  - **Version 0.2.19 Released!**
    - Paper accepted to EMNLP 2024 Findings! 🎓
    - Enhanced PEDANTS with multi-pipeline support and improved edge case handling
    - Added support for OpenAI GPT-series and Claude Series models (OpenAI version > 1.0)
    - Integrated support for open-source models (LLaMA-2-70B-chat, LLaVA-1.5, etc.) via [deepinfra](https://deepinfra.com/models)
    - Introduced trained tiny-bert for QA evaluation (18MB model size)
    - Added direct Huggingface model download support for TransformerMatcher




  * 1. [Normalized Exact Match](#em)
  * 2. [Token F1 Score](#f1)
  * 3. [PEDANTS](#pedants)
  * 4. [Finetuned Neural Matching](#neural)
  * 5. [Prompting LLM](#llm)


  - Python >= 3.6
  - openai >= 1.0


  ```bash
  pip install qa-metrics
  ```



  Our package offers six QA evaluation methods with varying strengths:

  | Method | Best For | Cost | Correlation with Human Judgment |
  |--------|----------|------|--------------------------------|
  | Normalized Exact Match | Short-form QA (NQ-OPEN, HotpotQA, etc.) | Free | Good |
  | PEDANTS | Both short & medium-form QA | Free | Very High |
  | [Neural Evaluation](https://huggingface.co/zli12321/answer_equivalence_tiny_bert) | Both short & long-form QA | Free | High |
  | [Open Source LLM Evaluation](https://huggingface.co/zli12321/prometheus2-2B) | All QA types | Free | High |
  | Black-box LLM Evaluation | All QA types | Paid | Highest |








  **Parameters**
  - `reference_answer` (list of str): A list of gold (correct) answers to the question
  - `candidate_answer` (str): The answer provided by a candidate that needs to be evaluated

  **Returns**
  - `boolean`: True if there are any exact normalized matches between gold and candidate answers

  ```python
  from qa_metrics.em import em_match

  reference_answer = ["The Frog Prince", "The Princess and the Frog"]
  candidate_answer = "The movie \"The Princess and the Frog\" is loosely based off the Brother Grimm's \"Iron Henry\""
  match_result = em_match(reference_answer, candidate_answer)
  ```




  **Parameters**
  - `reference_answer` (str): A gold (correct) answer to the question
  - `candidate_answer` (str): The answer provided by a candidate that needs to be evaluated

  **Returns**
  - `dictionary`: Contains the F1 score, precision, and recall between a gold and candidate answer


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `threshold` (float): F1 score threshold for considering a match (default: 0.5)

  **Returns**
  - `boolean`: True if F1 score exceeds threshold for any gold answer

  ```python
  from qa_metrics.f1 import f1_match, f1_score_with_precision_recall

  f1_stats = f1_score_with_precision_recall(reference_answer[0], candidate_answer)
  match_result = f1_match(reference_answer, candidate_answer, threshold=0.5)
  ```




  **Parameters**
  - `reference_answer` (str): A Gold answer
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `float`: The similarity score between two strings (0 to 1)


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `dictionary`: Contains the gold answer and candidate answer pair with highest matching score


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `dictionary`: Contains matching scores for all gold answer and candidate answer pairs


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `boolean`: True if candidate answer matches any gold answer


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `question` (str): The question being evaluated

  **Returns**
  - `list`: The type of the question (what, who, when, how, why, which, where)


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `list`: A list revised rules applicable to judge answer correctness

  ```python
  from qa_metrics.pedant import PEDANT

  pedant = PEDANT()
  scores = pedant.get_scores(reference_answer, candidate_answer, question)
  match_result = pedant.evaluate(reference_answer, candidate_answer, question)
  ```




  **Parameters**
  - `reference_answer` (str): A Gold answer
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `float`: The similarity score between two strings (0 to 1)


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `dictionary`: Contains the gold answer and candidate answer pair with highest matching score


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `dictionary`: Contains matching scores for all gold answer and candidate answer pairs


  **Parameters**
  - `reference_answer` (list of str): List of gold answers
  - `candidate_answer` (str): Candidate answer to evaluate
  - `question` (str): The question being evaluated

  **Returns**
  - `boolean`: True if transformer model considers candidate answer equivalent to any gold answer

  ```python
  from qa_metrics.transformerMatcher import TransformerMatcher


  tm = TransformerMatcher("zli12321/answer_equivalence_tiny_bert")
  match_result = tm.transformer_match(reference_answer, candidate_answer, question)
  ```




  **Parameters**
  - `prompt` (str): The input prompt text
  - `model_engine` (str): OpenAI model to use (e.g., 'gpt-3.5-turbo')
  - `temperature` (float): Controls randomness (0-1)
  - `max_tokens` (int): Maximum tokens in response

  ```python
  from qa_metrics.prompt_llm import CloseLLM

  model = CloseLLM()
  model.set_openai_api_key(YOUR_OPENAI_KEY)
  result = model.prompt_gpt(prompt=prompt, model_engine='gpt-3.5-turbo')
  ```


  **Parameters**
  - `prompt` (str): The input prompt text
  - `model_engine` (str): Claude model to use
  - `anthropic_version` (str): API version
  - `max_tokens_to_sample` (int): Maximum tokens in response
  - `temperature` (float): Controls randomness (0-1)

  ```python
  model = CloseLLM()
  model.set_anthropic_api_key(YOUR_ANTHROPIC_KEY)
  result = model.prompt_claude(prompt=prompt, model_engine='claude-v1')
  ```


  **Parameters**
  - `message` (str): The input message text
  - `model_engine` (str): Model to use
  - `temperature` (float): Controls randomness (0-1)
  - `max_tokens` (int): Maximum tokens in response

  ```python
  from qa_metrics.prompt_open_llm import OpenLLM

  model = OpenLLM()
  model.set_deepinfra_key(YOUR_DEEPINFRA_KEY)
  result = model.prompt(message=prompt, model_engine='mistralai/Mixtral-8x7B-Instruct-v0.1')
  ```



  Our fine-tuned models are available on Huggingface:
  - [BERT](https://huggingface.co/Zongxia/answer_equivalence_bert)
  - [DistilRoBERTa](https://huggingface.co/Zongxia/answer_equivalence_distilroberta)
  - [DistilBERT](https://huggingface.co/Zongxia/answer_equivalence_distilbert)
  - [RoBERTa](https://huggingface.co/Zongxia/answer_equivalence_roberta)
  - [Tiny-BERT](https://huggingface.co/Zongxia/answer_equivalence_tiny_bert)
  - [RoBERTa-Large](https://huggingface.co/Zongxia/answer_equivalence_roberta-large)



  - [Full Paper](https://arxiv.org/abs/2402.11161)
  - [Dataset Repository](https://github.com/zli12321/Answer_Equivalence_Dataset.git)
  - [Supported Models on Deepinfra](https://deepinfra.com/models)



  ```bibtex
  @misc{li2024pedantspreciseevaluationsdiverse,
        title={PEDANTS: Cheap but Effective and Interpretable Answer Equivalence},
        author={Zongxia Li and Ishani Mondal and Yijun Liang and Huy Nghiem and Jordan Lee Boyd-Graber},
        year={2024},
        eprint={2402.11161},
        archivePrefix={arXiv},
        primaryClass={cs.CL},
        url={https://arxiv.org/abs/2402.11161},
  }
  ```


pkgId: 821d81474f1e19b89652868dfc59262fd036714f758aa54e92bd9383c261ec9e
name: python-qa-rag-pipeline-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for qa-rag-pipeline
url: https://pypi.org/project/qa-rag-pipeline/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qa-rag-pipeline-0.1.0-1.src.rpm
location_href: Packages/python-qa-rag-pipeline-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python package that implements a Question-Answering Retrieval-Augmented Generation (RAG) pipeline using OpenAI, FAISS, and Sentence Transformers.


  - Retrieve relevant context using FAISS.
  - Generate standalone questions using OpenAI's LLM.
  - Classify intent to block certain queries.


  ```bash
  pip install .


pkgId: 586ad0de48e2d9357f12012b22db53b500e54eb882dea6fcb7ef5a7d2874c891
name: python-qadence2-platforms-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for qadence2-platforms
url: https://pypi.org/project/qadence2-platforms/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qadence2-platforms-0.2.2-1.src.rpm
location_href: Packages/python-qadence2-platforms-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  !!! note
      Qadence 2 Platforms is currently a *work in progress* and is under active development.

      Please be aware that the software is in an early stage, and frequent updates, including breaking changes, are to be expected. This means that:
      * Features and functionalities may change without prior notice.
      * The codebase is still evolving, and parts of the software may not function as intended.
      * Documentation and user guides may be incomplete or subject to significant changes.


  Qadence 2 Platforms is a collection of functionalities that transforms [Qadence IR](https://github.com/pasqal-io/qadence2-ir/) into backend-specific data and constructors, to be executed by backend methods. It is not intended to be used directly by [Qadence 2](https://github.com/pasqal-io/qadence2-core/) users, but rather those who need to implement or extend backends, quantum instruction primitives, compiler or backend directives, etc.




  !!! note
      it is advised to set up a python environment before installing the package.

  To install the current version, there is currently one option:




  Clone this repository by typing on the terminal

  ```bash
  git clone https://github.com/pasqal-io/qadence2-platforms.git
  ```

  Go to `qadence2-platforms` folder and install it using [hatch](https://hatch.pypa.io/latest/):

  ```bash
  python -m pip install hatch
  ```

  and run `hatch` to create or reuse the project environment:

  ```bash
  hatch -v shell
  ```





  This package **should not** be used directly by the user. It is used to convert [Qadence IR](https://github.com/pasqal-io/qadence2-ir) into backend-compatible data, and to execute it with extra options (provided by the compilation process, either on [Qadence 2 expressions](https://github.com/pasqal-io/qadence2-expressions) or [Qadence 2 core](https://github.com/pasqal-io/qadence2-core)).



  Qadence 2 expressions is being compiled into an IR comprised of both quantum and classical operations.



  The `backend` module exposes a single `compile_to_backend` function which accepts a `Model` and a string denoting the `backend`.



  Each submodule under `backend` is expected (1) to translate the `IR` data into backend-compatible data, (2) to provide instruction conversions from `IR` to backend, (3) to handle the storage and embedding of parameters, and (4) to implement execution process for `run`, `sample` and `expectation`.



  Example
  ```python exec="on" source="material-block" session="model"
  from qadence2_ir.types import (
      Model,
      Alloc,
      AllocQubits,
      Call,
      Assign,
      QuInstruct,
      Support,
      Load
  )


  Model(
      register = AllocQubits(
          num_qubits = 3,
          qubit_positions = [(-2,1), (0,1), (1,3)],
          grid_type = "triangular",
          grid_scale = 1.0,
          options = {"initial_state": "010"}
      ),
      inputs = {
          "x": Alloc(1, trainable=False),
          "t": Alloc(1, trainable=False),      # time
          "Omega": Alloc(4, trainable=True),   # 4-points amp. modulation
          "delta": Alloc(1, trainable=False), # detuning
      },
      instructions = [
          
          Assign("%0", Call("mul", 1.57, Load("x"))),
          Assign("%1", Call("sin", Load("%0"))),
          QuInstruct("rx", Support(target=(0,)), Load("%1")),
          
          QuInstruct("h", Support.target_all()),
          QuInstruct("not", Support(target=(1,), control=(0,))),
          QuInstruct(
  		        "qubit_dyn",
  		        Support(control=(0,), target=(2,)),
  		        Load("t"),
  		        Load("Omega"),
  		        Load("delta"),
  		    )
      ],
      directives = {"digital-analog": True},
  )
  ```

  Compiling a `pyqtorch` circuit and computing gradients using `torch.autograd`

  ```python exec="on" source="material-block" session="model"
  import torch
  import pyqtorch as pyq
  from qadence2_ir.types import (
      Model, Alloc, AllocQubits, Load, Call, Support, QuInstruct, Assign
  )

  from qadence2_platforms.compiler import compile_to_backend


  model = Model(
      register=AllocQubits(num_qubits=2),
      inputs={
          "x": Alloc(size=1, trainable=False),
      },
      instructions=[
          Assign("%0", Call("mul", 1.57, Load("x"))),
          Assign("%1", Call("sin", Load("%0"))),
          QuInstruct("rx", Support(target=(0,)), Load("%1")),
          QuInstruct("not", Support(target=(1,), control=(0,))),
      ],
      directives={"digital": True},
  )
  api = compile_to_backend(model, "pyqtorch")
  f_params = {"x": torch.rand(1, requires_grad=True)}
  wf = api.run(state=pyq.zero_state(2), values=f_params)
  dfdx = torch.autograd.grad(wf, f_params["x"], torch.ones_like(wf))[0]
  ```



  !!! note
      Documentation in progress.




  Before making a contribution, please review our [code of conduct](docs/getting_started/CODE_OF_CONDUCT.md).

  - **Submitting Issues:** To submit bug reports or feature requests, please use our [issue tracker](https://github.com/pasqal-io/qadence2-platforms/issues).
  - **Developing in qadence 2 platforms:** To learn more about how to develop within `qadence 2 platforms`, please refer to [contributing guidelines](docs/getting_started/CONTRIBUTING.md).


pkgId: 12c7d850527569d6347405125620e38b117e0a6aa3fcbcdd4497066300418c3e
name: python-qandle-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for qandle
url: https://pypi.org/project/qandle/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qandle-0.1.6-1.src.rpm
location_href: Packages/python-qandle-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  **QANDLE** is a fast and simple quantum state-vector simulator for hybrid machine learning using the PyTorch library.
  Documentation and examples can be found in the [QANDLE documentation](https://gstenzel.github.io/qandle/), the code resides on [GitHub](https://github.com/gstenzel/qandle).
  The paper can be found on [arXiv](https://arxiv.org/abs/2404.09213).


  ```bash
  pip install qandle
  ```


  ```python
  import torch
  import qandle


  circuit = qandle.Circuit(
      layers=[
          
          qandle.AngleEmbedding(num_qubits=2),
          
          qandle.RX(qubit=1),
          
          qandle.RY(qubit=0, theta=torch.tensor(0.2)),
          
          qandle.RX(qubit=0, name="data_reuploading"),
          
          qandle.RY(qubit=1, remapping=None),
          qandle.CNOT(control=0, target=1),
          qandle.MeasureProbability(),
      ]
  )


  input_state = torch.rand(circuit.num_qubits, dtype=torch.float) # random input
  data_reuploading = torch.rand(1, dtype=torch.float) # random data reuploading input


  circuit(input_state, data_reuploading=data_reuploading)
  ```


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


  If you use QANDLE in your research, please cite the following paper:
  ```bbl
  @misc{qandle2024,
        title={Qandle: Accelerating State Vector Simulation Using Gate-Matrix Caching and Circuit Splitting},
        author={Gerhard Stenzel and Sebastian Zielinski and Michael Kölle and Philipp Altmann and Jonas Nüßlein and Thomas Gabor},
        year={2024},
        eprint={2404.09213},
        archivePrefix={arXiv},
        primaryClass={quant-ph}
  }
  ```


pkgId: a050b063bc93503daf3b735e76d01e92139a473ecac09e313214a4a6ddd37047
name: python-qapp-common-help
arch: noarch
version: 0.0.8.3
epoch: 0
release: 1
summary: Development documents and examples for qapp-common
url: https://citynow.asia/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qapp-common-0.0.8.3-1.src.rpm
location_href: Packages/python-qapp-common-help-0.0.8.3-1.noarch.rpm
checksum_type: sha256
description:
  - Add pennylane in enum sdk
  - Change function in `device.py` to protected to override in pennylane sdk

rpm_license:
  The MIT License (MIT) Copyright © CITYNOW Co. Ltd. All rights reserved.  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: d1df9d0b856c53422a27aea41236b47565fd53bac41ecf6fc790654117290e8f
name: python-qase-pytest-help
arch: noarch
version: 6.1.10
epoch: 0
release: 1
summary: Development documents and examples for qase-pytest
url: https://qase.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qase-pytest-6.1.10-1.src.rpm
location_href: Packages/python-qase-pytest-help-6.1.10-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://lxgaming.github.io/badges/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  To install the latest version, run:

  ```sh
  pip install pre qase-pytest
  ```



  The new version 6.x of the Pytest reporter has breaking changes.
  To migrate from versions 4.x or 5.x, follow the [upgrade guide](docs/UPGRADE.md).



  Qase Pytest Reporter is configured in multiple ways:

  - using a config file `qase.config.json`
  - using environment variables
  - using command line options

  Environment variables override the values given in the config file,
  and command line options override both other values.

  Configuration options are described in the
  [configuration reference](docs/CONFIGURATION.md).




  ```json
  {
    "mode": "testops",
    "fallback": "report",
    "testops": {
      "project": "YOUR_PROJECT_CODE",
      "api": {
        "token": "YOUR_API_TOKEN",
        "host": "qase.io"
      },
      "run": {
        "title": "Test run title"
      },
      "batch": {
        "size": 100
      }
    },
    "report": {
      "driver": "local",
      "connection": {
        "local": {
          "path": "./build/qase-report",
          "format": "json"
        }
      }
    },
    "framework": {
      "pytest": {
        "captureLogs": true
      }
    },
    "environment": "local"
  }
  ```





  To link the automated tests with the test cases in Qase TestOps, use the `@qase.id()` decorator.
  Other test data, such as case title, system and custom fields,
  can be added with `@qase.title()` and `@qase.fields()`:

  ```python
  from qase.pytest import qase

  @qase.id(13)
  @qase.title("My first test")
  @qase.fields(
      ("severity", "critical"),
      ("priority", "high"),
      ("layer", "unit"),
      ("description", "Try to login to Qase TestOps using login and password"),
      ("preconditions", "*Precondition 1*. Markdown is supported."),
  )
  def test_example_1():
      pass
  ```

  Each unique number can only be assigned once to the class or function being used.



  To exclude a particular test from the report, use the `@qase.ignore` decorator:

  ```python
  from qase.pytest import qase

  @qase.ignore
  def test_example_1():
      pass
  ```



  - PASSED - when test passed
  - FAILED - when test failed with `AssertionError`
  - BLOCKED - when test failed with any other exception
  - SKIPPED - when test has been skipped



  To capture the network logs, enable the `http` option in the `framework.capture` section
  of the configuration file.

  The Qase Pytest reporter will capture all HTTP requests and responses
  and save them as a test steps automatically.



  To upload screenshots, logs, and other information to Qase.io,
  use `qase.attach()`.
  It works both with files in the filesystem and with data available in the code.
  There is no limit on the amount of attachments from a single test.

  ```python
  import pytest
  from qase.pytest import qase

  @qase.title("File attachments")
  def test_example_1():
      
      qase.attach("/path/to/file", "/path/to/file/2")
      
      qase.attach(
          ("/path/to/file/1", "application/json"),
          ("/path/to/file/3", "application/xml"),
      )

  @pytest.fixture(scope="session")
  def driver():
      driver = webdriver.Chrome()
      yield driver
      logs = "\n".join(str(row) for row in driver.get_log('browser')).encode('utf-8')
      
      qase.attach((logs, "text/plain", "browser.log"))
      driver.quit()

  @qase.id(12)
  def test_example_2(driver):
      
      qase.attach((driver.get_screenshot_as_png(), "image/png", "result.png"))
  ```



  To mark a test step, either annotate a function with `@qase.step()`,
  or use the `with qase.step()` context:

  ```python
  from qase.pytest import qase

  @qase.step("First step") # test step name
  def some_step():
      sleep(5)

  @qase.step("Second step")  # test step name
  def another_step():
      sleep(3)



  def test_example():
      some_step()
      another_step()
      
      with qase.step("Third step"):
          sleep(1)
  ```



  By default, qase-pytest will create a new test run in Qase TestOps
  and report results to this test run.
  To provide a custom name for this run, add
  the option `--qase-testops-run-title`.

  ```bash
  pytest \
      --qase-mode=testops \
      --qase-testops-api-token=<your api token here> \
      --qase-testops-project=PRJCODE \ # project, where your testrun would be created
      --qase-testops-run-title=My\ First\ Automated\ Run
  ```



  Test results can be reported to an existing test run in Qase using its ID.
  This is useful when a test run combines tests from multiple sources:

  * manual and automated
  * autotests from different frameworks
  * tests running in multiple shards on different machines

  For example, if the test run has ID=3, the following command will
  run tests and report results to this test run:

  ```bash
  pytest \
      --qase-mode=testops \
      --qase-testops-api-token=<your api token here> \
      --qase-testops-project=PRJCODE \ # project, where the test run is created
      --qase-testops-run-id=3 # testrun id
  ```



  Create a new testrun base on a testplan. Testrun in Qase TestOps will contain only those
  test results. `qase-pytest` supports selective execution.

  ```bash
  pytest \
      --qase-mode=testops \
      --qase-testops-api-token=<your api token here> \
      --qase-testops-project=PRJCODE \ # project, where your testrun exists in
      --qase-testops-plan-id=3 # testplan id
  ```


pkgId: ad72c78c3a7861c447e3a440eb175ff97a6f9cb53a491f9615899926342bd3d8
name: python-qase-python-commons-help
arch: noarch
version: 3.2.4
epoch: 0
release: 1
summary: Development documents and examples for qase-python-commons
url: https://github.com/qase-tms/qase-python/tree/main/qase-python-commons
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qase-python-commons-3.2.4-1.src.rpm
location_href: Packages/python-qase-python-commons-help-3.2.4-1.noarch.rpm
checksum_type: sha256
description:
  This package contains reporters for Qase TestOps and Qase Report that are used in [qase-pytest](https://github.com/qase-tms/qase-python/tree/master/qase-pytest) and [qase-robotframework](https://github.com/qase-tms/qase-python/tree/master/qase-robotframework).



  `pip install qase-python-commons`


pkgId: a62c87a2d8b510d7fb766d17e7d547aa4dab196940d319a60cdb2e4aecac2013
name: python-qbraid-core-help
arch: noarch
version: 0.1.32
epoch: 0
release: 1
summary: Development documents and examples for qbraid-core
url: https://docs.qbraid.com/core
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qbraid-core-0.1.32-1.src.rpm
location_href: Packages/python-qbraid-core-help-0.1.32-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation](https://img.shields.io/badge/Documentation-DF0982)](https://sdk.qbraid.com/projects/core/en/latest/)
  [![codecov](https://codecov.io/gh/qBraid/qbraid-core/graph/badge.svg?token=vnZxySTsW2)](https://codecov.io/gh/qBraid/qbraid-core)
  [![PyPI version](https://img.shields.io/pypi/v/qbraid-core.svg?color=blue)](https://pypi.org/project/qbraid-core/)
  [![Python verions](https://img.shields.io/pypi/pyversions/qbraid-core.svg?color=blue)](https://pypi.org/project/qbraid-core/)
  [![GitHub](https://img.shields.io/badge/issue_tracking-github-blue?logo=github)](https://github.com/qBraid/community/issues)

  Python library providing core abstractions for software development within the qBraid ecosystem, and a low-level interface to a growing array of qBraid cloud services. The qbraid-core package forms the foundational base for the [qBraid CLI](https://pypi.org/project/qbraid-cli/), the [qBraid SDK](https://pypi.org/project/qbraid/), and the
  [jupyter-environment-manager](https://pypi.org/project/jupyter-environment-manager/).

  You can find the latest, most up to date, documentation [here](https://sdk.qbraid.com/projects/core/en/latest/), including a list of services that are supported.



  You can install qbraid-core from PyPI with:

  ```bash
  python -m pip install qbraid-core
  ```



  After installing qbraid-core, you must configure your account credentials:

  1. Create a qBraid account or log in to your existing account by visiting
     [account.qbraid.com](https://account.qbraid.com/)
  2. Copy your API Key token from the left side of
      your [account page](https://account.qbraid.com/):
  3. Save your API key from step 2 in local configuration file `~/.qbraid/qbraidrc`, where `~` corresponds to your home (`$HOME`) directory:

  ```bash
  [default]
  api-key = YOUR_KEY
  url = https://api.qbraid.com/api
  ```

  Or generate your `~/.qbraid/qbraidrc` file via the qbraid-core Python interface:

  ```python
  >>> from qbraid_core import QbraidSession
  >>> session = QbraidSession(api_key='API_KEY')
  >>> session.save_config()
  >>> session.get_available_services()
  ['environments', 'quantum']
  ```

  Other credential configuration methods can be found [here](https://docs.qbraid.com/cli/api-reference/qbraid_configure).



  After configuring your qBraid credentials, verify your setup by running the following from a Python interpreter:

  ```python
  >>> import qbraid_core
  >>> quantum_client = qbraid_core.client('quantum')
  >>> device_data = quantum_client.search_devices()
  >>> for item in device_data:
  ...     print(item['qbraid_id'])
  ```



  - For feature requests and bug reports: [Submit an issue](https://github.com/qBraid/community/issues)
  - For discussions and/or specific questions about qBraid services, [join our discord community](https://discord.gg/KugF6Cnncm)
  - For questions that are more suited for a forum, post to [Stack Overflow](https://stackoverflow.com/) with the [`qbraid`](https://stackoverflow.com/questions/tagged/qbraid) tag.



  The "Launch on qBraid" button (below) can be added to any public GitHub
  repository. Clicking on it automaically opens qBraid Lab, and performs a
  `git clone` of the project repo into your account's home directory. Copy the
  code below, and replace `YOUR-USERNAME` and `YOUR-REPOSITORY` with your GitHub
  info.

  [<img src="https://qbraid-static.s3.amazonaws.com/logos/Launch_on_qBraid_white.png" width="150">](https://account.qbraid.com?gitHubUrl=https://github.com/qBraid/qBraid.git)

  Use the badge in your project's `README.md`:

  ```markdown
  [<img src="https://qbraid-static.s3.amazonaws.com/logos/Launch_on_qBraid_white.png" width="150">](https://account.qbraid.com?gitHubUrl=https://github.com/YOUR-USERNAME/YOUR-REPOSITORY.git)
  ```

  Use the badge in your project's `README.rst`:

  ```rst
  .. image:: https://qbraid-static.s3.amazonaws.com/logos/Launch_on_qBraid_white.png
      :target: https://account.qbraid.com?gitHubUrl=https://github.com/YOUR-USERNAME/YOUR-REPOSITORY.git
      :width: 150px
  ```


pkgId: cf17e782cbfa25d0aa1247bbd0a5043c5a1efc51193ffca3bd757b0fb5fac2f9
name: python-qbraid-help
arch: noarch
version: 0.8.10
epoch: 0
release: 1
summary: Development documents and examples for qbraid
url: https://sdk.qbraid.com/
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qbraid-0.8.10-1.src.rpm
location_href: Packages/python-qbraid-help-0.8.10-1.noarch.rpm
checksum_type: sha256
description:
  ![Runtime Diagram](https://qbraid-static.s3.amazonaws.com/qbraid-runtime.png)

  - [User Guide](https://docs.qbraid.com/sdk/user-guide/)
  - [API Reference](https://sdk.qbraid.com/en/stable/api/qbraid.html)
  - [Example Notebooks](https://github.com/qBraid/qbraid-lab-demo)

  For the best experience, install the qBraid-SDK environment on [lab.qbraid.com](https://lab.qbraid.com). Login (or
  [create an account](https://account.qbraid.com)) and follow the steps to
  [install an environment](https://docs.qbraid.com/lab/user-guide/environments#install-environment). Using the SDK on [qBraid Lab](https://docs.qbraid.com/lab/user-guide/overview) means direct, pre-configured access to QPUs from IonQ, Oxford Quantum Circuits, QuEra, Rigetti, and IQM, as well as on-demand simulators from qBraid and AWS. See [qBraid Quantum Jobs](https://docs.qbraid.com/lab/user-guide/quantum-jobs) for more.

  The qBraid-SDK, and all of its dependencies, can be installed using pip:
  ```bash
  pip install qbraid
  ```
  You can also [install from source](CONTRIBUTING.md#installing-from-source) by cloning this repository and running a pip install command in the root directory of the repository:
  ```bash
  git clone https://github.com/qBraid/qBraid.git
  cd qBraid
  pip install .
  ```
  > *Note:* The qBraid-SDK requires Python 3.9 or greater.
  To use [qBraid Runtime](https://docs.qbraid.com/sdk/user-guide/runtime) locally, you must also install the necessary extras and configure your account credentials according to the device(s) that you are targeting. Follow the linked, provider-specific, instructions for the [QbraidProvider](https://docs.qbraid.com/sdk/user-guide/runtime_native), [BraketProvider](https://docs.qbraid.com/sdk/user-guide/runtime_braket), [QiskitRuntimeProvider](https://docs.qbraid.com/sdk/user-guide/runtime_ibm), [IonQProvider](https://docs.qbraid.com/sdk/user-guide/runtime_ionq), and [OQCProvider](https://docs.qbraid.com/sdk/user-guide/runtime_oqc), as applicable.


  You can view the version of the qBraid-SDK you have installed and get detailed information about the installation within Python using the following commands:
  ```python
  In [1]: import qbraid
  In [2]: qbraid.__version__
  In [3]: qbraid.about()
  ```

  Graph-based approach to quantum program type conversions.
  Below, `QPROGRAM_REGISTRY` maps shorthand identifiers for supported quantum programs, each corresponding to a type in the typed `QPROGRAM` Union. For example, 'qiskit' maps to `qiskit.QuantumCircuit` in `QPROGRAM`. Notably, 'qasm2' and 'qasm3' both represent raw OpenQASM strings. This arrangement simplifies targeting and transpiling between different quantum programming frameworks.
  ```python
  >>> from qbraid import QPROGRAM_REGISTRY
  >>> QPROGRAM_REGISTRY
  {'cirq': cirq.circuits.circuit.Circuit,
   'qiskit': qiskit.circuit.quantumcircuit.QuantumCircuit,
   'pennylane': pennylane.tape.tape.QuantumTape,
   'pyquil': pyquil.quil.Program,
   'pytket': pytket._tket.circuit.Circuit,
   'braket': braket.circuits.circuit.Circuit,
   'openqasm3': openqasm3.ast.Program,
   'pyqir': pyqir.Module,
   'qasm2': str,
   'qasm3': str}
  ```
  Pass any registered quantum program along with a target package from
  `QPROGRAM_REGISTRY` to "transpile" your circuit to a new program type:
  ```python
  >>> from qbraid import random_circuit, transpile
  >>> qiskit_circuit = random_circuit("qiskit")
  >>> cirq_circuit = transpile(qiskit_circuit, "cirq")
  >>> print(qiskit_circuit)
            ┌────────────┐
  q_0: ──■──┤ Rx(3.0353) ├
       ┌─┴─┐└───┬────┬───┘
  q_1: ┤ H ├────┤ √X ├────
       └───┘    └────┘
  >>> print(cirq_circuit)
  0: ───@───Rx(0.966π)───
        │
  1: ───H───X^0.5────────
  ```
  Behind the scenes, the qBraid-SDK uses [rustworkx](https://www.rustworkx.org/) to create a
  directional graph that maps all possible conversions between supported program types:
  ```python
  from qbraid import ConversionGraph

  graph = ConversionGraph()
  graph.plot(legend=True)
  ```
  <img src="https://qbraid-static.s3.amazonaws.com/conversion_graph_extras_legend.png" style="width: 65%;">
  You can use the native conversions supported by qBraid, or define your own. For [example](https://docs.qbraid.com/sdk/user-guide/transpiler#conversion-graph):
  ```python
  from unittest.mock import Mock
  from qbraid import Conversion, register_program_type

  register_program_type(Mock, alias="mock")

  example_qasm3_to_mock_func = lambda x: x
  conversion = Conversion("qasm3", "mock", example_qasm3_to_mock_func)
  graph.add_conversion(conversion)

  graph.plot(seed=20, k=3, legend=True)
  ```

  Run experiements using on-demand simulators provided by qBraid. Retrieve a list of available devices:
  ```python
  from qbraid import QbraidProvider
  provider = QbraidProvider()
  devices = provider.get_devices()
  ```
  Or, instantiate a known device by ID and submit quantum jobs from any supported program type:
  ```python
  device = provider.get_device("qbraid_qir_simulator")
  jobs = device.run([qiskit_circuit, braket_circuit, cirq_circuit, qasm3_str], shots=1000)
  results = [job.result() for job in jobs]
  batch_counts = [result.data.get_counts() for result in results]
  print(batch_counts[0])

  ```
  And visualize the results:
  ```python
  from qbraid.visualization import plot_distribution, plot_histogram
  plot_distribution(batch_counts)
  plot_histogram(batch_counts)
  ```

  [![Community](https://img.shields.io/badge/Community-DF0982)](https://github.com/qBraid/community)
  [![GitHub Issues](https://img.shields.io/badge/issue_tracking-github-blue?logo=github)](https://github.com/qBraid/qBraid/issues)
  [![Stack Exchange](https://img.shields.io/badge/StackExchange-qbraid-orange?logo=stackexchange)](https://quantumcomputing.stackexchange.com/questions/tagged/qbraid)
  [![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?logo=discord&logoColor=white)](https://discord.gg/TPBU2sa8Et)
  - Interested in contributing code, or making a PR? See
    [CONTRIBUTING.md](CONTRIBUTING.md)
  - For feature requests and bug reports:
    [Submit an issue](https://github.com/qBraid/qBraid/issues)
  - For discussions, and specific questions about the qBraid-SDK [join our discord community](https://discord.gg/TPBU2sa8Et)
  - For questions that are more suited for a forum, post to [QCSE](https://quantumcomputing.stackexchange.com/) with the [`qbraid`](https://quantumcomputing.stackexchange.com/questions/tagged/qbraid) tag.

  The "Launch on qBraid" button (top) can be added to any public GitHub
  repository. Clicking on it automaically opens qBraid Lab, and performs a
  `git clone` of the project repo into your account's home directory. Copy the
  code below, and replace `YOUR-USERNAME` and `YOUR-REPOSITORY` with your GitHub
  info.
  Use the badge in your project's `README.md`:
  ```markdown
  [<img src="https://qbraid-static.s3.amazonaws.com/logos/Launch_on_qBraid_white.png" width="150">](https://account.qbraid.com?gitHubUrl=https://github.com/YOUR-USERNAME/YOUR-REPOSITORY.git)
  ```
  Use the badge in your project's `README.rst`:
  ```rst
  ```

  [GNU General Public License v3.0](LICENSE)


pkgId: 695f540278edfd2061eee5ef78efdbc02bc7082b142c44c569e60f2d703932e9
name: python-qbusmqttapi-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for qbusmqttapi
url: https://github.com/Qbus-iot/qbusmqttapi
rpm_license: MIT License 2024
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qbusmqttapi-1.2.0-1.src.rpm
location_href: Packages/python-qbusmqttapi-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Python MQTT API for Qbus Home Automation

  This package is an extention for the Qbus integration in Home Assistant.

  It includes all convertions from the mqtt protocol which enables Home Assistant to communicate with Qbus Controllers.

  For more information, please visi https://iot.qbus.be


pkgId: c7d9eff9976f83a088e50c219c337d7dca0f6e17dd802d4c6c39f33bcf604c4e
name: python-qc-robyn-admin-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for qc-robyn-admin
url: https://github.com/0x7eQiChen/robyn-admin
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qc-robyn-admin-0.1.1-1.src.rpm
location_href: Packages/python-qc-robyn-admin-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A simple yet powerful admin interface for Robyn framework.

  orm use Tortoise ORM

  read more info in [en_doc](https://qc-robyn-admin.readthedocs.io/en/latest/en/)




  You can install robyn-admin via pip:

  ```
  bash
  pip install qc_robyn_admin

  pip install git+https://github.com/0x7eQiChen/qc_robyn_admin.git
  ```


pkgId: b0ea83c4203e46ddd99c27f7fbd31eb8e9f2a796a6dcd7f82f7d1a5daa8312fd
name: python-qcio-help
arch: noarch
version: 0.12.0
epoch: 0
release: 1
summary: Development documents and examples for qcio
url: https://github.com/coltonbh/qcio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qcio-0.12.0-1.src.rpm
location_href: Packages/python-qcio-help-0.12.0-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/qcio.svg)](https://pypi.python.org/pypi/qcio)
  [![image](https://img.shields.io/pypi/l/qcio.svg)](https://pypi.python.org/pypi/qcio)
  [![image](https://img.shields.io/pypi/pyversions/qcio.svg)](https://pypi.python.org/pypi/qcio)
  [![Actions status](https://github.com/coltonbh/qcio/workflows/Tests/badge.svg)](https://github.com/coltonbh/qcio/actions)
  [![Actions status](https://github.com/coltonbh/qcio/workflows/Basic%20Code%20Quality/badge.svg)](https://github.com/coltonbh/qcio/actions)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)

  Elegant and intuitive data structures for quantum chemistry, featuring seamless Jupyter Notebook visualizations. Also featuring NIST/CODATA2022 core physical constants and a Periodic Table.

  Inspired by [QCElemental](https://github.com/MolSSI/QCElemental). Built for consistency and rapid development.

  `qcio` works in harmony with a suite of other quantum chemistry tools for fast, structured, and interoperable quantum chemistry.



  - [qcio](https://github.com/coltonbh/qcio) - Elegant and intuitive data structures for quantum chemistry, featuring seamless Jupyter Notebook visualizations. [Documentation](https://qcio.coltonhicks.com)
  - [qcparse](https://github.com/coltonbh/qcparse) - A library for efficient parsing of quantum chemistry data into structured `qcio` objects.
  - [qcop](https://github.com/coltonbh/qcop) - A package for operating quantum chemistry programs using `qcio` standardized data structures. Compatible with `TeraChem`, `psi4`, `QChem`, `NWChem`, `ORCA`, `Molpro`, `geomeTRIC` and many more.
  - [BigChem](https://github.com/mtzgroup/bigchem) - A distributed application for running quantum chemistry calculations at scale across clusters of computers or the cloud. Bring multi-node scaling to your favorite quantum chemistry program.
  - `ChemCloud` - A [web application](https://github.com/mtzgroup/chemcloud-server) and associated [Python client](https://github.com/mtzgroup/chemcloud-client) for exposing a BigChem cluster securely over the internet.



  ```bash
  pip install qcio
  ```



  `qcio` is built around a simple mental model: `Input` objects are used to define inputs for a quantum chemistry program, and `Output` objects are used to capture the outputs from a quantum chemistry program.

  All `qcio` objects can be serialized and saved to disk by calling `.save("filename.json")` and loaded from disk by calling `.open("filename.json")`. `qcio` supports `json`, `yaml`, and `toml` file formats. Binary data will be automatically base64 encoded and decoded when saving and loading.





  ```python
  from qcio import Structure, ProgramInput

  caffeine = Structure.open("caffeine.xyz")

  prog_input = ProgramInput(
      structure=caffeine,
      calctype="energy",
      keywords={"purify": "no", "restricted": False},
      model={"method": "hf", "basis": "sto-3g"},
      extras={"comment": "This is a comment"}, # Anything extra not in the schema
  )

  prog_input.add_file("wfn.dat")
  prog_input.keywords["initial_guess"] = "wfn.dat"


  prog_input.save("input.json")


  prog_input = ProgramInput.open("input.json")
  ```

  `Structure` objects can be opened from and saved as xyz files or saved to disk as `.json`, `.yaml`, or `.toml` formats by changing the extension of the file. For `.xyz` files precision can be controlled by passing the `precision` argument to the `save` method.

  ```python
  caffeine = Structure.open("caffeine.xyz")
  caffeine.save("caffeine2.json", precision=6)
  caffeine.save("caffeine.toml")
  ```



  `DualProgramInput` objects can be used to power workflows that require multiple QC programs. For example, a geometry optimization workflow might use `geomeTRIC` to power the optimization and use `terachem` to compute the energies and gradients.

  ```python
  from qcio import Structure, DualProgramInput

  caffeine = Structure.open("caffeine.xyz")

  prog_input = DualProgramInput(
      structure=caffeine,
      calctype="optimization",
      keywords={"maxiter": 250},
      subprogram="terachem",
      subprogram_args = {
          "model": {"method": "hf", "basis": "sto-3g"},
          "keywords": {"purify": "no", "restricted": False},
      },
      extras={"comment": "This is a comment"}, # Anything extra not in the schema
  )
  ```



  `qcio` also supports the native file formats of each QC program with a `FileInput` object. Assume you have a directory like this with your input files for `psi4`:

  ```
  psi4/
      input.dat
      geometry.xyz
      wfn.dat
  ```

  You can collect these native files and any associated command line arguments needed to specify a calculation into a `FileInput` object like this:

  ```python
  from qcio import FileInput
  psi4_input = FileInput.from_directory("psi4")


  psi4_input.files



  psi4_input.cmdline_args.extend(["-n", "4"])


  psi4_input.save_files("psi4")
  ```



  Objects are immutable by default so if you want to modify an object cast it to a dictionary, make the desired modification, and then instantiate a new object. This prevents accidentally modifying objects that may already be referenced in other calculations--perhaps as `.input_data` on an `Output` object.

  ```python

  new_input_dict = prog_input.model_dumps()
  new_input_dict["model"]["method"] = "b3lyp"

  new_prog_input = ProgramInput(**new_input_dict)
  ```





  All computations result in a `ProgramOutput` object that encapsulates the core results, files, stdout, and additional details of the calculation. A `ProgramOutput` object has the following attributes:

  ```python
  output.input_data # Input data used by the QC program
  output.success # Whether the calculation succeeded or failed
  output.results # All structured results from the calculation
  output.results.files # Any files returned by the calculation
  output.stdout # Stdout log from the calculation
  output.pstdout # Shortcut to print out the stdout in human readable format
  output.provenance # Provenance information about the calculation
  output.extras # Any extra information not in the schema
  ```

  The `.results` attribute on a `ProgramOutput` is polymorphic and may be either `Files`, `SinglePointResults` or `OptimizationResults` depending on the type of calculation requested. Available attributes for each result type can be found by calling `dir()` on the object.

  ```python
  dir(output.results)
  ```

  Results can be saved to disk in json, yaml, or toml format by calling `.save("filename.{json/yaml/toml}")` and loaded from disk by calling `.open("filename.{json/yaml/toml}")`.



  Visualize all your results with a single line of code!

  First install the visualization module:

  ```sh
  pip install qcio[view]
  ```

  or if your shell requires `''` around arguments with brackets:

  ```sh
  pip install 'qcio[view]'
  ```

  Then in a Jupyter notebook import the `qcio` view module and call `view.view(...)` passing it one or any number of `qcio` objects you want to visualizing including `Structure` objects or any `ProgramOutput` object. You may also pass an array of `titles` and/or `subtitles` to add additional information to the molecular structure display. If no titles are passed `qcio` with look for `Structure` identifiers such as a name or SMILES to label the `Structure`.

  ![Structure Viewer](https://public.coltonhicks.com/assets/qcio/structure_viewer.png)

  Seamless visualizations for `ProgramOutput` objects make results analysis easy!

  ![Optimization Viewer](https://public.coltonhicks.com/assets/qcio/optimization_viewer.png)

  Single point calculations display their results in a table.

  ![Single Point Viewer](https://public.coltonhicks.com/assets/qcio/single_point_viewer.png)

  If you want to use the HTML generated by the viewer to build your own dashboards use the functions inside of `qcio.view.py` that begin with the word `generate_` to create HTML you can insert into any dashboard.



  Core physical constants are available in the `constants` module. The source of all values is documented and kept up-to-date with the latest NIST/CODATA2022 values.

  ```python
  from qcio import constants

  constants.BOHR_TO_ANGSTROM
  ```

  Periodic Table is also available from the `constants` module.

  ```python
  from qcio.constants import periodic_table as pt

  pt.He.symbol
  pt.He.number
  pt.He.name
  pt.Ht.mass
  pt.He.group
  pt.He.period
  pt.He.block
  pt.He.electron_confg

  group_6 = pt.group(6)
  period_3 = pt.period(3)


  pt.data_source
  pt.data_url
  ```



  If you have any issues with `qcio` or would like to request a feature, please open an [issue](https://github.com/coltonbh/qcio/issues).


pkgId: c0b52b2680f0ad3e497179c1c48f2caa556193df94a3100c92dc8d1bf155a301
name: python-qermit-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for qermit
url: https://pypi.org/project/qermit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qermit-0.7.0-1.src.rpm
location_href: Packages/python-qermit-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/qermit.svg)](https://badge.fury.io/py/qermit)

  Qermit is a python module for running error-mitigation protocols on quantum processors.
  It is an extension to the [pytket](https://docs.quantinuum.com/tket) quantum computing toolkit.

  This repository contains source code and API documentation.
  For details on building the docs please see `docs/README.md`



  To install, run:
  ```
  pip install qermit
  ```
  You may also wish to install the package from source:
  ```
  pip install -e .
  ```
  A `poetry.lock` file is included for use with [poetry](https://python-poetry.org/docs/cli/#install).

  API documentation can be found at [qerm.it](https://qerm.it).



  Please file bugs on the Github
  [issue tracker](https://github.com/CQCL/Qermit/issues).



  Pull requests or feature suggestions are very welcome.
  To make a PR, first fork the repository, make your proposed changes, and open a PR from your fork.



  Style checks are run by continuous integration.
  To install the dependencies required to run them locally run:
  ```
  pip install qermit[tests]
  ```



  This repository uses [ruff](https://docs.astral.sh/ruff/) for formatting and linting.
  To check if your changes meet these standards run:
  ```
  ruff check
  ruff format --check
  ```



  [mypy](https://mypy.readthedocs.io/en/stable/) is used as a static type checker.
  ```
  mypy -p qermit
  ```



  Tests are run by continuous integration.
  To install the dependencies required to run them locally run:
  ```
  pip install qermit[tests]
  ```

  To run tests use:
  ```
  cd tests
  pytest
  ```

  When adding a new feature, please add a test for it.
  When fixing a bug, please add a test that demonstrates the fix.



  If you wish to cite Qermit, we recommend citing our [benchmarking paper](https://quantum-journal.org/papers/q-2023-07-13-1059/) where possible.


pkgId: 2e136db8c7765eecc2148cb7a70801e9a8717337ce3b9a833b718dcd2d1e3193
name: python-qg-botsdk
arch: noarch
version: 4.3.0
epoch: 0
release: 1
summary: easy-to-use SDK for Tencent QQ guild robot
url: https://github.com/GLGDLY/qg_botsdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qg-botsdk-4.3.0-1.src.rpm
location_href: Packages/python-qg-botsdk-4.3.0-1.noarch.rpm
checksum_type: sha256
description:
  对于使用python进行频道官方机器人开发而言，市面上确实有不同的sdk可以选用，但其很多只提供异步asyncio+类继承的开发方式，对于不会相关技巧的朋友们，尤其新手，会有开发难度。
  为此，qg_botsdk相应提供了另一个选择，这一款sdk虽然同样使用asyncio编写sdk底层，但其同时提供了threading和asyncio封装下的应用层调用，以抽象化封装的库编写方式，极大地降低应用层的开发难度。


pkgId: 02d160712c43edec79d6b89730bae698c3e348a2072fc5ec4e8821fc4c3e0ed0
name: python-qi-compute-api-client-help
arch: noarch
version: 0.39.0
epoch: 0
release: 1
summary: Development documents and examples for qi-compute-api-client
url: https://github.com/QuTech-Delft/compute-api-client
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qi-compute-api-client-0.39.0-1.src.rpm
location_href: Packages/python-qi-compute-api-client-help-0.39.0-1.noarch.rpm
checksum_type: sha256
description:
  *AlgorithmsApi* | [**create_algorithm_algorithms_post**](compute_api_client/docs/AlgorithmsApi.md#create_algorithm_algorithms_post) | **POST** /algorithms | Create algorithm
  *AlgorithmsApi* | [**delete_algorithm_algorithms_id_delete**](compute_api_client/docs/AlgorithmsApi.md#delete_algorithm_algorithms_id_delete) | **DELETE** /algorithms/{id} | Destroy algorithm
  *AlgorithmsApi* | [**read_algorithm_algorithms_id_get**](compute_api_client/docs/AlgorithmsApi.md#read_algorithm_algorithms_id_get) | **GET** /algorithms/{id} | Retrieve algorithm
  *AlgorithmsApi* | [**read_algorithms_algorithms_get**](compute_api_client/docs/AlgorithmsApi.md#read_algorithms_algorithms_get) | **GET** /algorithms | List algorithms
  *AlgorithmsApi* | [**update_algorithm_algorithms_id_put**](compute_api_client/docs/AlgorithmsApi.md#update_algorithm_algorithms_id_put) | **PUT** /algorithms/{id} | Update algorithm
  *BackendApi* | [**create_backend_backends_post**](compute_api_client/docs/BackendApi.md#create_backend_backends_post) | **POST** /backends | Create backend
  *BackendApi* | [**read_backend_backends_id_get**](compute_api_client/docs/BackendApi.md#read_backend_backends_id_get) | **GET** /backends/{id} | Retrieve backend
  *BackendApi* | [**read_backend_self_backends_me_get**](compute_api_client/docs/BackendApi.md#read_backend_self_backends_me_get) | **GET** /backends/me | Retrieve backend
  *BackendApi* | [**read_backends_backends_get**](compute_api_client/docs/BackendApi.md#read_backends_backends_get) | **GET** /backends | List backends
  *BackendApi* | [**update_backend_self_backends_me_patch**](compute_api_client/docs/BackendApi.md#update_backend_self_backends_me_patch) | **PATCH** /backends/me | Update backend
  *BackendTypesApi* | [**read_backend_type_backend_types_id_get**](compute_api_client/docs/BackendTypesApi.md#read_backend_type_backend_types_id_get) | **GET** /backend_types/{id} | Retrieve backend type
  *BackendTypesApi* | [**read_backend_types_backend_types_get**](compute_api_client/docs/BackendTypesApi.md#read_backend_types_backend_types_get) | **GET** /backend_types/ | List backend types
  *BatchJobsApi* | [**create_batch_job_batch_jobs_post**](compute_api_client/docs/BatchJobsApi.md#create_batch_job_batch_jobs_post) | **POST** /batch_jobs | Create batch job
  *BatchJobsApi* | [**enqueue_batch_job_batch_jobs_id_enqueue_patch**](compute_api_client/docs/BatchJobsApi.md#enqueue_batch_job_batch_jobs_id_enqueue_patch) | **PATCH** /batch_jobs/{id}/enqueue | Enqueue batch job for execution
  *BatchJobsApi* | [**finish_batch_job_batch_jobs_id_finish_patch**](compute_api_client/docs/BatchJobsApi.md#finish_batch_job_batch_jobs_id_finish_patch) | **PATCH** /batch_jobs/{id}/finish | Finish batch job
  *BatchJobsApi* | [**peek_batch_job_batch_jobs_peek_patch**](compute_api_client/docs/BatchJobsApi.md#peek_batch_job_batch_jobs_peek_patch) | **PATCH** /batch_jobs/peek | Peek batch job
  *BatchJobsApi* | [**pop_batch_job_batch_jobs_pop_patch**](compute_api_client/docs/BatchJobsApi.md#pop_batch_job_batch_jobs_pop_patch) | **PATCH** /batch_jobs/pop | Take batch job
  *BatchJobsApi* | [**read_batch_jobs_batch_jobs_get**](compute_api_client/docs/BatchJobsApi.md#read_batch_jobs_batch_jobs_get) | **GET** /batch_jobs | List batch jobs
  *BatchJobsApi* | [**unpop_batch_job_batch_jobs_unpop_patch**](compute_api_client/docs/BatchJobsApi.md#unpop_batch_job_batch_jobs_unpop_patch) | **PATCH** /batch_jobs/unpop | Take batch job
  *CommitsApi* | [**compile_commit_commits_id_compile_post**](compute_api_client/docs/CommitsApi.md#compile_commit_commits_id_compile_post) | **POST** /commits/{id}/compile | Compile file in a commit
  *CommitsApi* | [**create_commit_commits_post**](compute_api_client/docs/CommitsApi.md#create_commit_commits_post) | **POST** /commits | Create commit
  *CommitsApi* | [**delete_commit_commits_id_delete**](compute_api_client/docs/CommitsApi.md#delete_commit_commits_id_delete) | **DELETE** /commits/{id} | Destroy commit
  *CommitsApi* | [**read_commit_commits_id_get**](compute_api_client/docs/CommitsApi.md#read_commit_commits_id_get) | **GET** /commits/{id} | Get commit by ID
  *CommitsApi* | [**read_commits_commits_get**](compute_api_client/docs/CommitsApi.md#read_commits_commits_get) | **GET** /commits | List commits
  *FilesApi* | [**create_file_files_post**](compute_api_client/docs/FilesApi.md#create_file_files_post) | **POST** /files | Create file
  *FilesApi* | [**delete_file_files_id_delete**](compute_api_client/docs/FilesApi.md#delete_file_files_id_delete) | **DELETE** /files/{id} | Destroy file
  *FilesApi* | [**read_file_files_id_get**](compute_api_client/docs/FilesApi.md#read_file_files_id_get) | **GET** /files/{id} | Retrieve file
  *FilesApi* | [**read_files_files_get**](compute_api_client/docs/FilesApi.md#read_files_files_get) | **GET** /files | List files
  *FinalResultsApi* | [**create_final_result_final_results_post**](compute_api_client/docs/FinalResultsApi.md#create_final_result_final_results_post) | **POST** /final_results | Create final result
  *FinalResultsApi* | [**read_final_result_by_job_id_final_results_job_job_id_get**](compute_api_client/docs/FinalResultsApi.md#read_final_result_by_job_id_final_results_job_job_id_get) | **GET** /final_results/job/{job_id} | Retrieve final result by job ID
  *FinalResultsApi* | [**read_final_result_final_results_id_get**](compute_api_client/docs/FinalResultsApi.md#read_final_result_final_results_id_get) | **GET** /final_results/{id} | Retrieve final result
  *HealthApi* | [**healthz_healthz_get**](compute_api_client/docs/HealthApi.md#healthz_healthz_get) | **GET** /healthz | Report health
  *JobsApi* | [**create_job_jobs_post**](compute_api_client/docs/JobsApi.md#create_job_jobs_post) | **POST** /jobs | Create job
  *JobsApi* | [**delete_job_jobs_id_delete**](compute_api_client/docs/JobsApi.md#delete_job_jobs_id_delete) | **DELETE** /jobs/{id} | Destroy job
  *JobsApi* | [**read_job_jobs_id_get**](compute_api_client/docs/JobsApi.md#read_job_jobs_id_get) | **GET** /jobs/{id} | Retrieve job
  *JobsApi* | [**read_jobs_jobs_get**](compute_api_client/docs/JobsApi.md#read_jobs_jobs_get) | **GET** /jobs | List jobs
  *JobsApi* | [**update_job_status_jobs_id_patch**](compute_api_client/docs/JobsApi.md#update_job_status_jobs_id_patch) | **PATCH** /jobs/{id} | Update Job Status
  *LanguagesApi* | [**read_language_languages_id_get**](compute_api_client/docs/LanguagesApi.md#read_language_languages_id_get) | **GET** /languages/{id} | Retrieve language
  *LanguagesApi* | [**read_languages_languages_get**](compute_api_client/docs/LanguagesApi.md#read_languages_languages_get) | **GET** /languages | List languages
  *MembersApi* | [**create_member_members_post**](compute_api_client/docs/MembersApi.md#create_member_members_post) | **POST** /members | Create member
  *MembersApi* | [**delete_member_members_id_delete**](compute_api_client/docs/MembersApi.md#delete_member_members_id_delete) | **DELETE** /members/{id} | Destroy member
  *MembersApi* | [**read_member_members_id_get**](compute_api_client/docs/MembersApi.md#read_member_members_id_get) | **GET** /members/{id} | Retrieve member
  *MembersApi* | [**read_members_members_get**](compute_api_client/docs/MembersApi.md#read_members_members_get) | **GET** /members | List members
  *MetadataApi* | [**create_metadata_self_metadata_post**](compute_api_client/docs/MetadataApi.md#create_metadata_self_metadata_post) | **POST** /metadata | Create metadata
  *MetadataApi* | [**read_metadata_by_backend_id_metadata_backend_backend_id_get**](compute_api_client/docs/MetadataApi.md#read_metadata_by_backend_id_metadata_backend_backend_id_get) | **GET** /metadata/backend/{backend_id} | Retrieve metadata by backend ID
  *MetadataApi* | [**read_metadata_metadata_id_get**](compute_api_client/docs/MetadataApi.md#read_metadata_metadata_id_get) | **GET** /metadata/{id} | Get metadata by ID
  *PermissionsApi* | [**read_permission_group_permission_groups_id_get**](compute_api_client/docs/PermissionsApi.md#read_permission_group_permission_groups_id_get) | **GET** /permission_groups/{id} | Retrieve permission groups
  *PermissionsApi* | [**read_permission_groups_permission_groups_get**](compute_api_client/docs/PermissionsApi.md#read_permission_groups_permission_groups_get) | **GET** /permission_groups/ | List permission groups
  *PermissionsApi* | [**read_permission_permissions_id_get**](compute_api_client/docs/PermissionsApi.md#read_permission_permissions_id_get) | **GET** /permissions/{id} | Retrieve permissions
  *PermissionsApi* | [**read_permissions_permissions_get**](compute_api_client/docs/PermissionsApi.md#read_permissions_permissions_get) | **GET** /permissions/ | List permissions
  *ProjectsApi* | [**create_project_projects_post**](compute_api_client/docs/ProjectsApi.md#create_project_projects_post) | **POST** /projects | Create project
  *ProjectsApi* | [**delete_project_projects_id_delete**](compute_api_client/docs/ProjectsApi.md#delete_project_projects_id_delete) | **DELETE** /projects/{id} | Destroy project
  *ProjectsApi* | [**partial_update_project_projects_id_patch**](compute_api_client/docs/ProjectsApi.md#partial_update_project_projects_id_patch) | **PATCH** /projects/{id} | Partially update project
  *ProjectsApi* | [**read_project_projects_id_get**](compute_api_client/docs/ProjectsApi.md#read_project_projects_id_get) | **GET** /projects/{id} | Retrieve project
  *ProjectsApi* | [**read_projects_projects_get**](compute_api_client/docs/ProjectsApi.md#read_projects_projects_get) | **GET** /projects | List projects
  *ProjectsApi* | [**update_project_projects_id_put**](compute_api_client/docs/ProjectsApi.md#update_project_projects_id_put) | **PUT** /projects/{id} | Update project
  *ReservationsApi* | [**create_reservation_reservations_post**](compute_api_client/docs/ReservationsApi.md#create_reservation_reservations_post) | **POST** /reservations | Create reservation
  *ReservationsApi* | [**read_reservation_reservations_id_get**](compute_api_client/docs/ReservationsApi.md#read_reservation_reservations_id_get) | **GET** /reservations/{id} | Retrieve reservation
  *ReservationsApi* | [**read_reservations_reservations_get**](compute_api_client/docs/ReservationsApi.md#read_reservations_reservations_get) | **GET** /reservations | List reservations
  *ReservationsApi* | [**terminate_reservation_reservations_id_terminate_patch**](compute_api_client/docs/ReservationsApi.md#terminate_reservation_reservations_id_terminate_patch) | **PATCH** /reservations/{id}/terminate | Terminate reservation
  *ResultsApi* | [**create_result_results_post**](compute_api_client/docs/ResultsApi.md#create_result_results_post) | **POST** /results | Create result
  *ResultsApi* | [**delete_results_by_job_id_results_job_job_id_delete**](compute_api_client/docs/ResultsApi.md#delete_results_by_job_id_results_job_job_id_delete) | **DELETE** /results/job/{job_id} | Delete results by job ID
  *ResultsApi* | [**read_result_results_id_get**](compute_api_client/docs/ResultsApi.md#read_result_results_id_get) | **GET** /results/{id} | Retrieve result
  *ResultsApi* | [**read_results_by_algorithm_id_results_algorithm_algorithm_id_get**](compute_api_client/docs/ResultsApi.md#read_results_by_algorithm_id_results_algorithm_algorithm_id_get) | **GET** /results/algorithm/{algorithm_id} | Retrieve results by algorithm ID
  *ResultsApi* | [**read_results_by_job_id_results_job_job_id_get**](compute_api_client/docs/ResultsApi.md#read_results_by_job_id_results_job_job_id_get) | **GET** /results/job/{job_id} | Retrieve results by job ID
  *TeamsApi* | [**read_team_teams_id_get**](compute_api_client/docs/TeamsApi.md#read_team_teams_id_get) | **GET** /teams/{id} | Retrieve teams
  *TeamsApi* | [**read_teams_teams_get**](compute_api_client/docs/TeamsApi.md#read_teams_teams_get) | **GET** /teams/ | List teams
  *TransactionsApi* | [**read_transaction_transactions_id_get**](compute_api_client/docs/TransactionsApi.md#read_transaction_transactions_id_get) | **GET** /transactions/{id} | Retrieve transactions
  *TransactionsApi* | [**read_transactions_transactions_get**](compute_api_client/docs/TransactionsApi.md#read_transactions_transactions_get) | **GET** /transactions/ | List transactions
  *UsersApi* | [**create_user_users_post**](compute_api_client/docs/UsersApi.md#create_user_users_post) | **POST** /users | Create user
  *UsersApi* | [**delete_user_users_id_delete**](compute_api_client/docs/UsersApi.md#delete_user_users_id_delete) | **DELETE** /users/{id} | Destroy user
  *UsersApi* | [**read_user_users_id_get**](compute_api_client/docs/UsersApi.md#read_user_users_id_get) | **GET** /users/{id} | Retrieve user
  *UsersApi* | [**read_users_users_get**](compute_api_client/docs/UsersApi.md#read_users_users_get) | **GET** /users | List users

   - [Algorithm](compute_api_client/docs/Algorithm.md)
   - [AlgorithmIn](compute_api_client/docs/AlgorithmIn.md)
   - [AlgorithmType](compute_api_client/docs/AlgorithmType.md)
   - [Backend](compute_api_client/docs/Backend.md)
   - [BackendIn](compute_api_client/docs/BackendIn.md)
   - [BackendPatch](compute_api_client/docs/BackendPatch.md)
   - [BackendStatus](compute_api_client/docs/BackendStatus.md)
   - [BackendType](compute_api_client/docs/BackendType.md)
   - [BackendWithAuthentication](compute_api_client/docs/BackendWithAuthentication.md)
   - [BatchJob](compute_api_client/docs/BatchJob.md)
   - [BatchJobIn](compute_api_client/docs/BatchJobIn.md)
   - [BatchJobStatus](compute_api_client/docs/BatchJobStatus.md)
   - [Commit](compute_api_client/docs/Commit.md)
   - [CommitIn](compute_api_client/docs/CommitIn.md)
   - [CompilePayload](compute_api_client/docs/CompilePayload.md)
   - [CompileStage](compute_api_client/docs/CompileStage.md)
   - [Domain](compute_api_client/docs/Domain.md)
   - [File](compute_api_client/docs/File.md)
   - [FileIn](compute_api_client/docs/FileIn.md)
   - [FinalResult](compute_api_client/docs/FinalResult.md)
   - [FinalResultIn](compute_api_client/docs/FinalResultIn.md)
   - [HTTPNotFoundError](compute_api_client/docs/HTTPNotFoundError.md)
   - [HTTPValidationError](compute_api_client/docs/HTTPValidationError.md)
   - [Job](compute_api_client/docs/Job.md)
   - [JobIn](compute_api_client/docs/JobIn.md)
   - [JobPatch](compute_api_client/docs/JobPatch.md)
   - [JobStatus](compute_api_client/docs/JobStatus.md)
   - [Language](compute_api_client/docs/Language.md)
   - [LocationInner](compute_api_client/docs/LocationInner.md)
   - [Member](compute_api_client/docs/Member.md)
   - [MemberIn](compute_api_client/docs/MemberIn.md)
   - [Metadata](compute_api_client/docs/Metadata.md)
   - [MetadataIn](compute_api_client/docs/MetadataIn.md)
   - [PageAlgorithm](compute_api_client/docs/PageAlgorithm.md)
   - [PageBackend](compute_api_client/docs/PageBackend.md)
   - [PageBackendType](compute_api_client/docs/PageBackendType.md)
   - [PageBatchJob](compute_api_client/docs/PageBatchJob.md)
   - [PageCommit](compute_api_client/docs/PageCommit.md)
   - [PageFile](compute_api_client/docs/PageFile.md)
   - [PageJob](compute_api_client/docs/PageJob.md)
   - [PageLanguage](compute_api_client/docs/PageLanguage.md)
   - [PageMember](compute_api_client/docs/PageMember.md)
   - [PageMetadata](compute_api_client/docs/PageMetadata.md)
   - [PagePermission](compute_api_client/docs/PagePermission.md)
   - [PagePermissionGroup](compute_api_client/docs/PagePermissionGroup.md)
   - [PageProject](compute_api_client/docs/PageProject.md)
   - [PageReservation](compute_api_client/docs/PageReservation.md)
   - [PageResult](compute_api_client/docs/PageResult.md)
   - [PageTeam](compute_api_client/docs/PageTeam.md)
   - [PageTransaction](compute_api_client/docs/PageTransaction.md)
   - [PageUser](compute_api_client/docs/PageUser.md)
   - [Permission](compute_api_client/docs/Permission.md)
   - [PermissionGroup](compute_api_client/docs/PermissionGroup.md)
   - [Project](compute_api_client/docs/Project.md)
   - [ProjectIn](compute_api_client/docs/ProjectIn.md)
   - [ProjectPatch](compute_api_client/docs/ProjectPatch.md)
   - [Reservation](compute_api_client/docs/Reservation.md)
   - [ReservationIn](compute_api_client/docs/ReservationIn.md)
   - [Result](compute_api_client/docs/Result.md)
   - [ResultIn](compute_api_client/docs/ResultIn.md)
   - [Role](compute_api_client/docs/Role.md)
   - [ShareType](compute_api_client/docs/ShareType.md)
   - [Team](compute_api_client/docs/Team.md)
   - [Transaction](compute_api_client/docs/Transaction.md)
   - [User](compute_api_client/docs/User.md)
   - [UserIn](compute_api_client/docs/UserIn.md)
   - [ValidationError](compute_api_client/docs/ValidationError.md)
  <a id="documentation-for-authorization"></a>

  Authentication schemes defined for the API:
  <a id="user_bearer"></a>

  - **Type**: OAuth
  - **Flow**: accessCode
  - **Authorization URL**: https://auth.qi2.quantum-inspire.com/realms/oidc_development/protocol/openid-connect/auth
  - **Scopes**: N/A
  <a id="backend"></a>

  - **Type**: API key
  - **API key parameter name**: Authorization
  - **Location**: HTTP header


pkgId: 8a04a7aa26bd7019af8481a1aa9f310967eea99f1843c7d02ad6b9b9f4b7cdd7
name: python-qianxing-openapi-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for qianxing-openapi
url: https://github.com/risenlighten-qianxing/openapi-sdk-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qianxing-openapi-0.1.8-1.src.rpm
location_href: Packages/python-qianxing-openapi-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  千行仿真平台的Python SDK。提供了一种简单直观的方式来控制和获取自动驾驶场景的仿真。



  您可以直接从PyPI安装该软件包：

  ```bash
  pip install qianxing-openapi
  ```



  以下是SDK使用的简单示例：

  ```python
  from qianxing_openapi.client import Client
  from qianxing_openapi.http_client import HttpConfig
  from qianxing_openapi.simulator import SimulatorConfig
  from qianxing_openapi.request_model import Point


  client = Client(
      HttpConfig(
          token="your_token_here",
          endpoint="your_endpoint_here"
      )
  )


  res = client.train_task.get_scene_id_list(task_id)
  print(f"可用场景: {res}")


  simulator = client.init_simulator_from_config(
      SimulatorConfig(
          scenario_id=res.scene_id_list[0],
          scenario_version=res.scene_version_list[0]
      )
  )


  for i in range(10):
      step_res = simulator.step()
      print(f"第 {i} 步结果: {step_res}")
      
      vehicle_ids = simulator.get_vehicle_id_list()
      print(f"车辆ID列表: {vehicle_ids}")

      
      simulator.set_vehicle_control_info(
          vehicle_id="test_vehicle_1",
          ste_wheel=1.2,
          lon_acc=1.1
      )

      
      simulator.set_vehicle_position(
          vehicle_id="test_vehicle_1",
          point=Point(x=-8.75, y=-537.0316, z=0)
      )


  simulator.stop()
  ```






  - `init_from_config(sim_config)`: 从配置初始化仿真器
  - `init_from_sim(simulation_id, addr)`: 从现有仿真初始化仿真器
  - `step()`: 仿真前进一步
  - `stop()`: 停止仿真
  - `reset(reset_traffic_flow)`: 重置仿真器到初始状态，可选择是否重置交通流


  - `get_vehicle_id_list()`: 获取所有车辆ID
  - `get_test_vehicle_id_list()`: 获取测试车辆ID
  - `get_vehicle_base_info(id_list)`: 获取车辆基本信息
  - `get_vehicle_position(id_list)`: 获取车辆位置
  - `get_vehicle_moving_info(id_list)`: 获取车辆运动信息
  - `get_vehicle_control_info(id_list)`: 获取车辆控制参数
  - `get_vehicle_perception_info(vehicle_id)`: 获取车辆感知信息
  - `get_vehicle_reference_lines(vehicle_id)`: 获取可用参考线
  - `get_vehicle_planning_info(vehicle_id)`: 获取车辆规划信息
  - `get_vehicle_navigation_info(vehicle_id)`: 获取车辆导航信息
  - `get_vehicle_collision_status(vehicle_id)`: 检查车辆碰撞状态
  - `get_vehicle_target_speed(vehicle_id)`: 获取车辆目标速度
  - `set_vehicle_position(vehicle_id, point, phi)`: 设置车辆位置和航向角
  - `set_vehicle_control_info(vehicle_id, ste_wheel, lon_acc)`: 设置车辆控制参数
  - `set_vehicle_planning_info(vehicle_id, planning_path)`: 设置车辆规划路径
  - `set_vehicle_moving_info(vehicle_id, u, v, w, u_acc, v_acc, w_acc)`: 设置车辆运动参数
  - `set_vehicle_base_info(vehicle_id, base_info)`: 设置车辆基本信息
  - `set_vehicle_link_nav(vehicle_id, link_nav)`: 设置车辆链接导航信息
  - `set_vehicle_destination(vehicle_id, destination)`: 设置车辆目标点


  - `get_current_stage(junction_id)`: 获取当前交通信号灯阶段
  - `get_movement_signal(movement_id)`: 获取转向信号灯颜色
  - `get_signal_plan(junction_id)`: 获取交通信号灯配时方案
  - `get_movement_list(junction_id)`: 获取路口转向列表


  - `get_ped_id_list()`: 获取所有行人ID
  - `get_ped_base_info(ped_id_list)`: 获取行人基本信息
  - `set_ped_position(ped_id, point, phi)`: 设置行人位置和航向角


  - `get_nmv_id_list()`: 获取所有非机动车ID
  - `get_nmv_base_info(nmv_id_list)`: 获取非机动车基本信息
  - `set_nmv_position(nmv_id, point, phi)`: 设置非机动车位置和航向角


  - `get_scene_id_list(task_id)`: 获取训练任务可用场景列表


  - `get_map(asset_id, asset_version)`: 获取特定资源的地图数据



  - Python >= 3.0
  - requests >= 2.25.0





  如需报告错误或请求新功能，请使用[GitHub Issues](https://github.com/risenlighten-qianxing/openapi-sdk-python/issues)页面。


pkgId: ed9d0feeb5c9d0e45b4d24131a7a6d0cfbfd046dfd3956548bd328331e3b2670
name: python-qick-help
arch: noarch
version: 0.2.300
epoch: 0
release: 1
summary: Development documents and examples for qick
url: https://github.com/openquantumhardware/qick
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qick-0.2.300-1.src.rpm
location_href: Packages/python-qick-help-0.2.300-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
   <img src="graphics/logoQICK.svg" alt="QICK logo" width=50% height=auto>
  </p>



  QICK is an open-source qubit controller, consisting of firmware, software, and an optional frontend for use with Xilinx RFSoC development boards.
  The goal of the project is to provide a powerful, flexible, cost-effective, and easy-to-learn platform for control and readout of a diverse range of quantum systems.

  QICK supports the ZCU111, ZCU216, and RFSoC4x2 development boards.
  We generally recommend using the newer generation of RFSoCs (ZCU216 and RFSoC4x2) for better overall performance.

  It consists of:
  * Firmware for the supported RFSoC boards, both compiled bitstreams and source for the designs and modules
  * The `qick` Python package, which includes the interface to the firmware and an API for writing QICK programs
  * [Jupyter notebooks](qick_demos) demonstrating usage

  See our [Read the Docs site](https://qick-docs.readthedocs.io/) for:
  * Documentation of the firmware and software
  * A quick-start guide for setting up your board and running the example Jupyter notebooks
  * Ways to communicate with QICK developers and the community
  * Extensions to QICK for added functionailty



  The QICK firmware and software is still very much a work in progress.
  We strive to be consistent with the APIs but cannot guarantee backwards compatibility.

  Frequent updates to the QICK firmware and software are made as pull requests.
  Each pull request will be documented with a description of the notable changes, including any changes that will require you to change your code.
  We hope that this will help you decide whether or not to update your local code to the latest version.
  We strive for, but cannot guarantee, bug-free and fully functional pull requests.
  We also do not guarantee that the demo notebooks will keep pace with every pull request, though we make an effort to update the demos after major API changes.

  Our version numbering follows the format major.minor.PR, where PR is the number of the most recently merged pull request.
  This will result in the PR number often skipping values, and occasionally decreasing.
  The tagged release of a new minor version will have the format major.minor.0.

  Tagged releases can be expected periodically.
  We recommend that everyone should be using at least the most recent release.
  We guarantee the following for releases:
  * The demo notebooks will be compatible with the QICK library, and will follow our current best recommendations for writing QICK programs.
  * The firmware images for all supported boards will be fully compatible with the library and the demo notebooks.
  * Release notes will summarize the pull request notes and explain both breaking API changes (what you need to change in your code) and improvements (why you should move to the new release).

  We recommend that you "watch" this repository on GitHub to get automatic notifications of pull requests and releases.



  You are welcome to contribute to QICK development by forking this repository and sending pull requests.

  All contributions are expected to be consistent with [PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/).

  We welcome bug reports and feature requests via GitHub Issues.



  The QICK source code is licensed under the MIT license, which you can find in the LICENSE file.
  The [QICK logo](graphics/logoQICK.svg) was designed by Dr. Christie Chiu.

  You are free to use this software, with or without modification, provided that the conditions listed in the LICENSE file are satisfied.


pkgId: c0eaebbc61b2b14bb71a976f9b61fb17b6f1e9cfadaae937faffb0c74092262c
name: python-qik-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for qik
url: https://github.com/AmbitionEng/qik
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qik-0.2.2-1.src.rpm
location_href: Packages/python-qik-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  Qik (*quick*) is an extensible command runner for monorepos. Like [make](https://www.gnu.org/software/make/), but with hash-based caching, advanced dependencies like globs and module imports, and execution in managed virtual environments.

  Qik's command caching and module parametrization can dramatically improve local development and CI/CD time. Qik's plugin ecosystem offers remote S3 command caching, Python import graph linting, and much more.

  Although qik is currently tailored towards Python repos, any project can use it.

  [Read the qik docs here](https://qik.build/en/stable/guide/) or [this blog post on why I built Qik](https://qik.build/en/stable/blog/2024/08/12/why-im-building-qik/).



  ```bash
  pip install qik
  ```

  For local development, we recommend installing most optional dependencies with:

  ```bash
  pip install "qik[dev]"
  ```

  Qik is compatible with Python 3.10 - 3.13, Linux, OSX, and WSL. It requires [git](https://git-scm.com) for command caching.





  Configure commands in `qik.toml`:

  ```toml
  [commands]
  format = "ruff format ."
  lint = "ruff check . --fix"
  type-check = "pyright"
  ```

  Run `qik` to execute every command across available cores. `qik <cmd> ...` runs specific commands.

  Specify `deps` to cache commands. Here we use `pip-compile` from [pip-tools](https://github.com/jazzband/pip-tools) to lock requirements:

  ```toml
  [commands.lock]
  exec = "pip-compile > requirements.txt"
  deps = ["requirements.in"]
  ```

  The requirements file from `qik lock` is cached locally until `requirements.in` changes.

  Along with globs, commands can depend on constants, other commands, Python distributions, and more.

  Here we update our previous command to depend on the `pip-tools` distribution, breaking the cache when the version changes:

  ```toml
  [commands.lock]
  exec = "pip-compile > requirements.txt"
  deps = [
      "requirements.in",
      {type = "pydist", name = "pip-tools"}
  ]
  ```

  Here we use command dependencies to ensure our linter runs after formatting:

  ```toml
  [commands.format]
  exec = "ruff format ."
  deps = ["**.py"]

  [commands.lint]
  exec = "ruff check . --fix"
  deps = ["**.py", {type = "command", name = "format"}]
  ```

  The `qik.pygraph` plugin provides the `pygraph` dependency. Here we run [pyright](https://github.com/microsoft/pyright) over the `hello.world` module whenever its code or imported code changes:

  ```toml
  [plugins]
  pygraph = "qik.pygraph"

  [commands.check-types]
  exec = "pyright hello/world"
  deps = [{type = "pygraph", pyimport = "hello.world"}]
  ```



  Cache results directly in your project with the `repo` cache:

  ```toml
  [commands.lock]
  exec = "pip-compile > requirements.txt"
  deps = ["requirements.in"]
  cache = "repo"
  ```

  Us the `qik.s3` plugin to create a shared remote cache using [AWS S3](https://aws.amazon.com/s3/):

  ```toml
  [plugins]
  s3 = "qik.s3"

  [caches.remote]
  type = "s3"
  bucket = "qik-cache"

  [commands.lock]
  exec = "pip-compile > requirements.txt"
  deps = ["requirements.in"]
  artifacts = ["requirements.txt"]
  cache = "remote"
  ```

  We specify `artifacts` here to ensure `requirements.txt` is cached and restored.



  Qik *spaces* define isolated environments and metadata for commands.

  Here we create a space for our linting command. The `qik.uv` plugin uses [uv](https://github.com/astral-sh/uv) to build virtualenvs:

  ```toml
  [plugins]
  uv = "qik.uv"

  [spaces]
  ruff = "ruff-requirements.txt"

  [commands.format]
  exec = "ruff format ."
  deps = ["**.py"]
  space = "ruff"

  [commands.lint]
  exec = "ruff check . --fix"
  deps = ["**.py", {type = "command", name = "format"}]
  space = "ruff"
  ```

  Running `qik` will lock and install the virtualenv for the `ruff` space and execute commands inside it. Changes to `ruff-requirements.txt` will break the cache of downstream commands.

  Along with managing virtual environments, spaces can:

  - Declare a `dotenv` file to automatically set environment variables.
  - Declare a `root`. Running `qik` under this folder only selects commands in the space.

  Here's a more complete example:

  ```toml
  [spaces.my-app]
  root = "app"
  dotenv = "app.env"
  venv = "requirements.txt"
  ```



  Spaces can define *modules* for command parametrization. Here we parametrize `pyright` over six modules across two spaces:

  ```toml
  [spaces.first]
  modules = ["a", "b", "c"]
  venv = "requirements-first.txt"

  [spaces.second]
  modules = ["d", "e", "f"]
  venv = "requirements-second.txt"

  [commands.check-types]
  exec = "pyright {module.dir}"
  deps = [{type = "pygraph", pyimport = "{module.pyimport}"}]
  ```

  Using `{module...}` in a command definition will automatically parametrize it over ever module in every space.

  Use `qik check-types -s first` to specify spaces or `qik check-types -m b -m c` to specific modules.



  Plugins like `qik.pygraph` can leverage the `fence` of a space to perform import linting and other useful tasks:

  ```toml
  [plugins]
  pygraph = "qik.pygraph"

  [spaces.first]
  modules = ["a", "b", "c"]
  fence = true
  ```

  Running `qik pygraph.check` will ensure these modules only import each other. Add additional internal imports or a virtual environment to extend the fence:

  ```toml
  [plugins]
  pygraph = "qik.pygraph"

  [spaces.first]
  modules = ["a", "b", "c"]
  fence = ["other/module"]
  venv = "requirements.txt"
  ```

  Include another space in the fence:

  ```toml
  [spaces.first]
  modules = ["a", "b", "c"]

  [spaces.second]
  modules = ["d", "e", "f"]
  fence = [{type = "space", name = "first"}]
  ```

  Running `qik pygraph.check -s second` will ensure the `second` space can import its modules and the `first` space's modules.



  Set context variables and use them in your configuration. Below we create a context variable for the bundle cache:

  ```toml
  ctx = [{name = "bundle_cache", default = "local"}]

  [command.build-bundle]
  exec = "npm run build"
  artifacts = ["js-build/*"]
  cache = "{ctx.bundle_cache}"
  ```

  Context variables can be supplied in the environment:

  ```bash
  BUNDLE_CACHE=remote qik build-bundle
  ```



  The core `qik` CLI functionality is as follows:

  - `qik` to run all commands.
  - `qik <cmd_name> <cmd_name>` to select commands by name.
  - `-m` to select by module.
  - `-s` to select by space.
  - `--watch` to reactively run selected commands.
  - `--since` to select commands based on changes since a git reference.
  - `-f` to run without the cache.
  - `-n` to set the number of workers.
  - `--ls` to list commands instead of running them.

  See [the command runner section](https://qik.build/en/stable/commands/#runner) for other advanced options, such as selecting commands based on cache status.

  The `qikx` utility is also available for running commands in spaces:

  ```bash

  qikx my_command --args val


  qikx my_command@space_name --args val
  ```



  Read the following guide to become a qik expert:

  - [Spaces](https://qik.build/en/stable/spaces/): How spaces work, their functionality, and how commands and plugins leverage them.
  - [Commands](https://qik.build/en/stable/commands/): Configuring and running commands. Learn the dependencies, selectors, and runtime behavior.
  - [Context](https://qik.build/en/stable/context/): Using environment-based runtime context.
  - [Caching](https://qik.build/en/stable/caching/): How caching works and how to configure different cache types.

  Learn more about plugins:

  - [Intro](https://qik.build/en/stable/plugin_intro/): How to configure and create plugins.
  - [Pygraph](https://qik.build/en/stable/plugin_pygraph/): Using the `qik.pygraph` plugin for import-based dependencies and import linting.
  - [UV](https://qik.build/en/stable/plugin_uv/): How to leverage and configure the `qik.uv` plugin for virtualenvs, including constraint files, custom PyPI indices, and more.
  - [S3](https://qik.build/en/stable/plugin_s3/): Configuring the `qik.s3` plugin for a remote S3 cache.

  Read the cookbook for more examples and guides:

  - [Spaces](https://qik.build/en/stable/cookbook_spaces/): More examples of leveraging spaces.
  - [Commands](https://qik.build/en/stable/cookbook_commands/): Common command definition examples.
  - [CLI Usage](https://qik.build/en/stable/cookbook_cli/): Command line interface snippets.
  - [CI/CD](https://qik.build/en/stable/ookbook_cicd/): Patterns for optimizing CI/CD time.

  Finish by checking out:

  - [Roadmap](https://qik.build/en/stable/roadmap/) for all the exciting upcoming features.
  - [Blog](https://qik.build/en/stable/blog/index/) for updates, how-tos, and other articles.

  Questions or thoughts? Open a [discussion](https://github.com/Opus10/qik/discussions). Report bugs [here](https://github.com/Opus10/qik/issues).



  Qik is currently in beta. Bumping the minor version (e.g. `0.1.0` to `0.2.0`) will indicate an API break until we release version `1.0.0`.

  Be diligent when using qik in your CI/CD. We recommend including a [base dependency](https://qik.build/en/stable/commands/#base) in your commands to regularly break the cache. We also recommend [understanding how the import graph is built](https://qik.build/en/stable/plugin_pygraph/#building-graph) when using pygraph dependencies.


pkgId: 370e28bef485e07c3bcc2c57d87f27302d6a646ad8983fa219c6ad6753d0c9f1
name: python-qilowatt-help
arch: noarch
version: 2024.12.1
epoch: 0
release: 1
summary: Development documents and examples for qilowatt
url: https://github.com/qilowatt/qilowatt-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qilowatt-2024.12.1-1.src.rpm
location_href: Packages/python-qilowatt-help-2024.12.1-1.noarch.rpm
checksum_type: sha256
description:
    - connecting to qilowatt MQTT server to send status, state and state0.
    - Receives BACKLOG commands
    - see example.py for usage


pkgId: cb0a5f6c6fa52c52c121325935915656b0ccedbe1c70a7d1ddd258dfdb992531
name: python-qimchi-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for qimchi
url: https://gitlab.com/squad-lab/qimchi
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qimchi-0.0.5-1.src.rpm
location_href: Packages/python-qimchi-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Plotly based data visualization tool for xarray data. Optimized to work with the [qcutils](https://gitlab.com/squad-lab/qcutils) package.


  This pip package has only been tested with `python>=3.11`. Separate `venv` testing environment is suggested while the package is in production.
  ```
  pip install git+ssh://git@gitlab.com/squad-lab/qimchi.git
  ```
  This should install the app, and you should be ready to go.


  Running qimchi is easy, after installing it in a suitable environment:
  ```python
  py -m qimchi
  ```


pkgId: d14da1e8784c6bdbf67586adcc7f58eccde9653ef443e6cecc7e6fad5185a52d
name: python-qis-help
arch: noarch
version: 2.1.28
epoch: 0
release: 1
summary: Development documents and examples for qis
url: https://github.com/ArturSepp/QuantInvestStrats
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qis-2.1.28-1.src.rpm
location_href: Packages/python-qis-help-2.1.28-1.noarch.rpm
checksum_type: sha256
description:
  qis package implements analytics for visualisation of financial data, performance
  reporting, analysis of quantitative strategies.

  qis package is split into 5 main modules with the
  dependecy path increasing sequentially as follows.

  1. ```qis.utils``` is module containing low level utilities for operations with pandas, numpy, and datetimes.

  2. ```qis.perfstats``` is module for computing performance statistics and performance attribution including returns, volatilities, etc.

  3. ```qis.plots``` is module for plotting and visualization apis.

  4. ```qis.models``` is module containing statistical models including filtering and regressions.

  5. ```qis.portfolio``` is high level module for analysis, simulation, backtesting, and reporting of quant strategies.
  Function ```backtest_model_portfolio()```  in ```qis.portfolio.backtester.py``` takes instrument prices
  and simulated weights from a generic strategy and compute the total return, performance attribution, and risk analysis

  ```qis.examples``` contains scripts with illustrations of QIS analytics.

  ```qis.examples.factheets``` contains scripts with examples of factsheets for simulated and actual strategies,
  and cross-sectional analysis of backtests.



  1. [Analytics](#analytics)
  2. [Installation](#installation)
  3. [Examples](#examples)
     1. [Visualization of price data](#price)
     2. [Multi assets factsheet](#multiassets)
     3. [Strategy factsheet](#strategy)
     4. [Strategy benchmark factsheet](#strategybenchmark)
     5. [Multi strategy factsheet](#multistrategy)
     6. [Notebooks](#notebooks)
  4. [Contributions](#contributions)
  5. [Updates](#updates)
  6. [ToDos](#todos)
  7. [Disclaimer](#disclaimer)



  Install using
  ```python
  pip install qis
  ```
  Upgrade using
  ```python
  pip install --upgrade qis
  ```

  Close using
  ```python
  git clone https://github.com/ArturSepp/QuantInvestStrats.git
  ```

  Core dependencies:
      python = ">=3.8",
      numba = ">=0.56.4",
      numpy = ">=1.22.4",
      scipy = ">=1.10",
      statsmodels = ">=0.13.5",
      pandas = ">=1.5.2",
      matplotlib = ">=3.2.2",
      seaborn = ">=0.12.2"

  Optional dependencies:
      yfinance ">=0.1.38" (for getting test price data),
      pybloqs ">=1.2.13" (for producing html and pdf factsheets)

  To use pybloqs for pandas > 2.x, locate file "...\Lib\site-packages\pybloqs\jinja\table.html" and
  change line 44 from {% for col_name, cell in row.iteritems() %} to {% for col_name, cell in row.items() %}






  The script is located in ```qis.examples.performances``` (https://github.com/ArturSepp/QuantInvestStrats/blob/master/qis/examples/performances.py)

  ```python
  import matplotlib.pyplot as plt
  import seaborn as sns
  import yfinance as yf
  import qis


  tickers = ['SPY', 'QQQ', 'EEM', 'TLT', 'IEF', 'SHY', 'LQD', 'HYG', 'GLD']
  prices = yf.download(tickers, start=None, end=None)['Adj Close'][tickers].dropna()


  with sns.axes_style("darkgrid"):
      fig, ax = plt.subplots(1, 1, figsize=(10, 7))
      qis.plot_prices(prices=prices, x_date_freq='YE', ax=ax)
  ```
  ![image info](qis/examples/figures/perf1.PNG)
  ```python

  with sns.axes_style("darkgrid"):
      fig, axs = plt.subplots(2, 1, figsize=(10, 7), tight_layout=True)
      qis.plot_prices_with_dd(prices=prices, x_date_freq='YE', axs=axs)
  ```
  ![image info](qis/examples/figures/perf2.PNG)

  ```python

  ust_3m_rate = yf.download('^IRX', start=None, end=None)['Adj Close'].dropna() / 100.0

  perf_params = qis.PerfParams(freq='ME', freq_reg='QE', alpha_an_factor=4.0, rates_data=ust_3m_rate)

  fig = qis.plot_ra_perf_table(prices=prices,
                               perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
                                             PerfStat.VOL, PerfStat.SHARPE_RF0,
                                             PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
                                             PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
                                             PerfStat.SKEWNESS, PerfStat.KURTOSIS],
                               title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')}",
                               perf_params=perf_params)
  ```
  ![image info](qis/examples/figures/perf3.PNG)



  ```python



  fig = qis.plot_ra_perf_table_benchmark(prices=prices,
                                         benchmark='SPY',
                                         perf_columns=[PerfStat.TOTAL_RETURN, PerfStat.PA_RETURN, PerfStat.PA_EXCESS_RETURN,
                                                       PerfStat.VOL, PerfStat.SHARPE_RF0,
                                                       PerfStat.SHARPE_EXCESS, PerfStat.SORTINO_RATIO, PerfStat.CALMAR_RATIO,
                                                       PerfStat.MAX_DD, PerfStat.MAX_DD_VOL,
                                                       PerfStat.SKEWNESS, PerfStat.KURTOSIS,
                                                       PerfStat.ALPHA_AN, PerfStat.BETA, PerfStat.R2],
                                         title=f"Risk-adjusted performance: {qis.get_time_period_label(prices, date_separator='-')} benchmarked with SPY",
                                         perf_params=perf_params)
  ```
  ![image info](qis/examples/figures/perf4.PNG)




  This report is adopted for reporting the risk-adjusted performance
  of several assets with the goal
  of cross-sectional comparision

  Run example in ```qis.examples.factsheets.multi_assets.py``` https://github.com/ArturSepp/QuantInvestStrats/blob/master/qis/examples/factsheets/multi_assets.py

  ![image info](qis/examples/figures/multiassets.PNG)



  This report is adopted for report performance, risk, and trading statistics
  for either backtested or actual strategy
      with strategy data passed as PortfolioData object

  Run example in ```qis.examples.factsheets.strategy.py``` https://github.com/ArturSepp/QuantInvestStrats/blob/master/qis/examples/factsheets/strategy.py

  ![image info](qis/examples/figures/strategy1.PNG)
  ![image info](qis/examples/figures/strategy2.PNG)
  ![image info](qis/examples/figures/strategy3.PNG)


  This report is adopted for report performance and marginal comparison
    of strategy vs a benchmark strategy
  (data for both are passed using individual PortfolioData object)

  Run example in ```qis.examples.factsheets.strategy_benchmark.py``` https://github.com/ArturSepp/QuantInvestStrats/blob/master/qis/examples/factsheets/strategy_benchmark.py

  ![image info](qis/examples/figures/strategy_benchmark.PNG)

  Brinson-Fachler performance attribution (https://en.wikipedia.org/wiki/Performance_attribution)
  ![image info](qis/examples/figures/brinson_attribution.PNG)



  This report is adopted to examine the sensitivity of
  backtested strategy to a parameter or set of parameters:

  Run example in ```qis.examples.factsheets.multi_strategy.py``` https://github.com/ArturSepp/QuantInvestStrats/blob/master/qis/examples/factsheets/multi_strategy.py

  ![image info](qis/examples/figures/multi_strategy.PNG)




  Recommended package to work with notebooks:
  ```python
  pip install notebook
  ```
  Starting local server
  ```python
  jupyter notebook
  ```

  Examples of using qis analytics jupyter notebooks are located here
  https://github.com/ArturSepp/QuantInvestStrats/blob/master/qis/examples/notebooks



  If you are interested in extending and improving QIS analytics,
  please consider contributing to the library.

  I have found it is a good practice to isolate general purpose and low level analytics and visualizations, which can be outsourced and shared, while keeping
  the focus on developing high level commercial applications.

  There are a number of requirements:

  - The code is [Pep 8 compliant](https://peps.python.org/pep-0008/)

  - Reliance on common Python data types including numpy arrays, pandas, and dataclasses.

  - Transparent naming of functions and data types with enough comments. Type annotations of functions and arguments is a must.

  - Each submodule has a unit test for core functions and a localised entry point to core functions.

  - Avoid "super" pythonic constructions. Readability is the priority.









  Core Changes

  1. Portfolio optimization (qis.portfolio.optimisation) layer is removed with core
  functionality moved to a stand-alone Python package: Backtesting Optimal Portfolio (bop)

  * This allows to remove the dependency from cvxpy and sklearn packages and
  thus to simplify the dependency management for qis

  2.	Added factsheet reporting using pybloqs package https://github.com/man-group/PyBloqs
  * Pybloqs is a versatile tool to create customised reporting using Matplotlib figures and table
  and thus leveraging QIS visualisation analytics

  3. New factsheets are added
  * Examples are added for the four type of reports:
      1. multi assets: report performance of several assets with goal of cross-sectional comparision:
      see qis.examples.factsheets.multi_asset.py
    2. strategy: report performance, risk, and trading statictics for either backtested or actual strategy
      with strategy data passed as PortfolioData object: see qis.examples.factsheets.strategy.py
    3. strategy vs benchmark: report performance and marginal comparison
    of strategy vs a benchmark strategy (data for both are passed using individual PortfolioData object):
    see qis.examples.factsheets.strategy_benchmark.py
    4. multi_strategy: report for a list of strategies with individual PortfolioData. This report is
    useful to examine the sensetivity of backtested strategy to a parameter or set of parameters:
    see qis.examples.factsheets.multi_strategy




  1. Enhanced documentation and readme examples.

  2. Docstrings for key functions.

  3. Reporting analytics and factsheets generation enhancing to matplotlib.





  QIS package is distributed FREE & WITHOUT ANY WARRANTY under the GNU GENERAL PUBLIC LICENSE.

  See the [LICENSE.txt](https://github.com/ArturSepp/QuantInvestStrats/blob/master/LICENSE.txt) in the release for details.

  Please report any bugs or suggestions by opening an [issue](https://github.com/ArturSepp/QuantInvestStrats/issues).


pkgId: 66817813f2fbd99c1f02903fba3b12971ef2e06b7065f26a7b5d8bf38c113cb9
name: python-qiskit-aqt-provider-help
arch: noarch
version: 1.9.0
epoch: 0
release: 1
summary: Development documents and examples for qiskit-aqt-provider
url: https://github.com/qiskit-community/qiskit-aqt-provider
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qiskit-aqt-provider-1.9.0-1.src.rpm
location_href: Packages/python-qiskit-aqt-provider-help-1.9.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Latest release](https://img.shields.io/pypi/v/qiskit-aqt-provider.svg)](https://pypi.python.org/pypi/qiskit-aqt-provider)
  [![License](https://img.shields.io/pypi/l/qiskit-aqt-provider.svg)](https://pypi.python.org/pypi/qiskit-aqt-provider)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10069281.svg)](https://doi.org/10.5281/zenodo.10069281)

  [![Supported Python versions](https://img.shields.io/pypi/pyversions/qiskit-aqt-provider.svg)](https://pypi.python.org/pypi/qiskit-aqt-provider)
  ![Build Status](https://github.com/qiskit-community/qiskit-aqt-provider/actions/workflows/poetry.yml/badge.svg?branch=master)
  [![Coverage Status](https://coveralls.io/repos/github/qiskit-community/qiskit-aqt-provider/badge.svg?branch=master)](https://coveralls.io/github/qiskit-community/qiskit-aqt-provider?branch=master)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://docs.astral.sh/ruff)
  [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)

  [Qiskit](https://www.ibm.com/quantum/qiskit) is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.

  This project contains a provider that allows access to [AQT](https://www.aqt.eu/) ion-trap quantum computing
  systems.



  See the [documentation](https://qiskit-community.github.io/qiskit-aqt-provider/) and the [examples](https://github.com/qiskit-community/qiskit-aqt-provider/tree/master/examples).


pkgId: b8f2e3822db8163a4f3c710a5d4c64a0f85f9d687b7ca02f735a57b3f8861524
name: python-qiskit-ibm-transpiler-help
arch: noarch
version: 0.9.3
epoch: 0
release: 1
summary: Development documents and examples for qiskit-ibm-transpiler
url: https://github.com/Qiskit/qiskit-ibm-transpiler
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qiskit-ibm-transpiler-0.9.3-1.src.rpm
location_href: Packages/python-qiskit-ibm-transpiler-help-0.9.3-1.noarch.rpm
checksum_type: sha256
description:
  A library to use [Qiskit Transpiler Service](https://docs.quantum.ibm.com/guides/qiskit-transpiler-service) and the [AI transpiler passes](https://docs.quantum.ibm.com/transpile/ai-transpiler-passes).

  **Note** The Qiskit Transpiler Service and the AI transpiler passes use different experimental services that are only available for IBM Quantum Premium Plan users. This library and the releated services are an alpha release, subject to change.



  To use the Qiskit IBM Transpiler, install the `qiskit-ibm-transpiler` package:

  ```sh
  pip install qiskit-ibm-transpiler
  ```

  to use it with the ability to run the available AI-powered transpiler passes (except `AIPauliNetworkSynthesis`) in local mode, install it as:

  ```sh
  pip install qiskit-ibm-traspiler[ai-local-mode]
  ```

  By default, the package tries to authenticate to IBM Quantum services with the defined Qiskit API token, and uses your token from the `QISKIT_IBM_TOKEN` environment variable or from the file `~/.qiskit/qiskit-ibm.json` (under the section `default-ibm-quantum`).

  _Note_: This library requires Qiskit 1.0 or greater.







  The following examples demonstrate how to transpile circuits using the Qiskit IBM Transpiler with different parameters.

  1. Create a circuit and call the Qiskit IBM Transpiler to transpile the circuit with `ibm_sherbrooke` as the `backend_name`, 3 as the `optimization_level`, and not using AI during the transpilation.

     ```python
     from qiskit.circuit.library import EfficientSU2
     from qiskit_ibm_transpiler.transpiler_service import TranspilerService

     circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()

     cloud_transpiler_service = TranspilerService(
         backend_name="ibm_sherbrooke",
         ai='false',
         optimization_level=3,
     )
     transpiled_circuit = cloud_transpiler_service.run(circuit)
     ```

  _Note:_ you only can use `backend_name` devices you are allowed to with your IBM Quantum Account. Apart from the `backend_name`, the `TranspilerService` also allows `coupling_map` as parameter.

  2. Produce a similar circuit and transpile it, requesting AI transpiling capabilities by setting the flag `ai` to `'true'`:

     ```python
     from qiskit.circuit.library import EfficientSU2
     from qiskit_ibm_transpiler.transpiler_service import TranspilerService

     circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()

     cloud_transpiler_service = TranspilerService(
         backend_name="ibm_sherbrooke",
         ai='true',
         optimization_level=1,
     )
     transpiled_circuit = cloud_transpiler_service.run(circuit)
     ```



  The `AIRouting` pass acts both as a layout stage and a routing stage. It can be used within a `PassManager` as follows:

  ```python
  from qiskit.transpiler import PassManager
  from qiskit_ibm_transpiler.ai.routing import AIRouting
  from qiskit.circuit.library import EfficientSU2

  ai_passmanager = PassManager([
     AIRouting(backend_name="ibm_sherbrooke", optimization_level=2, layout_mode="optimize")
  ])

  circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()

  transpiled_circuit = ai_passmanager.run(circuit)
  ```

  Here, the `backend_name` determines which backend to route for, the `optimization_level` (1, 2, or 3) determines the computational effort to spend in the process (higher usually gives better results but takes longer), and the `layout_mode` specifies how to handle the layout selection.
  The `layout_mode` includes the following options:

  - `keep`: This respects the layout set by the previous transpiler passes (or uses the trivial layout if not set). It is typically only used when the circuit must be run on specific qubits of the device. It often produces worse results because it has less room for optimization.
  - `improve`: This uses the layout set by the previous transpiler passes as a starting point. It is useful when you have a good initial guess for the layout; for example, for circuits that are built in a way that approximately follows the device's coupling map. It is also useful if you want to try other specific layout passes combined with the `AIRouting` pass.
  - `optimize`: This is the default mode. It works best for general circuits where you might not have good layout guesses. This mode ignores previous layout selections.



  The AI circuit synthesis passes allow you to optimize pieces of different circuit types ([Clifford](/api/qiskit/qiskit.quantum_info.Clifford), [Linear Function](/api/qiskit/qiskit.circuit.library.LinearFunction), [Permutation](/api/qiskit/qiskit.circuit.library.Permutation#permutation), [Pauli Network](/api/qiskit/qiskit.circuit.library.PauliNetwork)) by re-synthesizing them. A typical way to use the synthesis pass is as follows:

  ```python
  from qiskit.transpiler import PassManager

  from qiskit_ibm_transpiler.ai.routing import AIRouting
  from qiskit_ibm_transpiler.ai.synthesis import AILinearFunctionSynthesis
  from qiskit_ibm_transpiler.ai.collection import CollectLinearFunctions
  from qiskit_ibm_transpiler.ai.synthesis import AIPauliNetworkSynthesis
  from qiskit_ibm_transpiler.ai.collection import CollectPauliNetworks
  from qiskit.circuit.library import EfficientSU2

  ai_passmanager = PassManager([
     AIRouting(backend_name="ibm_quebec", optimization_level=3, layout_mode="optimize"),  # Route circuit
     CollectLinearFunctions(),  # Collect Linear Function blocks
     AILinearFunctionSynthesis(backend_name="ibm_quebec")  # Re-synthesize Linear Function blocks
     CollectPauliNetworks(), # Collect Pauli Networks blocks
     AIPauliNetworkSynthesis(backend_name="ibm_cairo"),  # Re-synthesize Pauli Network blocks
  ])

  circuit = EfficientSU2(10, entanglement="full", reps=1).decompose()

  transpiled_circuit = ai_passmanager.run(circuit)
  ```

  The synthesis respects the coupling map of the device: it can be run safely after other routing passes without "messing up" the circuit, so the overall circuit will still follow the device restrictions. By default, the synthesis will replace the original sub-circuit only if the synthesized sub-circuit improves the original (currently only checking `CNOT` count), but this can be forced to always replace the circuit by setting `replace_only_if_better=False`.

  The following synthesis passes are available from `qiskit_ibm_transpiler.ai.synthesis`:

  - _AICliffordSynthesis_: Synthesis for [Clifford](https://docs.quantum.ibm.com/api/qiskit/qiskit.quantum_info.Clifford) circuits (blocks of `H`, `S` and `CX` gates). Currently up to 9 qubit blocks.
  - _AILinearFunctionSynthesis_: Synthesis for [Linear Function](https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.library.LinearFunction) circuits (blocks of `CX` and `SWAP` gates). Currently up to 9 qubit blocks.
  - _AIPermutationSynthesis_: Synthesis for [Permutation](https://docs.quantum.ibm.com/api/qiskit/qiskit.circuit.library.Permutation#permutation) circuits (blocks of `SWAP` gates). Currently available for 65, 33, and 27 qubit blocks.
  - _AIPauliNetworkSynthesis_: Synthesis for [Pauli Network](/api/qiskit/qiskit.circuit.library.PauliNetwork) circuits (blocks of `H`, `S`, `SX`, `CX`, `RX`, `RY` and `RZ` gates). Currently up to six qubit blocks.

  We expect to gradually increase the size of the supported blocks.

  All passes use a thread pool to send several requests in parallel. By default it will use as max threads as number of cores plus four (default values for `ThreadPoolExecutor` python object). However, you can set your own value with the `max_threads` argument at pass instantation. For example, the following line will instantiate the `AILinearFunctionSynthesis` pass allowing it to use a maximum of 20 threads.

  ```python
  AILinearFunctionSynthesis(backend_name="ibm_quebec", max_threads=20)  # Re-synthesize Linear Function blocks using 20 threads max
  ```

  You can also set the environment variable `AI_TRANSPILER_MAX_THREADS` to the desired number of maximum threads, and all synthesis passes instantiated after that will use that value.

  For sub-circuit to be synthesized by the AI synthesis passes, it must lay on a connected subgraph of the coupling map (this can be ensured by just doing a routing pass previous to collecting the blocks, but this is not the only way to do it). The synthesis passes will automatically check if a the specific subgraph where the sub-circuit lays is supported, and if it is not supported it will raise a warning and just leave the original sub-circuit as it is.

  To complement the synthesis passes we also provide custom collection passes for Cliffords, Linear Functions and Permutations that can be imported from `qiskit_ibm_transpiler.ai.collection`:

  - _CollectCliffords_: Collects `Clifford` blocks as `Instruction` objects and stores the original sub-circuit to compare against it after synthesis.
  - _CollectLinearFunctions_: Collects blocks of `SWAP` and `CX` as `LinearFunction` objects and stores the original sub-circuit to compare against it after synthesis.
  - _CollectPermutations_: Collects blocks of `SWAP` circuits as `Permutations`.
  - _CollectPauliNetworks_: Collects Pauli Network blocks and stores the original sub-circuit to compare against it after synthesis.

  These custom collection passes limit the sizes of the collected sub-circuits so that they are supported by the AI synthesis passes, so it is recommended to use them after the routing passes and before the synthesis passes to get a better optimization overall.



  The library is prepared to let the user log the messages they want. For that, users only have to add the following code to their code:

  ```python
  import logging

  logging.getLogger("qiskit_ibm_transpiler").setLevel(logging.X)
  ```

  where X can be: `NOTSET`, `DEBUG`, `INFO`, `WARNING`, `ERROR` or `CRITICAL`



  If you use any AI-powered feature from the Qiskit IBM Transpiler in your research, use the following recommended citation:

  ```
  @misc{2405.13196,
  Author = {David Kremer and Victor Villar and Hanhee Paik and Ivan Duran and Ismael Faro and Juan Cruz-Benito},
  Title = {Practical and efficient quantum circuit synthesis and transpiling with Reinforcement Learning},
  Year = {2024},
  Eprint = {arXiv:2405.13196},
  }
  ```


pkgId: c84b1f8fcb1fa83d1b41d87dc3be1ccf5ff2dafc6c63c84be27ed03244817c93
name: python-qiskit-quantuminspire-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for qiskit-quantuminspire
url: https://www.quantum-inspire.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qiskit-quantuminspire-0.3.0-1.src.rpm
location_href: Packages/python-qiskit-quantuminspire-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/qutech-delft/qiskit-quantuminspire.svg?style=popout-square)](https://opensource.org/licenses/Apache-2.0)

  **Qiskit** is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.

  This project contains a provider that allows access to **[Quantum Inspire]** quantum systems.



  All information needed to get started using this plugin can be found in our [documentation](https://qutech-delft.github.io/qiskit-quantuminspire/). Some particularly useful links:

  1. [Installation and login](https://qutech-delft.github.io/qiskit-quantuminspire/getting_started/installation.html)
  2. [Submitting your first circuit](https://qutech-delft.github.io/qiskit-quantuminspire/getting_started/submitting.html)
  3. [Example notebooks](https://qutech-delft.github.io/qiskit-quantuminspire/notebooks/index.html)

  [quantum inspire]: https://www.quantum-inspire.com/


pkgId: ecb02e159e4c70b35cfd3c4dea01e1e95f909a559d60077959930fa65b885fa7
name: python-qiskit-superstaq-help
arch: noarch
version: 0.5.33
epoch: 0
release: 1
summary: Development documents and examples for qiskit-superstaq
url: https://pypi.org/project/qiskit-superstaq/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qiskit-superstaq-0.5.33-1.src.rpm
location_href: Packages/python-qiskit-superstaq-help-0.5.33-1.noarch.rpm
checksum_type: sha256
description:
  ![qiskit-superstaq's default workflow](https://github.com/Infleqtion/client-superstaq/actions/workflows/ci.yml/badge.svg)

  This package is used to access Superstaq via a Web API through [Qiskit](https://qiskit.org/). Qiskit programmers
  can take advantage of the applications, pulse level optimizations, and write-once-target-all
  features of Superstaq with this package.

  `qiskit-superstaq` is [available on PyPI](https://pypi.org/project/qiskit-superstaq/) and can be installed with:

  ```
  pip install qiskit-superstaq
  ```

  Please note that Python version `3.8` or higher is required. See installation instructions [here](https://github.com/Infleqtion/client-superstaq#readme).


  ```python
  import qiskit
  import qiskit_superstaq as qss

  token = "Insert superstaq token that you received from https://superstaq.infleqtion.com"

  superstaq = qss.superstaq_provider.SuperstaqProvider(token)

  backend = superstaq.get_backend("ibmq_brisbane_qpu")
  qc = qiskit.QuantumCircuit(2, 2)
  qc.h(0)
  qc.cx(0, 1)
  qc.measure(0, 0)
  qc.measure(1, 1)

  print(qc)


  job = backend.run(qc, shots=100, method="dry-run")
  print(job.result().get_counts())
  ```


pkgId: 2be7bfa0d88630e5eb3db0181f3fe5074ff140dd77a58431bc64bb78f778ac85
name: python-qlever
arch: noarch
version: 0.5.15
epoch: 0
release: 1
summary: Script for using the QLever SPARQL engine.
url: https://pypi.org/project/qlever/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qlever-0.5.15-1.src.rpm
location_href: Packages/python-qlever-0.5.15-1.noarch.rpm
checksum_type: sha256
description:
  QLever is a very fast SPARQL engine, much faster than most existing engines. It
  can handle graphs with more than hundred billion triples on a single machine
  with moderate resources. See https://qlever.cs.uni-freiburg.de for more
  information and many public SPARQL endpoints that use QLever

  This project provides a Python script that can control everything that QLever
  does, in particular, creating SPARQL endpoints for arbitrary RDF datasets. It
  is supposed to be very easy to use and self-explanatory as you use it. In
  particular, the tool provides context-sensitive autocompletion of all its
  commands and options. If you use a container system (like Docker or Podman),
  you don't even have to download any QLever code, but the script will download
  the required image for you.

  NOTE: There has been a major update on 24.03.2024, which changed some of the
  Qleverfile variables and command-line options (all for the better, of course).
  If you encounter any problems, please contact us by opening an issue on
  https://github.com/ad-freiburg/qlever-control/issues.



  Simply do `pip install qlever` and make sure that the directory where pip
  installs the package is in your `PATH`. Typically, `pip` will warn you when
  that is not the case and tell you what to do.



  Create an empty directory, with a name corresponding to the dataset you want to
  work with. For the following example, take `olympics`. Go to that directory
  and do the following. After the first call, `qlever` will tell you how to
  activate autocompletion for all its commands and options (it's very easy, but
  `pip` cannot do that automatically).

  ```
  qlever setup-config olympics   # Get Qleverfile (config file) for this dataset
  qlever get-data                # Download the dataset
  qlever index                   # Build index data structures for this dataset
  qlever start                   # Start a QLever server using that index
  qlever example-queries         # Launch some example queries
  qlever ui                      # Launch the QLever UI
  ```

  This will create a SPARQL endpoint for the [120 Years of
  Olympics](https://github.com/wallscope/olympics-rdf) dataset. It is a great
  dataset for getting started because it is small, but not trivial (around 2
  million triples), and the downloading and indexing should only take a few
  seconds.

  Each command will also show you the command line it uses. That way you can
  learn, on the side, how QLever works internally. If you just want to know the
  command line for a particular command, without executing it, you can append
  `--show` like this:

  ```
  qlever index --show
  ```

  There are many more commands and options, see `qlever --help` for general help,
  `qlever <command> --help` for help on a specific command, or just the
  autocompletion.



  To use QLever with your own dataset, you should also write a `Qleverfile`, like
  in the example above. The easiest way to write a `Qleverfile` is to get one of
  the existing ones (using `qlever setup-config ...` as explained above) and then
  change it according to your needs (the variable names should be self-explanatory).
  Pick one for a dataset that is similar to yours and when in doubt, pick `olympics`.



  The (Python) code for the script is in the `*.py` files in `src/qlever`. The
  preconfigured Qleverfiles are in `src/qlever/Qleverfiles`.

  If you want to make changes to the script, or add new commands, do as follows:

  ```
  git clone https://github.com/ad-freiburg/qlever-control
  cd qlever-control
  pip install -e .
  ```

  Then you can use `qlever` just as if you had installed it via `pip install
  qlever`. Note that you don't have to rerun `pip install -e .` when you modify
  any of the `*.py` files and not even when you add new commands in
  `src/qlever/commands`. The exceutable created by `pip` simply links and refers
  to the files in your working copy.

  If you have bug fixes or new useful features or commands, please open a pull
  request. If you have questions or suggestions, please open an issue.


pkgId: 95385706043210be5dd384807fc396c3ec91ee53665ab8b340671eb2e3e61a28
name: python-qm-qua-help
arch: noarch
version: 1.2.1
epoch: 0
release: 1
summary: Development documents and examples for qm-qua
url: https://pypi.org/project/qm-qua/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qm-qua-1.2.1-1.src.rpm
location_href: Packages/python-qm-qua-help-1.2.1-1.noarch.rpm
checksum_type: sha256
description:
  QUA is a pulse-level language used to control a Quantum System.
  Read more about it and it's uses here: https://arxiv.org/abs/2303.03816

  This package, QM-QUA, is an implementation that uses the Quantum Machines QOP controller and is used both to
  communicate with the QOP and to implement a Pythonic implementation (DSL) of QUA.

  To learn how to use this package, please visit the documentation website at: https://qm-docs.qualang.io/


pkgId: a6fb1a9cd7f72df72a66243e9ac58bba588afb40ec1fb89c6eaeb7fce381f943
name: python-qm-saas-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for qm-saas
url: https://pypi.org/project/qm-saas/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qm-saas-1.1.2-1.src.rpm
location_href: Packages/python-qm-saas-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Run Quantum Machines' QUA simulator instances at scale.

  This package provides a client to use the QM OPX simulator cloud service. It allows you to run QUA programs and retrieve the results on several instances in the cloud.

  To learn how to use this package, please visit the documentation website at: [https://docs.quantum-machines.co/latest/docs/Guides/qm_saas_guide/](https://docs.quantum-machines.co/latest/docs/Guides/qm_saas_guide/)


pkgId: 4c8c0a2068c63c6c98c260acba336a897b4ca47fb0f37f6fc27a122cc21d20c9
name: python-qnexus-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for qnexus
url: https://pypi.org/project/qnexus/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qnexus-0.9.2-1.src.rpm
location_href: Packages/python-qnexus-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  [Quantinuum Nexus](https://nexus.quantinuum.com) python client.


  ```python
  import qnexus as qnx


  qnx.login()


  qnx.jobs.get_all(job_status=["SUBMITTED", "QUEUED", "RUNNING"]).df()
  ```

  Full documentation available at https://docs.quantinuum.com/nexus

  Copyright 2024 Quantinuum Ltd.


pkgId: b1bc4ad4d5eae089599e084a043951c62ec323a80903c644616c602e137ebffb
name: python-qnta-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for qnta
url: https://pypi.org/project/qnta/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qnta-0.0.1-1.src.rpm
location_href: Packages/python-qnta-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://qntx.github.io/quanta">
      <img src="./docs/assets/images/logos/quanta.png" alt="Quanta" width="200" height="auto" />
    </a>
  </p>

  <h1 style="text-align: center;">Σ in innovation, harmony in finance.</h1>





  ```bash
  git clone https://github.com/Qntx/quanta.git
  cd quanta
  pip install -r requirements.txt
  mike serve
  ```



  ```bash
  mike delete --all
  mike set-default --push latest
  mike deploy --push --update-aliases develop latest
  ```


pkgId: a835652e8f6440ebbdcfa9eaad81f82a75a61efebe8447ea305e66323c96d98a
name: python-qolab-help
arch: noarch
version: 0.26
epoch: 0
release: 1
summary: Development documents and examples for qolab
url: https://pypi.org/project/qolab/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qolab-0.26-1.src.rpm
location_href: Packages/python-qolab-help-0.26-1.noarch.rpm
checksum_type: sha256
description:
  Classes and functions useful for the quantum optics lab: qolab.

  Designed to run experimental hardware and data analysis with python.

  The package `qolab` was started in April 2021 by Eugeniy E. Mikhailov
  within Quantum Optics Lab (QOLab), which explains it name.



  ~~~~
  pip install qolab
  ~~~~



  To build a python wheel package and put it in `./dist/` directory, run

  ~~~~~
  flit build
  ~~~~~


pkgId: 2d1ca2c2ba1f6e20bf66c55d1d7475f0863697ca460a07c853f48c4a27082f46
name: python-qpysequence-help
arch: noarch
version: 0.10.5
epoch: 0
release: 1
summary: Development documents and examples for qpysequence
url: https://pypi.org/project/qpysequence/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qpysequence-0.10.5-1.src.rpm
location_href: Packages/python-qpysequence-help-0.10.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Coverage](https://codecov.io/gh/qilimanjaro-tech/qpysequence/branch/main/graph/badge.svg?token=Z2ADH5BS5S)](https://codecov.io/gh/qilimanjaro-tech/qpysequence)
  [![Package Version](https://img.shields.io/pypi/v/qpysequence?color=%2334D058&label=pypi%20package)](https://pypi.org/project/qpysequence)
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/qpysequence.svg?color=%2334D058)](https://pypi.org/project/qpysequence)



  QPySequence, which stands for *Qblox Python Sequence*, is a python library developed by Qilimanjaro Quantum Tech to create the `sequence.json` file that is uploaded to a Qblox sequencer.
  The sequences that are uploaded to the Qblox instruments is a dictionary of four components:

  - **Waveforms**: dictionary containing an explicit array representation of the pulses to be played, each identified with an index and a name.
  - **Acquisitions**: dictionary containing different specifications for the acquisition of data, mainly the number of bins, each identified with an index and a name.
  - **Weights**: dictionary containing lists of time-dependent acquisition weights, each associated with an index and a name.
  - **Program**: description of the sequence in the Q1ASM language, represented as a plain text. In the program all waveforms, acquisitions and weights are referenced by their indices.

  In the [Qblox docs](https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/) there are several examples on how to write a Q1ASM program to perform a certain experiment as well as the necessary waveforms, acquisitions and weights to complete the sequence. This is task usually done by manually writing the waveforms and weights dictionaries with an inline numpy array generating function, the acquisitions are specified also manually, and finally a Q1ASM program is writen as a python formated string, with some variables inside for certain parameters.

  This procedure is feasible for small examples and certain simple experiments. However, when integrating this into a larger codebase, for example, inside of a general quantum control library, with a complex class structure, holding many instrument drivers and being developed by several colaborators; the maintenance, quality, readability and debugging of the code can become a cumbersome task.

  While certain parts of this procedure could be modularized with some helper functions, the string nature of the Q1ASM program as well with the remaining parts of the sequence it is connected to, indirectly via integers (the indices) that have to be handled separately, still leaves a lot of room for improvement with the implementation of a higher abstraction layer that would handle the creation of the sequence in an easier and more robust manner.

  QPySequence is a library that handles all the components of a sequence as python objects, from the sequence itself to each instruction of the program, including new abstractions as blocks and loops to structure the program in a more clear and readable way.



  The main classes of QPySequence imitate the structure of the `sequence.json` itself: `Waveforms`, `Acquisitions`, `Weights` and `Program`, as well as the class `Sequence` which contains them.
  The `Program` class is the one with higher complexity of the main four, with several internal classes used to structure all the instructions it holds (instances of classes which inherit from the abstract `Instruction` class). In contrast, the other three main classes (`Acquisitions`, `Weights` and `Waveforms`) share a very similar structure, since their structure is that of their dictionary counterpart in `sequence.json`, with the addition of methods that facilitate their construction.
  All the classes that are not internal have an implementation of the `repr()` method, which gives the equivalent string representation of that object that will be actually sent to the sequencer. In this way, when a `Sequence` object is completed with all of its components and its `repr()` method is called, it calls the `repr()` method of its elements, which gets recursively repeated until until reaching the lower layers, obtaining finally the complete string representation of the `sequence.json` file that can be directly uploaded to a Qblox sequencer.
  The `repr()` method can be called on any component of QPySequence, which allow to only generate the string representation of a single component, as the `Program` for example, if desired.



  This simple example illustrates how to create a sequence for an averaged readout

  ```python
  import qpysequence as qps
  import numpy as np


  readout_duration = 1000
  play_acq_delay = 120
  averaging_repetitions = 1024


  waveforms = qps.waveforms.Waveforms()
  readout_pulse = np.array([1.0 + 0.0j for _ in range(readout_duration)], dtype=np.complex128)
  ro_index_i, ro_index_q = waveforms.add_pair_from_complex(readout_pulse)


  acquisitions = qps.acquisitions.Acquisitions()
  acq_index = acquisitions.add("averaged")


  weights = {}


  program = qps.program.Program()
  main_loop = qps.program.Loop("main", averaging_repetitions)
  play = qps.program.instructions.Play(ro_index_i, ro_index_q, play_acq_delay)
  acquire = qps.program.instructions.Acquire(acq_index, bin_index=0, wait_time=readout_duration)
  main_loop.append_components([play, acquire])
  program.append_block(main_loop)


  sequence = qps.Sequence(program, waveforms, acquisitions, weights)


  sequence_json = repr(sequence)
  ```



  If you want to participate in the project, set up first your local environment, set up the git hooks and install the library.

  Read the [development](./doc/DEVELOPMENT.md) documentation.


pkgId: 0693ca1d0482749f34bd3e01e98ae544ae066d5ad0c5f83f72f065dcbb7680c2
name: python-qrs-api-client-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for qrs-api-client
url: https://github.com/rumen-vasilev/qrs-api-client
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qrs-api-client-2.0.0-1.src.rpm
location_href: Packages/python-qrs-api-client-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  Python client for [Qlik Sense Repository Service API](https://help.qlik.com/en-US/sense-developer/November2024/Subsystems/RepositoryServiceAPI/Content/Sense_RepositoryServiceAPI/RepositoryServiceAPI-Introduction.htm).

  Forked from [clintcarr/qrspy](https://github.com/clintcarr/qrspy)


  * Python 3.6+
  * requests>=2.32.3
  * requests_ntlm>=1.2.0
  * python-dotenv>=1.0.0


  ```bash
  pip install qrs-api-client
  ```


  You can optionally put the authentication data into an .env file. Just create it in your project folder and initialize
  the variables listed below.
  ```dotenv
  CERT_PATH="qlik_certs/client.pem"
  KEY_PATH="qlik_certs/client_key.pem"
  ROOT_CERT_PATH="qlik_certs/root.pem"
  SERVER_NAME="<server name>"
  SERVER_PORT=4242
  USER_ID="<DOMAIN>\\<user_id>"
  PASSWORD="<insert password>"
  ```



  You need to export the Qlik Sense certificates in PEM format from the Qlik Sense Enterprise server to a local folder in
  order to authenticate on the server.


  ```python
  from qrs_api_client.client import QRSClient
  from qrs_api_client.auth import AuthManager


  auth_manager = AuthManager(
      cert_path="<path_to_certificates>/client.pem",
      key_path="<path_to_certificates>/client_key.pem",
      root_cert_path="<path_to_certificates>/root.pem")


  client = QRSClient(server_name="<server_name>", server_port=4242, auth_manager=auth_manager,
                     auth_method="certificate", verify_ssl=True)


  api_desc_post = client.get("about/api/description", "extended=false&method=POST")
  if api_desc_post:
      print(api_desc_post)
  else:
      print("API request error.")
  ```


  ```python
  from qrs_api_client.client import QRSClient
  from dotenv import load_dotenv
  import os


  load_dotenv()


  client = QRSClient(server_name=os.getenv("SERVER_NAME"), server_port=os.getenv("SERVER_PORT"),
                     auth_method="certificate", verify_ssl=True)


  api_desc_post = client.get("about/api/description", "extended=false&method=POST")
  if api_desc_post:
      print(api_desc_post)
  else:
      print("API request error.")
  ```




  ```python
  from qrs_api_client.client import QRSClient
  from qrs_api_client.auth import AuthManager


  auth_manager = AuthManager(user_id="<DOMAIN>\\<user_id>", password="<password>",
                             root_cert_path="<path_to_certificates>/root.pem")


  client = QRSClient(server_name="<server_name>", server_port=443, auth_manager=auth_manager,
                     auth_method="ntlm", verify_ssl=False)


  api_desc_post = client.get("about/api/description", "extended=false&method=POST")
  if api_desc_post:
      print(api_desc_post)
  else:
      print("API request error.")
  ```


  ```python
  from qrs_api_client.client import QRSClient


  client = QRSClient(server_name="<server_name>", server_port=443, auth_method="ntlm", verify_ssl=False)


  api_desc_post = client.get("about/api/description", "extended=false&method=POST")
  if api_desc_post:
      print(api_desc_post)
  else:
      print("API request error.")
  ```


  Please click on this [link](https://github.com/rumen-vasilev/qrs-api-client/tree/master/examples) to find examples of usage of this client.


  Please click on this [link](https://rumen-vasilev.github.io/qrs-api-client/) for full API reference documentation.


pkgId: 9006eba0b6db96f256550ab67750f2a3a7a4f60ee555d5a4900a25b523c3ce5f
name: python-qsharp-jupyterlab
arch: noarch
version: 1.11.1
epoch: 0
release: 1
summary: Q# extension for JupyterLab
url: https://github.com/microsoft/qsharp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qsharp-jupyterlab-1.11.1-1.src.rpm
location_href: Packages/python-qsharp-jupyterlab-1.11.1-1.noarch.rpm
checksum_type: sha256
description:
  Q# is an open-source, high-level programming language for developing and running quantum algorithms.
  The `qsharp-jupyterlab` extension provides syntax highlighting for Q# documents and Q# notebook
  cells in JupyterLab.



  To install the Q# JupyterLab extension, run:

  ```bash
  pip install qsharp-jupyterlab
  ```

  To run Q# in Jupyter notebooks, remember to also install the `qsharp` package: [https://pypi.org/project/qsharp].



  For more information about the Azure Quantum Development Kit, visit [https://aka.ms/AQ/Documentation](https://aka.ms/AQ/Documentation).



  Q# welcomes your contributions! Visit the Q# GitHub repository at [https://github.com/microsoft/qsharp] to find out more about the project.


pkgId: a4507f118ace7915327838c298dd1e4620198650c50d00e5dbb3ff5fafd7c0b0
name: python-qspec-help
arch: noarch
version: 0.3.6
epoch: 0
release: 1
summary: Development documents and examples for qspec
url: https://pypi.org/project/qspec/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qspec-0.3.6-1.src.rpm
location_href: Packages/python-qspec-help-0.3.6-1.noarch.rpm
checksum_type: sha256
description:
  <h1>
  <img src="https://raw.githubusercontent.com/patmlr/qspec/refs/heads/dev-jekyll/docs/assets/img/logo.svg" width="300">
  </h1><hr>

  [![Static Badge](https://img.shields.io/badge/OS-Windows-yellow)](https://www.microsoft.com)
  [![Static Badge](https://img.shields.io/badge/Python-3.8%2B-blue?logo=python&logoColor=white)](https://www.python.org/)
  [![Static Badge](https://img.shields.io/badge/License-MIT-slateblue)](https://opensource.org/license/mit)

  [![Static Badge](https://img.shields.io/badge/DOI-10.48550/arXiv.2409.01417-orange)](https://doi.org/10.48550/arXiv.2409.01417)
  [![Static Badge](https://img.shields.io/badge/arXiv-2409.01417-red)](https://arxiv.org/abs/2409.01417)

  The [_qspec_](https://pypi.org/project/qspec/) Python package provides mathematical and physical functions
  frequently used in laser spectroscopy but also more general methods for data processing.
  Most functions are compatible with numpy arrays and are able to process *n*-dimensional arrays.
  This enables fast calculations with large samples of data, e.g., facilitating Monte-Carlo simulations.
  Tutorials and the API documentation are available on the [_Homepage_](https://patmlr.github.io/qspec/).
  Additional example scripts can be found in the example folder on [_GitHub_](https://github.com/patmlr/qspec).



  - [_Matplotlib_](http://matplotlib.org/)
  - [_NumPy_](http://www.numpy.org/)
  - [_SciPy_](http://www.scipy.org/)
  - [_SymPy_](http://www.sympy.org/)



  - _algebra_: Contains functions to calculate dipole coefficients and Wigner-*j* symbols.
  - _analyze_: Contains optimization functions and a class for King-plots.
  - _models_: Framework to generate modular fit models.
  - _physics_: Library of physical functions.
  - _simulate_: Intuitive framework to simulate coherent laser-atom interactions.
  - _stats_: Contains functions for the statistical analysis of data.
  - _tools_: General helper, print, data shaping and mathematical functions.


  - Calculate frequently used physical observables such as kinetic energies, velocities, Doppler shifts,
  hyperfine structure splittings, etc.
  - Coherently evolve atomic state population in a classical laser field.
  In contrast to powerful packages such as [_qutip_](https://qutip.org/),
  the quantum mechanical system is set up automatically by just providing atomic state and laser information.
  - Generate modular lineshape models for fitting. The modular system can be used
  to sum, convolve, link models and share parameters, fit hyperfine structure spectra, etc. This module is similar to the [_satlas2_](https://iks-nm.github.io/satlas2/) Python package.
  - Perform multidimensional King-plot analyses.

rpm_license:
  MIT License  Copyright (c) 2022 - 2024 Patrick Müller  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: a483211792b7268935eb6c52ce27062f2e58ddab6725f5514ed7f995eaef1640
name: python-qstone-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for qstone
url: https://github.com/riverlane/QStone
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qstone-0.1.1-1.src.rpm
location_href: Packages/python-qstone-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  An utility to benchmark the quality of an HPC and Quantum Computers integration. The benchmark allows the definition of a set of users for which a set of configurable quantum applications will be randomly selected. Example of currently supported quantum applications: VQE, PyMatching, RB. Users can create custom applications and use them together with the core applications.
  QStone generates different portable files (.tar.gz), each supporting a different user and a different scheduler (currently supporting: slurm, lsf, bare_metal). During execution of the benchmark, QStone gathers information on each steps of the applications, allowing investigations on bottlenecks and/or resource constraints at the interface between Quantum and HPC.
  The benchmark under the following [assumptions](assumptions.md).



  Building an appropriate hardware/software infrastructure to support HPCQC requires
  loads of work. We believe we shoud use a data driven approach in which we measure, fix, measure again with every new version of Quantum Computers, software and HPC hardware.



  Currently supported platforms/architectures:

  - MacOS: M1/M2 (Sequoia)
  - Intel: x86 (Ubuntu)
  - PowerPC: Power9 (RedHat)

  Tested on Python [3.9-3.12]





  `pip install QStone`



  Run QStone using Command Line Interface

  - Run the **generator** command

      ```qstone generate -i conf.json [--atomic/-a] [--scheduler/-s "slurm"/"jsrun"/"bare_metal"]```

      Generates tar.gz files that contains all the scripts to run scheduler for each user. Currently supported schedulers: [baremetal, altair/fnc, slurm/schedmd]. QStone expects an input configuration describing the users to want to generate jobs for as well as the description of the quantum computer you are generating jobs for. The optional `--atomic` flag forces the generation of single step jobs, instead of the default repartition in three jobs (pre, run, post). The `-s` flag allows selecting the output scheduler, default is `bare_metal`.

      With `config.json`:

  ```json
  {
    "project_name": "proj_name",
    "connector": "NO_LINK",
    "qpu_ip_address": "0.0.0.0",
    "qpu_port": "55",
    "qpu_management": "LOCK",
    "timeouts" : {
        "http": 5,
        "lock": 4
    },
    "jobs": [
      {
        "type": "VQE",
        "qubit_min": 2,
        "qubit_max": 4,
        "walltime" : 10,
        "nthreads" : 4,
        "lsf/jsrun_opt": "-nnodes=4 "
      },
      {
        "type": "RB",
        "qubit_min": 2,
        "qubit_max": 4,
        "walltime" : 10,
        "nthreads" : 2,
        "slurm/schedmd_opt": "--cpus-per-task=4"
      }
    ],
    "users": [
      {
        "user": "user0",
        "weight": 1,
        "computations": {
          "VQE": 0.05,
          "RB": 0.94,
          "PyMatching": 0.01
        }
      }
    ]
  }
  ```

  For more information on the `config.json` format refer to [config](CONFIG_JSON.md).

  - Alternatively call the generator in script:

  ```python
  from qstone.generators import generator

  def main():
      generator.generate_suite(config="config.json",
          num_calls=100,output_folder=".",atomic=False, scheduler="bare_metal")

  if __name__ == "__main__":
       main()
  ```


  -  Run the **run** command to execute chosen scheduler/workload selecting an optional output folder

      ```qstone run -i scheduler.qstone.tar.gz [-o folder]```

  The optional `-o` allows selecting the output folder in which to run the benchmark instance.

  - Alternatively may untar on your machine of choice and run as the selected user.

      - Run the jobs by executing `sh qstone_suite/qstone.sh`

      - Run the profiling tool to extract metrics of interest.

  -  Run the **profile** command providing the initial input configuration and output folder to run profiling tool on run information

      ```qstone profile --cfg conf.json --folder qstone_profile```

  -  Run the **profile** command providing the initial input configuration and multiple output folders (in case of multi-user run) to run profiling tool on run information

      ```qstone profile --cfg conf.json --folder qstone_profile --folder qstone_profile2```




  - Local no-link runner
  - gRPC
  - Http
  - Rigetti



  - Getting started [notebook](examples/running/getting_started.ipynb)
  - How to add a [new type of computation](examples/adding/computation/README.md)
  - How to create a simple [gateway](examples/node/README.md)



  Guidance on how to [contribute](CONTRIBUTING.md) and [change logs](CHANGELOG.md)


pkgId: dcdf071e5533b98c0204f12f1080c64927530b6e03fb9b8e1108a5ca57444616
name: python-qtdraw-help
arch: noarch
version: 2.2.3
epoch: 0
release: 1
summary: Development documents and examples for qtdraw
url: https://github.com/CMT-MU/QtDraw
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qtdraw-2.2.3-1.src.rpm
location_href: Packages/python-qtdraw-help-2.2.3-1.noarch.rpm
checksum_type: sha256
description:
  3D drawing tool for molecules and crystals based on [PyVista](https://docs.pyvista.org/) and [PySide6](https://doc.qt.io/qtforpython-6/index.html).
  Drawings are associated with crystallographic symmetry operations provided by [MultiPie](https://github.com/CMT-MU/MultiPie).

  - **Authors**: Hiroaki Kusunose

  - **Citing QtDraw and MultiPie**: If you are using QtDraw and/or MultiPie in your scientific research, please help our scientific visibility by citing our work:
      > Hiroaki Kusunose, Rikuto Oiwa, and Satoru Hayami, Symmetry-adapted modeling for molecules and crystals, Phys. Rev. B <b>107</b>, 195118 (2023).<br>
      > DOI: [https://doi.org/10.1103/PhysRevB.107.195118](https://doi.org/10.1103/PhysRevB.107.195118)

  - **Installation**: QtDraw can be installed from PyPI using pip on Python >= 3.9:
      ```
      pip install qtdraw
      ```

  - **Shell commands**:
    - `qtdraw [filename]` : Open QtDraw file.
    - `conv_qtdraw2 [ver1_file.qtdw]` : Convert Version 1 `.qtdw` file into this version (Version 2).

  - **Requirements**:
    - This library requires [TeXLive](https://www.tug.org/texlive/) environment.
    - Symmetry operation supports are provided by [MultiPie](https://github.com/CMT-MU/MultiPie).

  - **See also**:
    - [Manual](https://cmt-mu.github.io/QtDraw/src/overview.html).
    - [MultiPie tutorial (in Japanese)](https://cmt-mu.github.io/MultiPieTutorial/)
    - [QtDraw tutorial (in Japanese)](https://cmt-mu.github.io/QtDrawTutorial/)
    - Source : [PyPI](https://pypi.org/project/qtdraw/) or [GitHub](https://github.com/CMT-MU/QtDraw)


pkgId: f92d1f14fb5c27cc8b3ca4257d0d2111ae195c0014bc98b646e9171ea49325ff
name: python-qteasy-help
arch: noarch
version: 1.3.12
epoch: 0
release: 1
summary: Development documents and examples for qteasy
description:
  | |
  | BACK TESTING RESULT |

url: https://github.com/shepherdpp/qteasy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qteasy-1.3.12-1.src.rpm
location_href: Packages/python-qteasy-help-1.3.12-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright <2019> <JACKIE PENG>  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: d7347a05bea02a82ae9dc7398b5fbf6e050edf14e99ee9224c802832753e9e28
name: python-qtpynodeeditor-help
arch: noarch
version: 0.3.3
epoch: 0
release: 1
summary: Development documents and examples for qtpynodeeditor
url: https://pypi.org/project/qtpynodeeditor/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qtpynodeeditor-0.3.3-1.src.rpm
location_href: Packages/python-qtpynodeeditor-help-0.3.3-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2019, Ken Lauer All rights reserved.  qtpynodeeditor is a derivative work of NodeEditor by Dmitry Pinaev. It follows in the footsteps of the original and is licensed by the BSD 3-clause license.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of copyright holder, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 7f2f490bd6bb0a4df80831a257720f76058f0c4ea3ced17325f63862b5b52724
name: python-qtrade-lib-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for qtrade-lib
url: https://github.com/yourusername/qtrade
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qtrade-lib-0.1.0-1.src.rpm
location_href: Packages/python-qtrade-lib-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI Status](https://github.com/gguan/qtrade/actions/workflows/ci.yml/badge.svg)](https://github.com/gguan/qtrade/actions)
  [![Python](https://img.shields.io/pypi/pyversions/qtrade.svg)](https://badge.fury.io/py/qtrade)
  [![PyPI version](https://badge.fury.io/py/qtrade.svg)](https://badge.fury.io/py/qtrade)
  ![Coverage](https://img.shields.io/badge/coverage-97%25-green)
  [![codestyle](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  A Python library for backtesting trading strategies and applying reinforcement learning to trading.



  - Backtesting engine
  - Market data components
  - Trading environment simulation
  - Strategy development tools





  ```bash
  git clone https://github.com/yourusername/qtrade.git
  cd qtrade
  pip install -e .
  ```



  Run strategy backtest example

  ```bash
  python examples/simply_strategy.py
  ```

  Run reinforcement learning example

  ```bash
  python examples/rl_example.py
  ```



  - Python >= 3.7
  - Dependencies listed in requirements.txt



  ```
  qtrade/
  ├── qtrade/              # Main package
  │   ├── backtest/       # Backtesting engine
  │   ├── components/     # Trading components
  │   └── env/           # Trading environment
  ├── tests/              # Unit tests
  ├── examples/           # Example scripts
  └── docs/              # Documentation
  ```



  Basic example:

  ```python
  from qtrade import Backtest
  from qtrade.components import Strategy


  ```



  1. Create virtual environment:
  ```bash
  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate
  ```

  2. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```

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



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


pkgId: 6f6e9f60d8df71389ceba67ba5d89fd0e76e76e78bf2d3b0882472ad60d8e548
name: python-quairkit-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for quairkit
url: https://www.quairkit.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quairkit-0.3.0-1.src.rpm
location_href: Packages/python-quairkit-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
   Backend: density_matrix
   System dimension: [2]
   System sequence: [0]
   Batch size: [2]
   
  [[1.+0.j 0.+0.j]
   [0.+0.j 0.+0.j]]
   
  [[0.5+0.j 0.5+0.j]


pkgId: e649e3c955304201be630f099f69f56b49d69cdea6f516133b30e8dc10421594
name: python-qualysdk-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for qualysdk
url: https://github.com/0x41424142/qualysdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-qualysdk-0.2.5-1.src.rpm
location_href: Packages/python-qualysdk-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  ![Logo](https://raw.githubusercontent.com/0x41424142/qualysdk/main/imgs/qualysdkLogo.png)

  [![Code Style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge)](https://github.com/psf/black) ![Development Status](https://img.shields.io/badge/in%20development-8A2BE2?style=for-the-badge)  ![PyPI - Latest Version](https://img.shields.io/pypi/v/qualysdk?style=for-the-badge&logo=pypi&logoColor=yellow) ![Python Versions](https://img.shields.io/pypi/pyversions/qualysdk?style=for-the-badge&logo=python&logoColor=yellow) ![GitHub Stars](https://img.shields.io/github/stars/0x41424142/qualysdk?style=for-the-badge) ![GitHub License](https://img.shields.io/github/license/0x41424142/qualysdk?style=for-the-badge)


  ![Black Formatter Status](https://github.com/0x41424142/qualysdk/actions/workflows/black.yml/badge.svg?event=push) ![CodeQL Scan Status](https://github.com/0x41424142/qualysdk/actions/workflows/codeql.yml/badge.svg?branch=main) [![CodeFactor](https://www.codefactor.io/repository/github/0x41424142/qualysdk/badge)](https://www.codefactor.io/repository/github/0x41424142/qualysdk)


  This SDK attempts to make it much easier to interact with Qualys's various API endpoints, across as many modules as I can find time to code.

  ```py
  from qualysdk.auth import BasicAuth
  from qualysdk.vmdr import get_host_list

  auth = BasicAuth(<username>, <password>, platform='qg1')


  hosts = get_host_list(auth, details="All/AGs", show_tags=True, page_count=4)
  >>>[VMDRHost(12345), ...]
  ```




  |Module| Status |
  |--|--|
  | GAV (Global AssetView) |✅ See GAV [documentation page](https://qualysdk.jakelindsay.uk/gav/) for supported calls ||
  | VMDR | ✅ See VMDR [documentation page](https://qualysdk.jakelindsay.uk/vmdr/) for supported calls |
  | PM (Patch Management) | See Patch Management [documentation page](https://qualysdk.jakelindsay.uk/patch/) for supported calls |
  | WAS | ✅ See WAS [documentation page](https://qualysdk.jakelindsay.uk/was/) for supported calls |
  | TC (TotalCloud) | ✅ See TotalCloud [documentation page](https://qualysdk.jakelindsay.uk/totalcloud/) for supported calls. |
  |Connectors | Not Started |
  |Cloud Agent | ✅ See Cloud Agent [documentation page](https://qualysdk.jakelindsay.uk/cloudagent/) for supported calls |
  |CS (Container Security) | ✅ See CS [documentation page](https://qualysdk.jakelindsay.uk/containersecurity/) for supported calls |
  |CERT (Certificate View) | ✅ See CERT [documentation page](https://qualysdk.jakelindsay.uk/cert/) for supported calls |
  |ADMIN (Administration) | Not Started |
  |Asset Management & Tagging| Not Started |
  | SQL Data Uploads | ✅ See SQL [documentation page](https://qualysdk.jakelindsay.uk/sql/) for supported uploads/DBs |





  For more detailed information on the package, including how to get up and running, please see the [documentation](https://qualysdk.jakelindsay.uk).



  This SDK tool is an independent project and is not an official product of Qualys. It has been developed and maintained solely by the names listed in the GitHub contributors list. Qualys has neither endorsed nor approved this SDK.

  Users of this SDK are advised to use it at their own risk and discretion.

  For official tools and support, please refer to the official Qualys resources and documentation.


pkgId: 517aeeb7ca7ddd84d1d37ec97610e4274f2101e8d624c661a27a795d73046136
name: python-quantconnect-stubs-help
arch: noarch
version: 16806
epoch: 0
release: 1
summary: Development documents and examples for quantconnect-stubs
url: https://github.com/QuantConnect/quantconnect-stubs-generator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantconnect-stubs-16806-1.src.rpm
location_href: Packages/python-quantconnect-stubs-help-16806-1.noarch.rpm
checksum_type: sha256
description:
  This package contains type stubs for QuantConnect's [Lean](https://github.com/QuantConnect/Lean) algorithmic trading engine and for parts of the .NET library that are used by Lean.

  These stubs can be used by editors to provide type-aware features like autocomplete and auto-imports in QuantConnect strategies written in Python.

  After installing the stubs, you can copy the following line to the top of every Python file to have the same imports as the ones that are added by default in the cloud:
  ```py
  from AlgorithmImports import *
  ```

  This line imports [all common QuantConnect members](https://github.com/QuantConnect/Lean/blob/master/Common/AlgorithmImports.py) and provides autocomplete for them.


pkgId: 40ac5fb4442200124d8c1aeaf603ecd59995642d2d5d6173b5e32767408a9b64
name: python-quantfinlib-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for quantfinlib
url: https://quantfinlib.org/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantfinlib-0.0.6-1.src.rpm
location_href: Packages/python-quantfinlib-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align='center'>
  <img src="./_static/quantfinlib_logo.png"  alt="QuantFinLib Logo" width="60"/>
  </h1><br>

  <h3 style='background-color:red; color:white; padding:20px'>This library is pre-alpha, please only use it for development testing</h2>

  ```
  $ pip install quantfinlib
  ```


  [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/quantfinlib/quantfinlib/blob/main/LICENSE)
  [![Python Version](https://img.shields.io/pypi/pyversions/quantfinlib.svg)](https://pypi.org/project/quantfinlib/)
  [![PyPI Version](https://img.shields.io/pypi/v/quantfinlib.svg)](https://pypi.org/project/quantfinlib/)
  [![Build Status](https://github.com/quantfinlib/quantfinlib/actions/workflows/deploy.yml/badge.svg)](https://github.com/quantfinlib/quantfinlib/actions/workflows/deploy.yml)
  [![Coverage Status](https://coveralls.io/repos/github/quantfinlib/quantfinlib/badge.svg?branch=main)](https://coveralls.io/github/quantfinlib/quantfinlib?branch=main)
  [![Docs](https://readthedocs.org/projects/quantfinlib/badge/?version=latest)](https://quantfinlib.readthedocs.io/en/latest/)


  QuantFinLib is a comprehensive Python library designed for quantitative finance. It offers a wide range
  of tools with applications in quantitative finance, including machine learning,
  asset management, portfolio optimization, time series transformations, indicators, labeling, feature engineering,
  stochastic simulation, randomization tests, and backtesting.

  Quantfinlib provide robust and well-designed
  solutions for financial data analysis, modeling, and trading strategy development.

  Quantfinlib is and always will be open source. Everyone is encouraged to add new features and contribute. Quantfinlib is free to use under the MIT license.


pkgId: 52303f088ebe485565ba53787300d83651f966a6ef2d190d590e2a867f1d72a1
name: python-quantify-zurich-instruments-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for quantify-zurich-instruments
url: https://pypi.org/project/quantify-zurich-instruments/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantify-zurich-instruments-0.0.1-1.src.rpm
location_href: Packages/python-quantify-zurich-instruments-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  To get started, take a look at our [documentation](https://opensource.orangeqs.info/quantify-zurich-instruments/latest/)


  quantify-zurich-instruments is a backend for [quantify](https://quantify-os.org/) that allows the user to compile and execute [quantify schedules](https://quantify-os.org/docs/quantify-scheduler/v0.17.1/user/user_guide.html) on [Zurich Instruments](https://zhinst.com) hardware.
  This quantify backend makes use of the [LabOne Q](https://docs.zhinst.com/labone_q_user_manual/) framework.

  This backend is developed by [Orange QS](https://orangeqs.com) and [Zurich Instruments](https://zhinst.com).


  This project is licensed under the [BSD 3-Clause "New" or "Revised" License](https://code.orangeqs.com/opensource/quantify-zurich-instruments/-/blob/main/LICENSE).

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023-2024, Orange Quantum Systems. Copyright (c) 2023-2024, Zurich Instruments. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: cc142c56d4913094133669ac808044710b3babc32d9e6cdc18616f50c461b7b6
name: python-quantinuum-schemas-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for quantinuum-schemas
url: https://pypi.org/project/quantinuum-schemas/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantinuum-schemas-1.1.0-1.src.rpm
location_href: Packages/python-quantinuum-schemas-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Public models that define API boundaries used by Quantinuum.  Intended to be
  used across teams and projects ie. shared. Backwards compatibility and semantic
  versioning are particularly important in this repo!  The "Check Conventional
  Commits format" workflow will make sure your PRs follow a [standard
  format](https://www.conventionalcommits.org/en/v1.0.0/). For
  backwards-incompatible changes, please use the conventional `!` or `BREAKING
  CHANGE:`.



  We try to keep the dependencies minimal. However we do need `pydantic` for
  validation and `pytket` for core (serialisable) models.



  See notes above about conventional commits and versioning.

  Once all your code changes are merged onto the `main` branch using conventional
  commits, follow these steps to publish.



  - Update `CHANGELOG.md`: this is automated.

    Use `devenv` and the `commitizen`
    [tool](https://commitizen-tools.github.io/commitizen/):
    ```
    git fetch --tags origin  # make sure your local tags are same as in github
    cz bump --files-only  # --files-only prevents the tool making a git tag
    ```
    This will use the [commit history](https://www.conventionalcommits.org/) and
    modify `CHANGELOG.md` to include a heading with the new version number and the
    date. It also updates `.cz.toml`. The tool automatically decides whether to
    increment the patch version, minor version or major version.

    If none of the commits since the last version tag would generate a CHANGELOG
    entry, then you will see `NO_COMMITS_TO_BUMP`. In this situation,

    ```shell
    >$ # only if you see NO_COMMITS_TO_BUMP... add one to the patch number
    >$ cz bump --files-only x.y.z+1  # !! substitute correct version
    >$ vi CHANGELOG.md  # edit to explain that there are no changes
    ```

  - If you like, you can manually edit `CHANGELOG.md` at this point. Consider
    moving important entries under these headings, or writing under them (see
    [Keep A Changelog](https://keepachangelog.com/en/1.1.0/#how)):
    - Deprecated
    - Removed
    - Security
  - Create a release branch `git checkout -b release/vx.y.z`
  - `git add` the modifications, then `git commit` and `git push` them.
  - Create a PR (title: `docs: Update CHANGELOG for vx.y.z`)
  - Ask a colleague to review the changes (should be just `CHANGELOG.md` and
    `pyproject.toml`)
  - Squash merge the PR into `main`



  - Go to github.com and on this repo's home page, click "Create a new release"
  - Using the version in the format `v1.2.34`, click "Choose a tag" and create a
    new tag
  - Click "Generate release notes"
  - Release title = `v1.2.34`. In the "Describe this release" box, copy and paste
    the new text that was added to CHANGELOG.md in the commit you are releasing.
  - Click "Publish release".
  - The "Create release" workflow should run automatically.
  - Check that the new release is on
    https://pypi.org/project/quantinuum-schemas/#history


pkgId: 5b125ad630ed155b8cd2c4321fac54cebaa22160fe0f3686c3449335564d95b1
name: python-quantlaw-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for quantlaw
url: https://github.com/quantlaw/quantlaw/
rpm_license: new-bsd
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantlaw-0.0.6-1.src.rpm
location_href: Packages/python-quantlaw-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/quantlaw)](https://pypi.org/project/quantlaw/)
  [![Build Status](https://travis-ci.com/QuantLaw/quantlaw.svg?branch=master)](https://travis-ci.com/QuantLaw/quantlaw)
  [![Maintainability](https://api.codeclimate.com/v1/badges/dabd1718d48dbf669d32/maintainability)](https://codeclimate.com/github/QuantLaw/quantlaw/maintainability)
  [![codecov](https://codecov.io/gh/QuantLaw/quantlaw/branch/master/graph/badge.svg?token=XCLX5460R8)](https://codecov.io/gh/QuantLaw/quantlaw)
  [![Documentation Status](https://readthedocs.org/projects/quantlaw/badge/?version=latest)](https://quantlaw.readthedocs.io/en/latest/?badge=latest)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4079451.svg)](https://doi.org/10.5281/zenodo.4079451)



  This package contains coding utilities for quantitative legal studies.



  The package currently consists of two modules.



  `quantlaw.de_extract` is an extractor for references to statutes in German legal texts.
  In contrast to most other named entity recognition packages, this module not only
  identifies the references but also extracts their content. This can, e.g., be used to
  quantitatively analyze the structure of the law.

  For example, we can extract the content of two references in the following text.

  Source text:

  "In den Fällen des **§ 111d Absatz 1 Satz 2** der *Strafprozessordnung* findet **§ 91**
  der *Insolvenzordnung* keine Anwendung."

  The extracted data would be:

  1. `[[['§', '111d'], ['Abs', '1'], ['Satz', '2']]]` for the law `StPO`
  2. `[[['§', '91']]]` for the law `InsO`

  Getting started in the documentation contains a minimal example.



  `quantlaw.utils` contains several utilities that are helpful to analyze the structure of
  the law with `BeautifulSoup` and `networkx`. The documentation contains further
  information about the individual usages.



  Python 3.7.9 is recommended. Our package is provided via `pip install quantlaw`.



  It is, inter alia, used to produce the results reported in the following publications:

  - Daniel Martin Katz, Corinna Coupette, Janis Beckedorf, and Dirk Hartung, Complex Societies and the Growth of the Law, *Sci. Rep.* **10** (2020), [https://doi.org/10.1038/s41598-020-73623-x](https://doi.org/10.1038/s41598-020-73623-x)
  - Corinna Coupette, Janis Beckedorf, Dirk Hartung, Michael Bommarito, and Daniel Martin Katz, Measuring Law Over Time, *Front. Phys.* **9:658463** (2021), https://doi.org/10.3389/fphy.2021.658463
  - Corinna Coupette, and Dirk Hartung, Rechtsstrukturvergleichung, *RabelsZ* **86**, 935-975 (2022), https://doi.org/10.1628/rabelsz-2022-0082
  - Corinna Coupette, Dirk Hartung, Janis Beckedorf, Maximilian Böther, and Daniel Martin Katz, Law Smells, *Artif Intell Law* **31**, 335-368 (2023), https://doi.org/10.1007/s10506-022-09315-w
  - Janis Beckedorf, Komplexität des Rechts, Mohr Siebeck, to appear (2025), https://doi.org/10.1628/978-3-16-164476-4

  Related Repositories:
  - [Complex Societies and the Growth of the Law](https://github.com/QuantLaw/Complex-Societies-and-Growth) ([Publication Release](https://doi.org/10.5281/zenodo.4070769))
  - [Measuring Law Over Time](https://github.com/QuantLaw/Measuring-Law-Over-Time) ([Publication Release](https://doi.org/10.5281/zenodo.4660191))
  - [Law Smells](https://github.com/QuantLaw/law-smells) ([Publication Release](https://doi.org/10.5281/zenodo.6468193))
  - [Komplexität des Rechts](https://github.com/beckedorf/komplexitaet-des-rechts) ([Publication Release](https://doi.org/10.1628/978-3-16-164476-4-appendix))
  - [Legal Data Preprocessing](https://github.com/QuantLaw/legal-data-preprocessing) ([Latest Publication Release](https://doi.org/10.5281/zenodo.4070772))
  - [Legal Data Clustering](https://github.com/QuantLaw/legal-data-clustering) ([Latest Publication Release](https://doi.org/10.5281/zenodo.4070774))

  Related Data:
  - [Preprocessed Input Data for *Sci. Rep.* **10** (2020)](https://doi.org/10.5281/zenodo.4070767)
  - [Preprocessed Input Data for *Measuring Law Over Time*, *Front. Phys.* **9:658463** (2021)](https://doi.org/10.5281/zenodo.4660133)
  - [Preprocessed Input Data for *Komplexität des Rechts*, Mohr Siebeck, to appear (2025)](https://doi.org/10.5281/zenodo.14298980)
  - [Preprocessed Input Data for *Law Smells*, *Artif Intell Law* **31**, 335–368 (2023)](https://doi.org/10.5281/zenodo.6468191)



  Please format the code using `isort`, `black`, and `flake8`. A convenient option to
  ensure correct formatting of the code is to
  [pip install pre-commit](https://pypi.org/project/pre-commit/) and run
  `pre-commit install` to add code checking and reformatting as git pre-commit hook.


pkgId: 1176fa7a558059a27276d71a29d3fac5ed3ea609dfe733db812bf1738d16a349
name: python-quantms-rescoring-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for quantms-rescoring
url: https://pypi.org/project/quantms-rescoring/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantms-rescoring-0.0.2-1.src.rpm
location_href: Packages/python-quantms-rescoring-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/bigbio/quantms-rescoring/actions/workflows/python-package.yml/badge.svg)](https://github.com/bigbio/quantms-rescoring/actions/workflows/python-package.yml)
  [![codecov](https://codecov.io/gh/bigbio/quantms-rescoring/branch/main/graph/badge.svg?token=3ZQZQ2ZQ2D)](https://codecov.io/gh/bigbio/quantms-rescoring)
  [![PyPI version](https://badge.fury.io/py/quantms-rescoring.svg)](https://badge.fury.io/py/quantms-rescoring)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

  quantms-rescoring is a Python tool for rescoring peptide-spectrum matches (PSMs) in idXML files. It is part of the quantms ecosystem package and leverages the MS²Rescore framework to improve identification confidence in proteomics data analysis.



  - Enhanced Rescoring: Utilizes advanced rescoring engines like Percolator to refine PSM scores.
  - Flexible Feature Generators: Supports feature extraction using tools like MS²PIP, DeepLC, and custom generators.
  - Metadata Retention: Preserves essential metadata from the input idXML files.
  - Error Handling: Skips invalid PSMs and logs issues for transparent processing.
  - Seamless Integration: Built to integrate into proteomics workflows.



  To use quantms-rescoring, ensure the following dependencies are installed:

  - Python 3.8+
  - click
  - pyopenms
  - ms2rescore
  - psm_utils



  For any issues or contributions, please open an issue in the [GitHub repository](https://github.com/bigbio/quantms/issues) - we use the quantms repo to control all issues—or PR in the [GitHub repository](https://github.com/bigbio/quantms-rescoring/pulls).


pkgId: 6c5813d7246fc736502f4172d2f64191295db621606c37d02c97161403e63dbb
name: python-quantum-attack-simulator-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for quantum-attack-simulator
url: https://github.com/koraydns/quantum-attack-simulator
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-quantum-attack-simulator-1.0-1.src.rpm
location_href: Packages/python-quantum-attack-simulator-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python-based simulator for analyzing the security of quantum communication systems. In version 1.0, the simulator is focused only on the BB84 protocol. This simulator includes features to simulate and analyze the effects of **depolarization noise**, **Man-in-the-Middle (MITM) attacks**, and **Photon Number Splitting (PNS) attacks**.



  The **Quantum Attack Simulator** allows users to study how various noise sources and attack vectors impact the security of the BB84 quantum key distribution protocol. By providing visualization tools and detailed analysis of attack effects, this simulator is an educational and research-oriented tool for understanding quantum communication vulnerabilities.




  - **Python 3.7 or later**
  - Install required dependencies:
  ```bash
  pip install -r requirements.txt
  ```

  Clone this repository and install locally:
   ```bash
  git clone https://github.com/yourusername/quantum-attack-simulator.git
  cd quantum-attack-simulator
  ```
  Alternatively, install the package directly via pip:
  ```bash
  pip install quantum-attack-simulator
  ```

  If you cloned this repository using `git clone` instead of installing via `pip`,
  you need to ensure the project directory is added to your Python path.

  Uncomment and include the following code block at the beginning of bb84_example script:

  ```python
  import sys
  import os

  current_dir = os.path.dirname(os.path.abspath(__file__))
  project_root = os.path.join(current_dir, '..')
  sys.path.append(project_root)
  ```

  To run the simulator with default settings:
  ```bash
  python examples/bb84_example.py
  ```
  You can customize the simulation with the following arguments:

  - `--attack-type`: Specify the type of attack to simulate. Options are:
    - `None (Default)`: No attack is simulated.
    - `MITM`: Simulate a Man-in-the-Middle attack.
    - `PNS`: Simulate a Photon Number Splitting attack.

  - `--depolarization-noise`: Enable or disable depolarization noise.
    - `0 (Default)`: Disable depolarization noise.
    - `1`: Enable depolarization noise (with a probability of 0.1).

  Examples:
  ```bash
  python examples/bb84_example.py --attack-type MITM --depolarization-noise 1
  ```
  ```bash
  python examples/bb84_example.py --attack-type PNS
  ```
  ```bash
  python examples/bb84_example.py --depolarization-noise 1
  ```




  This scenario demonstrates the BB84 protocol simulation with depolarization noise applied but no attack (e.g., MITM or PNS).


  - A probability of 10% is applied, meaning qubits might undergo depolarization, simulating real-world noise in the quantum channel.
  - Observed mismatches in the key agreement phase are analyzed to determine whether they fall within the expected noise threshold.


  - Despite some mismatches caused by noise, the protocol determines that the observed error rate is within the acceptable threshold for depolarization noise.
  - Communication proceeds successfully, and a shared key is generated.


  - The mismatch rate is compared against the expected noise threshold. It is highly likely that no attack will be detected.
  - The error rates for different intensity levels are analyzed. All rates are within the noise threshold, confirming no PNS attack.
  ```bash
  python bb84_example.py --depolarization-noise 1
  ```
  ```bash
  Sender's Bits: 0000110101000111000101110111110101001100
  Sender's States: DSDSDSDDSDSDSSDSDDSSSDDSSDSSDSDSDSDSDDSS
  Sender's Bases: ZXZZXZZZXZXXZZZXXXXXXZZXXZXXZXZXXXZXZXXZ
  Sender's Intensities: ['high', 'none', 'medium', 'none', 'high', 'none', 'medium', 'high', 'none', 'medium', 'none', 'medium', 'none', 'none', 'low', 'none', 'medium', 'low', 'none', 'none', 'none', 'low', 'low', 'none', 'none', 'low', 'none', 'none', 'medium', 'none', 'high', 'none', 'medium', 'none', 'high', 'none', 'high', 'low', 'none', 'none']


  Applying depolarization noise with probability 0.1


  Receiver's Bases: ZXZZXXXXZZXZXZZXZXZZZZXZXXXXZXXZXXXZZZXX
  Receiver's Bits: 1001111011000111000001010111111101101100

  Performing security checks...
  An interception detected. Mismatched bits: 2
  Mismatch detected! Analyzing possible causes...
  Observed error rate: 9.52% (expected <= 10.00%)
  Differences are likely caused by depolarization noise.
  Communication can proceed despite mismatches caused by depolarization noise.
  Error rates by intensity (for PNS Check): {'low': 0.0, 'medium': 0.0, 'high': 0.0}

  Key: 000011011101011110110
  The key is 21 bits long.
  ```


  This scenario represents the ideal condition where there is neither noise nor any attack on the quantum communication channel.


  - No depolarization noise is applied, ensuring a clean quantum channel.
  - Sender and receiver's bases align perfectly in the shared indices, resulting in no mismatches.


  - A perfect match between sender and receiver bits leads to a flawless key agreement.
  - The generated key is identical for both parties without any discrepancies.


  - Since there are no mismatches, it is confirmed that no interception (e.g., MITM attack) is detected.
  - The absence of error rates for intensity levels confirms that no PNS attack occurred.
  ```bash
  python bb84_example.py
  ```
  ```bash
  Sender's Bits: 1110010101010111111000010111011010000111
  Sender's States: SDSDSDSSSSSSSDDDDDSDSSSSSSSSSSSSDDDDSSDD
  Sender's Bases: ZXXXZXZZZXXZXXZZXZZXZZZZZXZZXZXXXZZXXXZX
  Sender's Intensities: ['none', 'high', 'none', 'medium', 'none', 'high', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'high', 'high', 'low', 'high', 'low', 'none', 'high', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'none', 'low', 'high', 'medium', 'low', 'none', 'none', 'low', 'high']

  No depolarization noise applied.

  Receiver's Bases: XXZZXZZZZXXZZZXZZXXXZZXXXXZZZXXXXXXZZXXZ
  Receiver's Bits: 1101100101011011000000110111111010001110

  Performing security checks...
  Seems no interception. The tested bits of Sender and Receiver are the same.
  No significant mismatches detected. Proceeding with PNS attack detection...
  Error rates by intensity (for PNS Check): {'low': 0.0, 'high': 0.0}

  Key: 101010110001111011
  The key is 18 bits long.
  ```

  ```bash
  python bb84_example.py --attack-type PNS
  ```
  ```bash
  Receiver's Bases: ZXXZZXXZZZZXZXXZXXZXXZZZXXXZZZXXXXZZXZZZ
  Receiver's Bits: 0011010101110111010100001101001110010010

  Proceeding with PNS attack detection...
  Error rates by intensity (for PNS Check): {'low': 0.6, 'medium': 1.0, 'high': 0.75}
  Possible PNS attack detected. Final error rate: 0.6
  Communication is terminated due to possible PNS attack.
  ```

  - **Blue Bars:** Error rates for different intensity levels (`low`, `medium`, `high`).
  - **Red Dashed Line:** Observed error rate across all qubits during communication.
  - **Green Dashed Line:** Expected noise level, representing the depolarization noise threshold.

  This visualization helps distinguish between natural noise and potential attacks by comparing observed error rates against expected thresholds.

  ![PNS Attack Effects Visualization](Screen_Shots/pns-attack-effects-visualization.png)


  ```bash
  python bb84_example.py --attack-type MITM
  ```
  ```bash
  Receiver's Bases: XXXZXZXZXZXXZXZZZXXZZXXZZXZZZZZZZZZXXZZZ
  Receiver's Bits: 1000001111110010110000110111010111100100

  Performing security checks...
  An interception detected. Mismatched bits: 9
  Mismatch detected! Analyzing possible causes...
  Observed error rate: 36.00% (expected <= 10.00%)
  Differences exceed depolarization noise levels and may indicate an attack.
  Communication is terminated due to detected interception. Possible MITM attack.
  ```

  - **Orange Bar:** Mismatch rate between the Sender's and Receiver's shared bits.
  - **Green Dashed Line:** Depolarization noise threshold, indicating the maximum expected error rate due to natural noise.

  This visualization aids in identifying potential MITM attacks by comparing mismatch rates against the expected noise threshold.

  ![MITM Attack Effects Visualization](Screen_Shots/mitm-attack-effects-visualization.png)



  This project is licensed under the Apache License, Version 2.0.
  You may obtain a copy of the License at:  [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)

  Unless required by applicable law or agreed to in writing, this software 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.
  For more details, refer to the [LICENSE file in this repository](LICENSE).


