# packages

pkgId: 71f2869597f04040ff3a4a634062706beb021768c6ec2db81eb2288baf193be3
name: python-picpro-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for picpro
url: https://github.com/Salamek/picpro
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-picpro-0.2.0-1.src.rpm
location_href: Packages/python-picpro-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This is complete rewrite of kitsrus_pic_programmer into Python 3 + bunch of fixes and features.

  [![Tox tests](https://github.com/Salamek/picpro/actions/workflows/python-test.yml/badge.svg)](https://github.com/Salamek/picpro/actions/workflows/python-test.yml)


      * K128
      * K149-A
      * K149-B
      * K150 (Tested)

  See http://www.kitsrus.com/pic.html






  ```
  pip install picpro
  ```


  You can also use these repositories maintained by me


  Add repository by running these commands

  ```
  $ wget -O- https://repository.salamek.cz/deb/salamek.gpg | sudo tee /usr/share/keyrings/salamek-archive-keyring.gpg
  $ echo "deb     [signed-by=/usr/share/keyrings/salamek-archive-keyring.gpg] https://repository.salamek.cz/deb/pub all main" | sudo tee /etc/apt/sources.list.d/salamek.cz.list
  ```

  And then you can install a package picpro

  ```
  $ apt update && apt install picpro
  ```



  Add repository by adding this at end of file /etc/pacman.conf

  ```
  [salamek]
  Server = https://repository.salamek.cz/arch/pub/any
  SigLevel = Optional
  ```

  and then install by running

  ```
  $ pacman -Sy picpro
  ```




  ```
  Command details:
      program             Program PIC chip.
      verify              Verify PIC flash.
      dump                Dump PIC data as binary.

  Usage:
      picpro program -p PORT -i HEX_FILE -t PIC_TYPE [--id=PIC_ID] [--fuse=FUSE_NAME:FUSE_VALUE...] [--icsp]
      picpro verify -p PORT -i HEX_FILE -t PIC_TYPE [--icsp]
      picpro dump <mem_type> -p PORT -b BIN_FILE -t PIC_TYPE [--icsp]
      picpro (-h | --help)


  Options:
      --icsp                           Enable ISCP programming.
      --fuse=FUSE_NAME:FUSE_VALUE      Set fuse value directly.
      --id=PIC_ID                      Set PIC id to be programmed in pic.
      -p PORT --port=PORT              Set serial port where programmer is connected.
      -t PIC_TYPE --pic_type=PIC_TYPE  Pic type you are programming/reading.
      -i HEX_FILE --hex_file=HEX_FILE  Hex file to flash or to read.
      -b BIN_FILE --bin_file=BIN_FILE  Bin file path.

  ```



  ```bash
  picpro program -p /dev/ttyUSB0 -i YOUR_HEX_FILE.hex -t 12F675
  ```



  ```bash
  picpro verify -p /dev/ttyUSB0 -i YOUR_HEX_FILE.hex -t 12F675
  ```



  ```bash
  picpro dump rom -p /dev/ttyUSB0 -b dump.rom -t 12F675
  ```



  ```bash
  picpro dump eeprom -p /dev/ttyUSB0 -b dump.eeprom -t 12F675
  ```



  ```bash
  picpro program -p /dev/ttyUSB0 -i YOUR_HEX_FILE.hex -t 12F675 --icsp
  ```



  ```bash
  picpro program -p /dev/ttyUSB0 -i YOUR_HEX_FILE.hex -t 12F675 --fuse=FUSE_NAME:FUSE_VALUE --fuse=FUSE_NAME:FUSE_VALUE
  ```


pkgId: f635aa71ac032a7dc611636eb7edb96726bce0a71c5044af45523be5da2564fb
name: python-piecemaker-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for piecemaker
url: https://github.com/jkenlooper/piecemaker
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-piecemaker-0.5.0-1.src.rpm
location_href: Packages/python-piecemaker-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  A jigsaw puzzle pieces generator that levels the playing field.

  It creates jigsaw puzzle pieces in multiple formats: svg, jpg, and png.  The
  number and size of pieces are set by passing the script different options.  It
  takes a while to run if doing a lot of pieces.  Extra JSON files are created
  with details on size of pieces and adjacent pieces information which is commonly
  used when verifying that two pieces can join together.

  Samples from different generated puzzles:

  ![generated piece](docs/0.png)
  ![generated piece](docs/3.png)
  ![sample](docs/sample-pieces.png)
  ![generated piece cut example](docs/generated-piece-cut-example.svg)

  Try out by running the `piecemaker.sh` script that will prompt for necessary options
  and run piecemaker inside a docker container. It will use the files in the examples
  directory by default.

  ```bash

  ./piecemaker.sh
  ```



  Requires:

  Python Packages:

  * [Pillow](http://github.com/python-imaging/Pillow)
  * [pixsaw](http://github.com/jkenlooper/pixsaw)
  * [beautifulsoup4](http://www.crummy.com/software/BeautifulSoup/bs4/)
  * [svgwrite](https://pypi.python.org/pypi/svgwrite)
  * lxml
  * [glue](https://github.com/jorgebastida/glue) (Only partially included in
    piecemaker source)

  Other Software needed:

  * [potrace](http://potrace.sourceforge.net/)

  If on ubuntu or other debian based distro

  ```bash
  apt-get --yes install libspatialindex6
  apt-get --yes install optipng
  apt-get --yes install python3-pil
  apt-get --yes install potrace libffi-dev libxml2-dev python3-lxml python3-xcffib
  apt-get --yes install librsvg2-bin
  apt-get --yes install python3-pip
  ```


  Install with pip in editable mode for developing and use virtualenv to isolate
  python dependencies

  ```bash
  python3 -m venv .venv
  source .venv/bin/activate
  pip install --upgrade --upgrade-strategy eager -e .
  ```




  See the script.py for more.  Not everything has been implemented. Use this
  example command to create 100 randomly generated jigsaw puzzle pieces from
  test.jpg image. This assumes that the 'test1' directory is empty since that is
  where it will be placing all the generated files.  The test.jpg is the source
  image that will be used when creating the pieces.  It is not modified.

  ```bash
  piecemaker --dir test1  --number-of-pieces 100 test.jpg
  ```

  Example of using an already existing svg file with jigsaw puzzle cut lines. The
  'test2' directory should be empty as well. Note that the svg file
  (test2-custom-cut-lines.svg) and the image (test.jpg) both need to be the same
  width and height. Try this out by using a previously generated
  'lines-resized.svg' from a different puzzle and a different image to create
  a new puzzle with identical piece cuts.

  ```bash
  piecemaker --dir test2 --svg test2-custom-cut-lines.svg test.jpg
  ```



  Create SVG files for jigsaws with tools from [proceduraljigsaw](https://github.com/proceduraljigsaw).

  * [CustomShapeJigsawJs](https://proceduraljigsaw.github.io/CustomShapeJigsawJs/) A custom border jigsaw puzzle generator for laser cutting based on Voronoi tesselation
      * [proceduraljigsaw/CustomShapeJigsawJs](https://github.com/proceduraljigsaw/CustomShapeJigsawJs)
  * [Fractalpuzzlejs](https://proceduraljigsaw.github.io/Fractalpuzzlejs/) Javascript web based circle grid fractal jigsaw puzzle generator for lasercutting.
      * [proceduraljigsaw/Fractalpuzzlejs](https://github.com/proceduraljigsaw/Fractalpuzzlejs)
  * [OrganicPuzzleJs](https://proceduraljigsaw.github.io/OrganicPuzzleJs/) is a (pretty broken, but mostly functional) organic-shaped jigsaw generator with custom border support.
      * [proceduraljigsaw/OrganicPuzzleJs](https://github.com/proceduraljigsaw/OrganicPuzzleJs)
  * [Gosperpuzzlejs](https://proceduraljigsaw.github.io/Gosperpuzzlejs/) Gosper curve fractal jigsaw generator
      * [proceduraljigsaw/Gosperpuzzlejs](https://github.com/proceduraljigsaw/Gosperpuzzlejs)
  * [HexFractalpuzzlejs](https://proceduraljigsaw.github.io/Hexpuzzlejs/) Hexagonal grid fractal puzzle generator
      * [proceduraljigsaw/Hexpuzzlejs](https://github.com/proceduraljigsaw/Hexpuzzlejs)
  * [ImpactPuzzle](https://github.com/proceduraljigsaw/ImpactPuzzle) Broken glass jigsaw puzzle generator.
  * [CircleGridPuzzle](https://github.com/proceduraljigsaw/CircleGridPuzzle) Fractal jigsaw puzzle generator in Python.

  SVG editing tools

  * [SVGEdit Online Editor](https://svgedit.netlify.app/editor/index.html) is a fast, web-based, JavaScript-driven SVG drawing editor that works in any modern browser.
      * [SVGEdit](https://svg-edit.github.io/svgedit/)
      * [SVG-Edit/svgedit](https://github.com/SVG-Edit/svgedit)



  Please contact [Jake Hickenlooper](mailto:jake@massive.xyz) or create an issue.

  Any submitted changes to this project require the commits to be signed off with
  the [git command option
  '--signoff'](https://git-scm.com/docs/git-commit#Documentation/git-commit.txt---signoff).
  This ensures that the committer has the rights to submit the changes under the
  project's license and agrees to the [Developer Certificate of
  Origin](https://developercertificate.org).



  [GNU Lesser General Public License v3.0](https://choosealicense.com/licenses/lgpl-3.0/)



  Where possible, an upkeep comment has been added to various parts of the source
  code. These are known areas that will require updates over time to reduce
  software rot. The upkeep comment follows this pattern to make it easier for
  commands like grep to find these comments.

  Example UPKEEP comment has at least a 'due:' or 'label:' or 'interval:' value
  surrounded by double quotes (").
  ````
  Example-> # UPKEEP due: "2022-12-14" label: "an example upkeep label" interval: "+4 months"
  ````

  Show only past due UPKEEP comments.
  ```bash
  make upkeep
  ```


pkgId: f782cddc2ac1ade43f366f2d7c3a91cce1018318d9d843424915589317600998
name: python-pieces-cli-help
arch: noarch
version: 1.9.0
epoch: 0
release: 1
summary: Development documents and examples for pieces-cli
url: https://pieces.app
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pieces-cli-1.9.0-1.src.rpm
location_href: Packages/python-pieces-cli-help-1.9.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Pieces CLI for Developers](https://camo.githubusercontent.com/69c990240f877927146712d45be2f690085b9e45b4420736aa373917f8e0b2c8/68747470733a2f2f73746f726167652e676f6f676c65617069732e636f6d2f7069656365735f7374617469635f7265736f75726365732f7066645f77696b692f5049454345535f4d41494e5f4c4f474f5f57494b492e706e67)
  <p align="center">



  <p align="center"> This is a comprehensive command-line interface (CLI) tool designed to interact seamlessly with Pieces OS. It provides a range of functionalities such as asset management, application interaction, and integration with various Pieces OS features.

  </p>


  </p>

  [![Introducing CLI](https://img.youtube.com/vi/kAgwHMxWY8c/0.jpg)](https://www.youtube.com/watch?v=kAgwHMxWY8c)



  Make sure you have [**Pieces OS**](https://docs.pieces.app/installation-getting-started/what-am-i-installing) installed in order to run the Pieces CLI tool.


  The Pieces Python CLI Tool is compatible with various operating systems, ensuring a wide range of usage and adaptability. While it offers full support across most systems, specific features might have varied performance based on the OS environment.

  The CLI Supports
  - Windows 10 or greater
  - Mac
  - Windows


  To get started with the Pieces Python CLI Tool, you need to:

  1. Ensure Pieces OS is installed and running on your system.
  2. Install the Python package:

     ```bash
     pip install pieces-cli
     ```

     ```bash
     brew install pieces-cli
     ```

     ```bash
     conda install pieces-cli
     ```


  After installing the CLI tool, you can access its functionalities through the terminal. The tool is initialized with the command `pieces` followed by various subcommands and options.




  - `x` -> The index
  - `current asset` -> The asset that you are currently using can be changed by the open command
  - `current conversation` -> The conversation that you currently using in the ask command




  To refer to the list of all the commands currently supported in the Pieces CLI Agent, visit the [documentation](https://docs.pieces.app/extensions-plugins/cli/commands).





  To run this project locally, follow these steps:

  1. Fork this project via GitHub.

  2. Clone this project:
  ```shell
  git clone https://github.com/pieces-app/cli-agent
  ```

  3. Create a Virtual Environment
  ```shell
  python3 -m venv venv
  ```

  4. Activate Your Virtualenv
  ```shell
  source venv/bin/activate for Mac & Linux OS

  cd venv\Scripts for Windows OS
  activate
  ```

  5. This project uses poetry for managing dependencies and builds. Install poetry with:
  ```shell
  pip install poetry
  ```

  6. Then use poetry to install the required dependencies
  ```shell
  poetry install
  ```

  7. You build with
  ```shell
  poetry build
  ```

  8. Finally any project dependencies should be added to the pyproject.toml file with
  ```shell
  poetry add
  ```

  9. Open the Dist folder
  ```shell
  cd dist
  ```

  10. Install the WHL file
  ```shell
  pip install pieces-cli-{VERSION}-py3-none-any.whl
  ```
  replace the VERSION with the version you downloaded
  Note: Ensure you get latest from the [releases](https://github.com/pieces-app/cli-agent/releases) of the cli-agent


  11. To view all the CLI Commands
  ```shell
  pieces help
  ```

  these can be local/github/pypi etc.



  To update the project, run the following command:

  ```shell
  pip install pieces-cli --upgrade
  ```



  To discover and run all the test cases in the repository, run the following command:

  ```shell
  pytest
  ```

  To check the test coverage, you can use the coverage package. Install coverage with:
  ```shell
  pip install coverage
  ```

  Run the tests with coverage using the following command:
  ```shell
  coverage run -m pytest
  coverage report
  ```


  To uninstall the project, run the following command:

  ```shell
  pip uninstall pieces-cli
  ```
  Don't forget to remove the virtual environment and dist folder


pkgId: 9af521c0e2192bb16c0cdb2fd7841ca85b7e958fd4bc2d45545433dd32e4a82b
name: python-pieces_os_client-help
arch: noarch
version: 4.1.0
epoch: 0
release: 1
summary: Development documents and examples for pieces_os_client
url: https://pieces.app
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pieces_os_client-4.1.0-1.src.rpm
location_href: Packages/python-pieces_os_client-help-4.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
      <b>
          <a href="https://pieces.app">
              <picture>
                  <source srcset="https://github.com/user-attachments/assets/6d1c9fc1-11d5-47b0-bb39-a81d40d8fab0" media="(prefers-color-scheme: light)">
                  <source srcset="https://github.com/user-attachments/assets/4529e56f-f614-4743-8ca8-33e0c040b069" media="(prefers-color-scheme: dark)">
                  <img src="https://github.com/user-attachments/assets/4529e56f-f614-4743-8ca8-33e0c040b069" height="125" width="600" />
              </picture>
          </a><br>
      </b>
  </h1>


     <p align="center">
        <a href="https://github.com/pieces-app/pieces-os-client-sdk-for-python/graphs/contributors" alt="GitHub contributors">
           <img src="https://img.shields.io/github/contributors/pieces-app/pieces-os-client-sdk-for-python.svg" />
        </a>
        <a href="https://github.com/pieces-app/pieces-os-client-sdk-for-python/issues" alt="GitHub issues by-label">
           <img src="https://img.shields.io/github/issues/pieces-app/pieces-os-client-sdk-for-python" />
        </a>
        <a href="https://discord.gg/getpieces" alt="Discord">
           <img src="https://img.shields.io/badge/Discord-@layer5.svg?color=7389D8&label&logo=discord&logoColor=ffffff" />
        </a>
        <a href="https://twitter.com/getpieces" alt="Twitter Follow">
           <img src="https://img.shields.io/twitter/follow/pieces.svg?label=Follow" />
        </a>
        <a href="https://github.com/pieces-app/pieces-os-client-sdk-for-python/blob/main/LICENSE" alt="License">
           <img src="https://img.shields.io/github/license/pieces-app/pieces-os-client-sdk-for-python.svg" />
        </a>
        <a href="https://pypi.org/project/pieces_os_client" >
           <img src="https://badge.fury.io/py/pieces-os-client.svg" />
        </a>
        <a href="https://pepy.tech/project/pieces_os_client" >
           <img src="https://static.pepy.tech/badge/pieces_os_client" />
        </a>
     </p>
  </p>




  The Pieces OS Client SDK is a powerful code engine package designed for writing applications on top of Pieces OS. It facilitates communication with a locally hosted server to enable features such as copilot chats, asset saving, and more.


  The Pieces SDK offers the following key features:

  1. Copilot Chats: Communicate seamlessly with copilot chats functionality.
  2. Asset Management: Save and manage assets and formats efficiently.
  3. Local Server Interaction: Interact with a locally hosted server for various functionalities.
  4. Multi LLMs support: Use any Pieces supported LLM to power your app.



  To get started with the Pieces OS Client SDK, follow these steps:

  1. **Download Pieces OS**: Pieces OS serves as the primary backend service, providing essential functionality for the SDK. Download the appropriate version for your operating system:
     - [macOS](https://docs.pieces.app/installation-getting-started/macos)
     - [Windows](https://docs.pieces.app/installation-getting-started/windows)
     - [Linux](https://docs.pieces.app/installation-getting-started/linux)

  2. **Install the SDK**: Use pip to install the Pieces OS Client SDK package:
     ```shell
     pip install pieces_os_client
     ```



  The Pieces OS Client SDK has a built-in wrapper that simplifies the process of interacting with the Pieces OS server. Here's how you can get started with the wrapper.



  ```python
  from pieces_os_client.wrapper import PiecesClient

  pieces_client = PiecesClient()
  ```



  When we initialize the Pieces Client, it defaults to `http://localhost:1000` for macOS/Windows and `http://localhost:5323` for Linux. If you have a remote instance of Pieces OS running, you can specify the host URL when initializing the Pieces Client:

  ```python
  from pieces_os_client.wrapper import PiecesClient


  host_url = "http://your-host-url:your-port"

  pieces_client = PiecesClient(host=host_url)
  ```



  To create a new asset, you can use the `create_asset` method of the Pieces Client. Here's an example of how to create a new asset:

  ```python
  from pieces_os_client.wrapper import PiecesClient
  from pieces_os_client import ClassificationSpecificEnum, FragmentMetadata

  pieces_client = PiecesClient()


  content = "print('Hello, World!')"
  metadata = FragmentMetadata(ext=ClassificationSpecificEnum.PY) # optional metadata


  new_asset_id = pieces_client.create_asset(content, metadata)
  print(f"Created asset with ID: {new_asset_id}")


  pieces_client.close()
  ```



  To get all your assets, you can use the `assets` method of the Pieces Client. Here's an example of how to get all your assets and print their names:

  ```python
  from pieces_os_client.wrapper import PiecesClient

  pieces_client = PiecesClient()


  assets = pieces_client.assets()
  for asset in assets:
     print(f"Asset Name: {asset.name}")


  pieces_client.close()
  ```



  To ask a question to Pieces Copilot and stream the response, you can use the `stream_question` method of the Pieces Client. Here's an example of how to ask a question and stream the response:

  ```python
  from pieces_os_client.wrapper import PiecesClient

  pieces_client = PiecesClient()


  question = "What is Object-Oriented Programming?"


  for response in pieces_client.copilot.stream_question(question):
     if response.question:
           
           answers = response.question.answers.iterable
           for answer in answers:
              print(answer.text,end="")


  pieces_client.close()
  ```



  You can explore more features and functionalities of the built-in wrapper by referring to the [Pieces OS Client Wrapper SDK documentation](https://docs.pieces.app/build/sdks/python).



  If you want to use the Pieces OS Client SDK directly without the built-in wrapper, you can follow these steps to get started.



  First, we will create a Python script to test the connection to the Pieces OS server.

  Create a python file and add the following code to confirm you can connect to your Pieces OS server:

  ```python
  import pieces_os_client
  import platform



  platform_info = platform.platform()
  if 'Linux' in platform_info:
      port = 5323
  else:
      port = 1000


  configuration = pieces_os_client.Configuration(host=f"http://localhost:{port}")


  api_client = pieces_os_client.ApiClient(configuration)


  with pieces_os_client.ApiClient(configuration) as api_client:
      
      api_instance = pieces_os_client.WellKnownApi(api_client)

      try:
          
          api_response = api_instance.get_well_known_health()
          print("The response of WellKnownApi().get_well_known_health:")
          print(api_response) # Response: ok
      except Exception as e:
          print("Exception when calling WellKnownApi->get_well_known_health: %s\n" % e)
  ```

  A developer documentation that outlines all the ins and outs of our available endpoints can be found [here](https://docs.pieces.app/build/reference/python/).


  Explore more about Pieces SDK and get help from the following resources:

  - 🚀 [Getting Started with Pieces](https://docs.pieces.app/installation-getting-started/what-am-i-installing)
  - 📜 [Pieces Docs](https://docs.pieces.app/build)
  - 💬 [Discord Community](https://discord.gg/getpieces)



  This repository is available under the [MIT License](./LICENSE).


pkgId: 7e6b11abe2d87357a23d894cca64fa4ed8878d28c91e5452e24547c6ab57afaf
name: python-pierskarsenbarg-pulumi-sdm-help
arch: noarch
version: 1.23.0
epoch: 0
release: 1
summary: Development documents and examples for pierskarsenbarg-pulumi-sdm
url: https://github.com/pierskarsenbarg/pulumi-sdm
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pierskarsenbarg-pulumi-sdm-1.23.0-1.src.rpm
location_href: Packages/python-pierskarsenbarg-pulumi-sdm-help-1.23.0-1.noarch.rpm
checksum_type: sha256
description:
  The StrongDM Resource Provider lets you manage [StrongDM](http://strongdm.com) resources.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @pierskarsenbarg/sdm
  ```

  or `yarn`:

  ```bash
  yarn add @pierskarsenbarg/sdm
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install pierskarsenbarg-pulumi-sdm
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/pierskarsenbarg/pulumi-sdm/sdk/go/...
  ```



  To use from .NET, install using `dotnet add package`:

  ```bash
  dotnet add package PiersKarsenbarg.Sdm
  ```



  The following configuration points are available for the `sdm` provider:

  - `sdm:apiAccessKey` (environment: `SDM_API_ACCESS_KEY`) - the API key for `Strong DM`
  - `sdm:apiSecretKey` (environment: `SDM_API_SECRET_KEY`) - the corresponding secret key for the above API key



  * Add Java language support
  * Add YAML language support

  <!-- ## Reference

  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/foo/api-docs/). -->


pkgId: 7c3917c25f12cedecbada716c0aae33eb540cf1ab5dae0b5e5be49eceb1a54c2
name: python-pigar-help
arch: noarch
version: 2.1.7
epoch: 0
release: 1
summary: Development documents and examples for pigar
url: https://pypi.org/project/pigar/
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pigar-2.1.7-1.src.rpm
location_href: Packages/python-pigar-help-2.1.7-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/github/actions/workflow/status/damnever/pigar/ci.yml?branch=main&style=flat-square)](https://github.com/damnever/pigar/actions) [![](https://img.shields.io/pypi/v/pigar.svg?style=flat-square)](https://pypi.org/project/pigar)


  - Generating requirements.txt for Python project.
     - Handling the difference between different Python versions.
     - Jupyter notebook (`*.ipynb`) support.
     - Including the import statements/magic from ``exec``/``eval``/``importlib``, doctest of docstring, etc.
  - Searching ditributions(packages) by the top level import/module names.
  - Checking the latest versions of requirements.

  **NOTE**: [Pipenv or other tools](https://packaging.python.org/tutorials/managing-dependencies/#managing-dependencies) is recommended for improving your development flow.




  `pigar` can run on Python 3.7+.

  To install it with `pip`, use:
  ```
  [sudo] pip install pigar
  ```
  To install it with ``conda``, use:
  ```
  conda install -c conda-forge pigar
  ```
  To get the newest code from GitHub:
  ```
  pip install git+https://github.com/damnever/pigar.git@[main or other branch] --upgrade
  ```



  - `pigar` can consider most kinds of complicated situations(see [FAQ](#faq)). For example, `pigar v1` has [py2_requirements.txt](https://github.com/damnever/pigar/blob/c68d372fba4a6f98228ec3cf8e273f59d68d0e3c/py2_requirements.txt) and [py3_requirements.txt](https://github.com/damnever/pigar/blob/c68d372fba4a6f98228ec3cf8e273f59d68d0e3c/py3_requirements.txt) for different Python versions.

      ```
      
      $ pigar generate

      
      $ pigar gen -f ../dev-requirements.txt ../
      ```

      `pigar gen --with-referenced-comments` can list all files which referenced the package/distribution(the line numbers for Jupyter notebook may be a bit confusing), for example:
      ```
      
      
      foobar == 3.3.3
      ```

      If the requirements.txt is overwritten, ``pigar`` will show the difference between the old and the new, use `--dont-show-differences` to disable it.

      **NOTE**, `pigar` will search the packages/distributions in local environment first, then it will do further analysis and search missing packages/distributions on PyPI.

      See also: [EXPERIMENTAL FEATURES](https://github.com/damnever/pigar#experimental-features).

  - If you do not know the import name that belongs to a specific distribution (more generally, does `Import Error: xxx` drive you crazy?), such as `bs4` which may come from `beautifulsoup4` or `MySQLdb` which could come from `mysql-python`, try searching for it:

      ```
      $ pigar search bs4 MySQLdb
      ```

  - Checking for the latest version:

      ```
      
      $ pigar check -f ./requirements.txt

      
      
      $ pigar check
      ```

  - More:

    TIP: `pigar` accepts a prefix for a command, such as `pigar gen`, `pigar c`.
     ```
     pigar --help
     ```




  - `requirement-annotations`

      Some packages may require optional packages/distributions to be installed depending on your usage. To make `pigar` a little bit more useful, use `pigar generate --enable-feature requirement-annotations` in conjunction with comments following the format below:
      ```python
      import foo # pigar: required-imports=import_name_bar,import_name_baz
      import foo # pigar: required-packages=package-name-bar,package-name-baz # Extra comments are allowed.
      foo(features=['bar', 'baz']) # pigar: required-distributions=package-name-bar,package-name-baz
      ```
      If you find the comment intrusive, you can extract those comments into a separate Python file and delete it as needed, for example, 'pigar_annotations.py'.




  <details>
    <summary>
    Is `pigar` a dependency management tool?
    </summary>

  **No.** I've thought about this many times, but there is too much dirty work to be done to make `pigar`'s way reliable.

  I like the way `pigar` does the job, but sadly, `pigar` does a bad job of managing dependencies, `pigar` is more like a tool to assist an old project to migrate to a new development workflow.
  </details>

  <details>
    <summary>
    (1) Why does `pigar` show multiple packages/distributions for the same import name?

    (2) Why does `pigar` generate different packages/distributions for the same import name in different environment?
    </summary>

  `pigar` can not handle those situations gracefully, you may need to remove the duplicate packages in requirements.txt manually, or select one of them when `pigar` asks you.
  Install the required packages/distributions(remove others) in local environment should fix it as well.

  Related issues: [#32](https://github.com/damnever/pigar/issues/32), [#68](https://github.com/damnever/pigar/issues/68), [#75](https://github.com/damnever/pigar/issues/75#issuecomment-605639825).
  </details>

  <details>
    <summary>
    Why can't `pigar` find the packages/distributions that have not been explicit import?
    </summary>

  Some frameworks may use some magic to import the modules for users automatically, and `pigar` can not handle it, you may need to fix it manually or use the [EXPERIMENTAL FEATURES](https://github.com/damnever/pigar#experimental-features).

  Related issues: [#33](https://github.com/damnever/pigar/issues/33), [#103](https://github.com/damnever/pigar/issues/103)
  </details>




  `pigar` does not use regular expressions in such a violent way. Instead, it uses AST, which is a better method for extracting imported names from arguments of `exec`/`eval`/`importlib`, doctest of docstring, etc. However, `pigar` can not solve all the tricky problems, see [FAQ](https://github.com/damnever/pigar#faq).

  Also, `pigar` can detect the difference between different Python versions. For example, you can find `concurrent.futures` from the Python 3.2 standard library, but you will need install `futures` in earlier versions of Python to get `concurrent.futures`, this is not a hardcode.

  If you have any issues or suggestions, [please submit an issue on GitHub](https://github.com/damnever/pigar/issues). [**All contributions are appreciated!**](https://github.com/damnever/pigar/graphs/contributors)




  [The BSD 3-Clause License](https://github.com/damnever/pigar/blob/master/LICENSE)


pkgId: ac6db3de41d8dd6ccc976764f58672b7ec4e558e1fe4af4dc5780577a65329d8
name: python-pimidipy-help
arch: noarch
version: 0.1.2.post1
epoch: 0
release: 1
summary: Development documents and examples for pimidipy
url: https://blokas.io/pimidi/docs/pimidipy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pimidipy-0.1.2.post1-1.src.rpm
location_href: Packages/python-pimidipy-help-0.1.2.post1-1.noarch.rpm
checksum_type: sha256
description:
  `pimidipy` is a Python library developed by [**Blokas**](https://blokas.io/) for Linux ALSA that makes interacting with MIDI devices extremely simple, taking care of all the low-level details for you.

  If you're looking to expand your Raspberry Pi's MIDI capabilities, check out [**Pimidi**](https://blokas.io/pimidi/) by Blokas. Pimidi is a hardware add-on that adds 2 MIDI inputs and 2 MIDI outputs to your Raspberry Pi, and it can be stacked up to 4 units high for even more I/O.

  Check out the full online documentation of `pimidipy` at https://blokas.io/pimidi/docs/pimidipy/.



  The `pimidipy` library offers:

  * A very simple API for working with MIDI data.
  * Automatic handling of device disconnects and reconnects.
  * Available as a [**Patchbox OS**](https://blokas.io/pimidi/docs/pimidipy-patchbox-module/) module by Blokas for easy auto-run setup.



  Here's a very short example of how scripting using `pimidipy` would look like. This works seamlessly with **Pimidi** hardware on Raspberry Pi:

  ```py3

  from pimidipy import *
  pimidipy = PimidiPy()

  input = pimidipy.open_input('pimidi0:0')   # Pimidi IN A
  output = pimidipy.open_output('pimidi0:1') # Pimidi OUT B

  def forward(event):
      print(f'Forwarding event {event} from {input.name} to {output.name}')
      output.write(event)

  input.add_callback(forward)

  pimidipy.run()
  ```

  This is pretty much the base foundation upon which you may build your custom MIDI processing. See the online [API Reference](https://blokas.io/pimidi/docs/pimidipy-reference/) for details on every API.



  We warmly invite the open-source community to help us improve and extend the `pimidipy` library. Whether you want to add new features, fix bugs, or improve documentation, we welcome your contributions!


  1. **Install prerequisites** (if not already installed):
     Make sure `pip` for Python 3 is available on your system. You can install it using:
     ```bash
     sudo apt update
     sudo apt install python3-pip
     ```

  2. **Fork** the repository and clone it to your local machine:
     ```bash
     git clone https://github.com/your-username/pimidipy.git
     cd pimidipy
     ```

  3. **Install the library locally** in editable mode using `pip`:
     ```bash
     pip3 install --break-system-packages -e .
     ```

     This allows you to make changes to the library and test them immediately without needing to reinstall it.

  4. **Make your changes** and test them locally.

  5. **Submit your changes** as a pull request.

  6. Join the conversation in our [community forums](https://community.blokas.io) to discuss ideas, get support, or share your projects.

  Your contributions will help make `pimidipy` even better for everyone. Thank you for being part of the Blokas community!


pkgId: d6caa574c292b70c3bbf439eac4e5a7843b5893629979d45c5d128125c7ba24a
name: python-pimpmyrice-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for pimpmyrice
url: https://github.com/daddodev/pimpmyrice
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pimpmyrice-0.3.2-1.src.rpm
location_href: Packages/python-pimpmyrice-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  _This project is currently in beta and may be subject to breaking changes._





  I heard you like ricing, so I made a ricer for your rices.

  [📄 Documentation](https://pimpmyrice.vercel.app/docs) ║ [📦 Starter Modules](https://pimpmyrice.vercel.app/modules) ║ [💬 Discord](https://discord.gg/TDrSB2wk6c)



  [![showcase_video](video_thumbnail.png)](https://www.youtube.com/watch?v=Z0MnaKWo25U)




  > Ricing refers to the process of customizing the visual appearance and functionality of a desktop environment, usually in Linux or Unix-based systems.<br />
  It involves tweaking themes, icons, fonts, and configurations to achieve a unique and aesthetically pleasing interface.<br />
  A well-customized setup, called a "rice", showcases the user's attention to detail, personality and creativity.

  Take a look at [r/unixporn](https://www.reddit.com/r/unixporn) for inspiration.




  PimpMyRice allows you to generate, organize and apply [themes](https://pimpmyrice.vercel.app/docs/theme) to your system.<br />
  It applies them through [modules](https://pimpmyrice.vercel.app/docs/module), each module being responsible for styling a specific program (eg: [discord](https://github.com/pimpmyrice-modules/betterdiscord)).

  See [overview](https://pimpmyrice.vercel.app/docs/overview) for more information.



  - 🚀 Easy to get started
  - 🛠️ Infinitely customizable
  - 📜 Powerful [file](https://pimpmyrice.vercel.app/docs/module#file) and [shell command](https://pimpmyrice.vercel.app/docs/module#shell) templating using [Jinja](https://jinja.palletsprojects.com/en/3.1.x/templates/)
  - 🐍 [Extendable through Python](https://pimpmyrice.vercel.app/docs/module#python)
  - ⚡ Fast enough
  - 📝 Autocomplete in editor and terminal*
  - 🌈 Color extraction*
  - 🔗 [Server with API](https://github.com/daddodev/pimpmyrice_server)*
  - 🖼️ GUI (coming soon™)

  _*WIP_








  ```bash
  yay -S pimpmyrice

  yay -S pimpmyrice-git
  ```



  ```bash
  pipx install pimpmyrice
  ```



  [Create your own modules](https://pimpmyrice.vercel.app/docs/module) from scratch or clone from the [starter modules](https://pimpmyrice.vercel.app/modules) to get started.

  For example, clone the [alacritty](https://github.com/pimpmyrice-modules/alacritty) module:

  ```bash
  pimp clone module pimp://alacritty
  ```

  Delete a module:
  ```bash
  pimp delete module alacritty
  ```



  Generate a theme from an image:

  ```bash
  pimp gen Downloads/example.png

  pimp gen https://website.com/example.png
  ```

  Set the generated theme:

  ```bash
  pimp set theme example
  ```

  Delete a theme:

  ```bash
  pimp delete theme example
  ```



  Edit the current theme:

  ```bash
  pimp edit theme
  ```


  Edit the base style:

  ```bash
  pimp edit base-style
  ```

  Enjoy ricing! 🍙

  **[<kbd>Browse the documentation</kbd>](https://pimpmyrice.vercel.app/docs/overview)** 



  - [pywal](https://github.com/dylanaraps/pywal)
  - [wpgtk](https://github.com/deviantfero/wpgtk)
  - [r/unixporn](https://www.reddit.com/r/unixporn)


pkgId: 9ae63ac4bd11103bf1dcc9a4549de64cc324134a8bfd85833a41d3c1fb731e21
name: python-pinecone-help
arch: noarch
version: 5.4.2
epoch: 0
release: 1
summary: Development documents and examples for pinecone
url: https://www.pinecone.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pinecone-5.4.2-1.src.rpm
location_href: Packages/python-pinecone-help-5.4.2-1.noarch.rpm
checksum_type: sha256
description:
  ![License](https://img.shields.io/github/license/pinecone-io/pinecone-python-client?color=orange) [![CI](https://github.com/pinecone-io/pinecone-python-client/actions/workflows/pr.yaml/badge.svg)](https://github.com/pinecone-io/pinecone-python-client/actions/workflows/pr.yaml)

  The official Pinecone Python SDK.

  For more information, see the docs at https://docs.pinecone.io



  - [**Reference Documentation**](https://sdk.pinecone.io/python/index.html)





  As part of an overall move to stop exposing generated code in the package's public interface, an obscure configuration property (`openapi_config`) was removed in favor of individual configuration options such as `proxy_url`, `proxy_headers`, and `ssl_ca_certs`. All of these properties were available in v3 and v4 releases of the SDK, with deprecation notices shown to affected users.

  It is no longer necessary to install a separate plugin, `pinecone-plugin-inference`, to try out the [Inference API](https://docs.pinecone.io/guides/inference/understanding-inference); that plugin is now installed by default in the v5 SDK. See [usage instructions below](#inference-api).



  - **Upgrading to `4.x`** : For this upgrade you are unlikely to be impacted by breaking changes unless you are using the `grpc` extras (see install steps below). Read full details in these [v4 Release Notes](https://github.com/pinecone-io/pinecone-python-client/releases/tag/v4.0.0).

  - **Upgrading to `3.x`**: Many things were changed in the v3 SDK to pave the way for Pinecone's new Serverless index offering. These changes are covered in detail in the [**v3 Migration Guide**](https://canyon-quilt-082.notion.site/Pinecone-Python-SDK-v3-0-0-Migration-Guide-056d3897d7634bf7be399676a4757c7b#a21aff70b403416ba352fd30e300bce3). Serverless indexes are only available in `3.x` release versions or greater.



  Many of the brief examples shown in this README are using very small vectors to keep the documentation concise, but most real world usage will involve much larger embedding vectors. To see some more realistic examples of how this SDK can be used, explore some of our many Jupyter notebooks in the [examples](https://github.com/pinecone-io/examples) repository.



  The Pinecone Python SDK is compatible with Python 3.8 and greater.



  There are two flavors of the Pinecone Python SDK. The default flavor installed from PyPI as `pinecone` has a minimal set of dependencies and interacts with Pinecone via HTTP requests.

  If you are aiming to maximimize performance, you can install additional gRPC dependencies to access an alternate SDK implementation that relies on gRPC for data operations. See the guide on [tuning performance](https://docs.pinecone.io/docs/performance-tuning).



  ```shell

  pip3 install pinecone


  pip3 install "pinecone[grpc]"


  pip3 install pinecone==5.0.0


  pip3 install "pinecone[grpc]"==5.0.0
  ```



  ```shell

  poetry add pinecone


  poetry add pinecone --extras grpc


  poetry add pinecone==5.0.0


  poetry add pinecone==5.0.0 --extras grpc
  ```





  Before you can use the Pinecone SDK, you must sign up for an account and find your API key in the Pinecone console dashboard at [https://app.pinecone.io](https://app.pinecone.io).



  The `Pinecone` class is your main entry point into the Pinecone python SDK. If you have set your API Key in the `PINECONE_API_KEY` environment variable, you can instantiate the client with no other arguments.

  ```python
  from pinecone import Pinecone

  pc = Pinecone() # This reads the PINECONE_API_KEY env var
  ```



  If you prefer to pass configuration in code, for example if you have a complex application that needs to interact with multiple different Pinecone projects, the constructor accepts a keyword argument for `api_key`.

  If you pass configuration in this way, you can have full control over what name to use for the environment variable, sidestepping any issues that would result
  from two different client instances both needing to read the same `PINECONE_API_KEY` variable that the client implicitly checks for.

  Configuration passed with keyword arguments takes precedence over environment variables.

  ```python
  import os
  from pinecone import Pinecone

  pc = Pinecone(api_key=os.environ.get('CUSTOM_VAR'))
  ```



  If your network setup requires you to interact with Pinecone via a proxy, you will need
  to pass additional configuration using optional keyword parameters. These optional parameters are forwarded to `urllib3`, which is the underlying library currently used by the Pinecone SDK to make HTTP requests. You may find it helpful to refer to the [urllib3 documentation on working with proxies](https://urllib3.readthedocs.io/en/stable/advanced-usage.html#http-and-https-proxies) while troubleshooting these settings.

  Here is a basic example:

  ```python
  from pinecone import Pinecone

  pc = Pinecone(
      api_key='YOUR_API_KEY',
      proxy_url='https://your-proxy.com'
  )

  pc.list_indexes()
  ```

  If your proxy requires authentication, you can pass those values in a header dictionary using the `proxy_headers` parameter.

  ```python
  from pinecone import Pinecone
  import urllib3 import make_headers

  pc = Pinecone(
      api_key='YOUR_API_KEY',
      proxy_url='https://your-proxy.com',
      proxy_headers=make_headers(proxy_basic_auth='username:password')
  )

  pc.list_indexes()
  ```



  By default the Pinecone Python SDK will perform SSL certificate verification
  using the CA bundle maintained by Mozilla in the [certifi](https://pypi.org/project/certifi/) package.

  If your proxy server is using a self-signed certificate, you will need to pass the path to the certificate in PEM format using the `ssl_ca_certs` parameter.

  ```python
  from pinecone import Pinecone
  import urllib3 import make_headers

  pc = Pinecone(
      api_key="YOUR_API_KEY",
      proxy_url='https://your-proxy.com',
      proxy_headers=make_headers(proxy_basic_auth='username:password'),
      ssl_ca_certs='path/to/cert-bundle.pem'
  )

  pc.list_indexes()
  ```



  If you would like to disable SSL verification, you can pass the `ssl_verify`
  parameter with a value of `False`. We do not recommend going to production with SSL verification disabled.

  ```python
  from pinecone import Pinecone
  import urllib3 import make_headers

  pc = Pinecone(
      api_key='YOUR_API_KEY',
      proxy_url='https://your-proxy.com',
      proxy_headers=make_headers(proxy_basic_auth='username:password'),
      ssl_ca_certs='path/to/cert-bundle.pem',
      ssl_verify=False
  )

  pc.list_indexes()

  ```



  If you've followed instructions above to install with optional `grpc` extras, you can unlock some performance improvements by working with an alternative version of the SDK imported from the `pinecone.grpc` subpackage.

  ```python
  import os
  from pinecone.grpc import PineconeGRPC

  pc = PineconeGRPC(api_key=os.environ.get('PINECONE_API_KEY'))


  index = pc.Index(host='my-index-8833ca1.svc.us-east1-gcp.pinecone.io')

  index.upsert(vectors=[])
  index.query(vector=[...], top_key=10)
  ```







  The following example creates a serverless index in the `us-west-2`
  region of AWS. For more information on serverless and regional availability, see [Understanding indexes](https://docs.pinecone.io/guides/indexes/understanding-indexes#serverless-indexes).

  ```python
  from pinecone import Pinecone, ServerlessSpec

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  pc.create_index(
      name='my-index',
      dimension=1536,
      metric='euclidean',
      deletion_protection='enabled',
      spec=ServerlessSpec(
          cloud='aws',
          region='us-west-2'
      )
  )
  ```



  The following example creates an index without a metadata
  configuration. By default, Pinecone indexes all metadata.

  ```python
  from pinecone import Pinecone, PodSpec

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  pc.create_index(
      name="example-index",
      dimension=1536,
      metric="cosine",
      deletion_protection='enabled',
      spec=PodSpec(
          environment='us-west-2',
          pod_type='p1.x1'
      )
  )
  ```

  Pod indexes support many optional configuration fields. For example,
  the following example creates an index that only indexes
  the "color" metadata field. Queries against this index
  cannot filter based on any other metadata field.

  ```python
  from pinecone import Pinecone, PodSpec

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  metadata_config = {
      "indexed": ["color"]
  }

  pc.create_index(
      "example-index-2",
      dimension=1536,
      spec=PodSpec(
          environment='us-west-2',
          pod_type='p1.x1',
          metadata_config=metadata_config
      )
  )
  ```



  The following example returns all indexes in your project.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  for index in pc.list_indexes():
      print(index['name'])
  ```



  The following example returns information about the index `example-index`.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  index_description = pc.describe_index("example-index")
  ```



  The following example deletes the index named `example-index`. Only indexes which are not protected by deletion protection may be deleted.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  pc.delete_index("example-index")
  ```



  The following example changes the number of replicas for `example-index`.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  new_number_of_replicas = 4
  pc.configure_index("example-index", replicas=new_number_of_replicas)
  ```



  If you would like to enable deletion protection, which prevents an index from being deleted, the `configure_index` method also handles that via an optional `deletion_protection` keyword argument.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')


  pc.configure_index("example-index", deletion_protection='enabled')


  pc.configure_index("example-index", deletion_protection='disabled')


  desc = pc.describe_index("example-index")
  print(desc.deletion_protection)
  ```



  The following example returns statistics about the index `example-index`.

  ```python
  import os
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  index = pc.Index(host=os.environ.get('INDEX_HOST'))

  index_stats_response = index.describe_index_stats()
  ```



  The following example upserts vectors to `example-index`.

  ```python
  import os
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  index = pc.Index(host=os.environ.get('INDEX_HOST'))

  upsert_response = index.upsert(
      vectors=[
          ("vec1", [0.1, 0.2, 0.3, 0.4], {"genre": "drama"}),
          ("vec2", [0.2, 0.3, 0.4, 0.5], {"genre": "action"}),
      ],
      namespace="example-namespace"
  )
  ```



  The following example queries the index `example-index` with metadata
  filtering.

  ```python
  import os
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')



  index = pc.Index(host=os.environ.get('INDEX_HOST'))

  query_response = index.query(
      namespace="example-namespace",
      vector=[0.1, 0.2, 0.3, 0.4],
      top_k=10,
      include_values=True,
      include_metadata=True,
      filter={
          "genre": {"$in": ["comedy", "documentary", "drama"]}
      }
  )
  ```



  The following example deletes vectors by ID.

  ```python
  import os
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')



  index = pc.Index(host=os.environ.get('INDEX_HOST'))

  delete_response = index.delete(ids=["vec1", "vec2"], namespace="example-namespace")
  ```



  The following example fetches vectors by ID.

  ```python
  import os
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')



  index = pc.Index(host=os.environ.get('INDEX_HOST'))

  fetch_response = index.fetch(ids=["vec1", "vec2"], namespace="example-namespace")
  ```



  The following example updates vectors by ID.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')



  index = pc.Index(host=os.environ.get('INDEX_HOST'))

  update_response = index.update(
      id="vec1",
      values=[0.1, 0.2, 0.3, 0.4],
      set_metadata={"genre": "drama"},
      namespace="example-namespace"
  )
  ```



  The `list` and `list_paginated` methods can be used to list vector ids matching a particular id prefix.
  With clever assignment of vector ids, this can be used to help model hierarchical relationships between
  different vectors such as when there are embeddings for multiple chunks or fragments related to the
  same document.

  The `list` method returns a generator that handles pagination on your behalf.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='xxx')
  index = pc.Index(host='hosturl')


  namespace = 'foo-namespace'
  for ids in index.list(prefix='pref', limit=3, namespace=namespace):
      print(ids) # ['pref1', 'pref2', 'pref3']

      
      vectors = index.fetch(ids=ids, namespace=namespace)
  ```

  There is also an option to fetch each page of results yourself with `list_paginated`.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='xxx')
  index = pc.Index(host='hosturl')


  results = index.list_paginated(
      prefix='pref',
      limit=3,
      namespace='foo',
      pagination_token='eyJza2lwX3Bhc3QiOiI5IiwicHJlZml4IjpudWxsfQ=='
  )
  print(results.namespace) # 'foo'
  print([v.id for v in results.vectors]) # ['pref1', 'pref2', 'pref3']
  print(results.pagination.next) # 'eyJza2lwX3Bhc3QiOiI5IiwicHJlZml4IjpudWxsfQ=='
  print(results.usage) # { 'read_units': 1 }
  ```





  The following example creates the collection `example-collection` from
  `example-index`.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  pc.create_collection(
      name="example-collection",
      source="example-index"
  )
  ```



  The following example returns a list of the collections in the current project.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  active_collections = pc.list_collections()
  ```



  The following example returns a description of the collection
  `example-collection`.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  collection_description = pc.describe_collection("example-collection")
  ```



  The following example deletes the collection `example-collection`.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  pc.delete_collection("example-collection")
  ```



  The Pinecone SDK now supports creating embeddings via the [Inference API](https://docs.pinecone.io/guides/inference/understanding-inference).

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key="YOUR_API_KEY")
  model = "multilingual-e5-large"


  text = [
      "Turkey is a classic meat to eat at American Thanksgiving.",
      "Many people enjoy the beautiful mosques in Turkey.",
  ]
  text_embeddings = pc.inference.embed(
      model=model,
      inputs=text,
      parameters={"input_type": "passage", "truncate": "END"},
  )




  query = ["How should I prepare my turkey?"]
  query_embeddings = pc.inference.embed(
      model=model,
      inputs=query,
      parameters={"input_type": "query", "truncate": "END"},
  )


  ```



  If you'd like to make a contribution, or get setup locally to develop the Pinecone Python SDK, please see our [contributing guide](https://github.com/pinecone-io/pinecone-python-client/blob/main/CONTRIBUTING.md)


pkgId: f92f067aed3472c6e3d26468c651cf7f43bcd7a2dae5dd473ead624ee59f9be1
name: python-pinecone-plugin-assistant-help
arch: noarch
version: 0.4.3
epoch: 0
release: 1
summary: Development documents and examples for pinecone-plugin-assistant
url: https://www.pinecone.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pinecone-plugin-assistant-0.4.3-1.src.rpm
location_href: Packages/python-pinecone-plugin-assistant-help-0.4.3-1.noarch.rpm
checksum_type: sha256
description:
  Interact with Pinecone's Assistant APIs, e.g. create, manage, and chat with assistants (currently in beta). Pinecone Assistant is also available in the [console](https://app.pinecone.io/).



  The following example highlights how to use an assistant to store and understand documents on a particular topic and chat with
  the assistant about those documents with the ultimate goal of semantically understanding your data.

  ```python
  from pinecone import Pinecone
  from pinecone_plugins.assistant.models.chat import Message

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')


  space_assistant = pc.assistant.create_assistant(assistant_name="space")


  space_assistant.upload_file("./space-fun-facts.pdf")


  msg = Message(content="How old is the earth?")
  resp = space_assistant.chat_completions(messages=[msg])
  print(resp)












  ```




  To create an assistant, see the below example. This API creates a assistant with the specified name, metadata, and optional timeout settings.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  metadata = {"author": "Jane Doe", "version": "1.0"}

  assistant = pc.assistant.create_assistant(
      assistant_name="example_assistant",
      instructions="Always use British English spelling and vocabulary.",
      metadata=metadata,
      timeout=30
  )
  ```

  Arguments:
  - `assistant_name` The name to assign to the assistant.
      - type: `str`
  - `instructions`  Custom instructions for the assistant. These will be applied to all future chat interactions.
      - type: `Optional[str] = None`
  - `metadata`: A dictionary containing metadata for the assistant.
      - type: `Optional[dict[str, any]] = None`
  - `timeout`: Specify the number of seconds to wait until assistant operation is completed.
      - If None, wait indefinitely until operation completes
      - If >=0, time out after this many seconds
      - If -1, return immediately and do not wait.
      - type: `Optional[int] = None`

  Returns:
  - `AssistantModel` object with the following properties:
      - `name`: Contains the name of the assistant.
      - `instructions`  Custom instructions for the assistant.
      - `metadata`: Contains the provided metadata.
      - `created_at`: Contains the timestamp of when the assistant was created.
      - `updated_at`: Contains the timestamp of when the assistant was last updated.
      - `status`: Contains the status of the assistant. This is one of:
          - 'Initializing'
          - 'Ready'
          - 'Terminating'
          - 'Failed'


  The example below describes/fetches an assistant with the specified name. Will raise a 404 if no model exists with the specified name. There are two methods for this:

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  assistant = pc.assistant.describe_assistant(
      assistant_name="example_assistant",
  )


  assistant = pc.assistant.Assistant(
      assistant_name="example_assistant",
  )
  ```
  Arguments:
  - `assistant_name`: The name of the assistant to fetch.
      - type: `str`, required

  Returns:
  - `AssistantModel` see [Create Assistant](#create-assistant)


  To update an assistant's metadata and/or instructions, see the below example.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')
  metadata = {"author": "Jane Doe", "version": "2.0"}

  assistant = pc.assistant.update_assistant(
      assistant_name="example_assistant",
      instructions="Always use Australian English spelling and vocabulary.",
      metadata=metadata,
  )
  ```

  Arguments:
  - `assistant_name`: The name of the assistant to fetch.
      - type: `str`, required
  - `instructions`  Custom instructions for the assistant. These will be applied to all future chat interactions.
      - type: `Optional[str] = None`
  - `metadata`: A dictionary containing metadata for the assistant. If provided, it will completely replace the existing metadata unless set to `None` (default).
      - type: `Optional[dict[str, any]] = None`

  Returns:
  - `AssistantModel` see [Create Assistant](#create-assistant)



  Lists all assistants created from the current project. Will raise a 404 if no assistant exists with the specified name.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  assistants = pc.assistant.list_assistants()
  ```

  Returns:
  - `List[AssistantModel]` objects


  Deletes a assistant with the specified name. Will raise a 404 if no assistant exists with the specified name.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  pc.assistant.delete_assistant(
      assistant_name="example_assistant",
  )
  ```

  Arguments:
  - `assistant_name`: The name of the assistant to fetch.
      - type: `str`, required

  Returns:
  - NoneType





  Uploads a file from the specified path to this assistant for internal processing.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  assistant = pc.assistant.Assistant(
      assistant_name="example_assistant",
  )


  resp = assistant.upload_file(
      file_path="/path/to/file.txt",
      timeout=None
  )
  ```

  Arguments:
  - `file_path`: The path to the file that needs to be uploaded.
      - type: `str`, required

  - `timeout`: Specify the number of seconds to wait until file processing is done.
      - If `None`, wait indefinitely.
      - If `>= 0`, time out after this many seconds.
      - If `-1`, return immediately and do not wait.
      - type: `Optional[int] = None`

  Return
  - `FileModel` object with the following properties:
      - `id`: The file id of the uploaded file.
      - `name`: The name of the uploaded file.
      - `created_on`: The timestamp of when the file was created.
      - `updated_on`: The timestamp of the last update to the file.
      - `metadata`: Metadata associated with the file.
      - `status`: The status of the file.


  Describes a file with the specified file `id` from this assistant. Includes information on its status and metadata.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  assistant = pc.assistant.Assistant(
      assistant_name="example_assistant",
  )


  file = assistant.describe_file(file_id="070513b3-022f-4966-b583-a9b12e0290ff")
  ```

  Arguments:
  - `file_id`: The file ID of the file to be described.
      - type: `str`, required

  Returns:
  - `FileModel` object with the following properties:
      - `id`: The UUID of the requested file.
      - `name`: The name of the requested file.
      - `created_on`: The timestamp of when the file was created.
      - `updated_on`: The timestamp of the last update to the file.
      - `metadata`: Metadata associated with the file.
      - `status`: The status of the file.


  Lists all uploaded files in this assistant.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  assistant = pc.assistant.Assistant(
      assistant_name="example_assistant",
  )

  files = assistant.list_files()
  ```

  Arguments:
  None

  Returns:
  - `List[FileModel]`, the list of files in the assistant



  Deletes a file with the specified file_id from this assistant.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  assistant = pc.assistant.Assistant(
      assistant_name="example_assistant",
  )


  assistant.delete_file(file_id="070513b3-022f-4966-b583-a9b12e0290ff")
  ```

  Arguments:
  - `file_id`: The file ID of the file to be described.
      - type: `str`, required

  Returns:
  - `NoneType`


  Performs a chat request to the following assistant which returns a stream of chat results in our custom format. Use this API if you want to have more control over the format of the citations. If the stream bool is set to `true`, this function will stream the response in chunks by returning a generator.

  ```python
  from pinecone import Pinecone
  from pinecone_plugins.assistant.models.chat import Message

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  space_assistant = pc.assistant.Assistant(assistant_name="space")

  msg = Message(content="How old is the earth?")
  resp = space_assistant.chat(messages=[msg])


  chunks = space_assistant.chat(messages=[msg], stream=True)

  for chunk in chunks:
      if chunk:
          print(chunk)
  ```

  Arguments:
  - `messages`: The current context for the chat request. The final element in the list represents the user query to be made from this context.
      - type: `List[Message] or List[Dict]` where `Message/Dict` requires the following:
          - `role`: `str`, the role of the context ('user' or 'agent')
          - `content`: `str`, the content of the context

  - `stream`: If this flag is turned on, then the return type is an `Iterable[StreamingChatResultModel]` where data is returned as a generator/stream.
      - type: `bool`, default `false`

  Return:
  - The default result is a `ChatResultModel` with the following format:
      - `finish_reason`: The reason the response finished, e.g., "stop".
      - `index`: The index of the choice in the list.
      - `message`: An object with the following properties:
          - `content`: The content of the message.
          - `role`: The role of the message sender, e.g., "assistant".
      - `id`: The unique identifier of the chat completion.
      - `model`: The model used for the chat completion, e.g., "gpt-3.5-turbo-0613".
      - `citations`: A list of citations with the following structure:
          - `position`: The position of the citation in the document.
          - `references`: A list of references with the following structure:
              - `file`: A dictionary with the following properties:
                  - `created_on`: The timestamp of when the file was created.
                  - `id`: The file ID.
                  - `name`: The name of the file.
                  - `status`: The status of the file.
                  - `updated_on`: The timestamp of the last update to the file.
              - `pages`: The list of pages that the citation references.

  The default result is a ChatModel with the following format:
  ```json
  {
      "finish_reason": "stop",
      "index": 0,
      "message": {
          "content": "The 2020 World Series was played in Texas at Globe Life Field in Arlington.",
          "role": "assistant"
      },
      "id": "chatcmpl-7QyqpwdfhqwajicIEznoc6Q47XAyW",
      "model": "gpt-3.5-turbo-0613",
      "citations": [
          {
              "position": 3,
              "references": [
                  {
                      "file": {
                          "created_on": "2024-06-02T19:48:00Z",
                          "id": "070513b3-022f-4966-b583-a9b12e0290ff",
                          "name": "tiny_file.txt",
                          "status": "Available",
                          "updated_on": "2024-06-02T19:48:00Z"
                      },
                      "pages": [1, 2, 3]
                  }
              ]
          }
      ]
  }
  ```
  - When `stream` is set to `true`, the response is an iterable of `StreamingChatResultModel` objects with the following properties:
      - `choices`: A list with the following structure:
          - `finish_reason`: The reason the response finished, which can be `null` while streaming.
          - `index`: The index of the choice in the list.
          - `delta`: An object with the following properties:
              - `content`: The incremental content of the message.
              - `role`: The role of the message sender, which can be empty while streaming.
          - `logprobs`: The log probabilities (if applicable), otherwise `null`.
      - `id`: The unique identifier of the chat completion.
      - `model`: The model used for the chat completion, e.g., "gpt-4o-2024-05-13".

  - However, when stream is set to true, the response is an stream of ChatResultModel's. This can be one of the following types:
      - StreamChatResultModelMessageStart:
          - `type`: The type of the message, which is "message_start".
          - `id`: The unique identifier of the message.
          - `model`: The model used for the chat completion, e.g., "gpt-4o-2024-05-13".
          - `role`: The role of the message sender, which is "assistant".

      Example:
      ```json
          {
              "type": "message_start",
              "id": "0000000000000000468323be9d266e55",
              "model": "gpt-4o-2024-05-13",
              "role": "assistant"
          }
      ```
      - StreamChatResultModelContentDelta
          - `type`: The type of the message, which is "content_chunk".
          - `id`: The unique identifier of the message.
          - `model`: The model used for the chat completion, e.g., "gpt-4o-2024-05-13".
          - `delta`: An object with the following properties:
              - `content`: The incremental content of the message.
      ```json
          {
              "type": "content_chunk",
              "id": "0000000000000000468323be9d266e55",
              "model": "gpt-4o-2024-05-13",
              "delta": {
                  "content": "The"
              }
          }
      ```
      - StreamChatResultModelCitation
          - `type`: The type of the message, which is "citation".
          - `id`: The unique identifier of the message.
          - `model`: The model used for the chat completion, e.g., "gpt-4o-2024-05-13".
          - `citation`: An object with the following properties:
              - `position`: The position of the citation in the document.
              - `references`: A list of references with the following structure:
                  - `id`: The file ID.
                  - `file`: A dictionary with the following properties:
                      - `status`: The status of the file.
                      - `id`: The file ID.
                      - `name`: The name of the file.
                      - `size`: The size of the file.
                      - `metadata`: The metadata of the file.
                      - `updated_on`: The timestamp of the last update to the file.
                      - `created_on`: The timestamp of when the file was created.
                      - `percent_done`: The percentage of the file that has been processed.
                      - `signed_url`: The signed URL of the file.
                      - `error_message`: A message describing any error during file processing, provided only if an error occurs.
                  - `pages`: The list of pages that the citation references.
      ```json
          {
              "type": "citation",
              "id": "0000000000000000116990b44044d21e",
              "model": "gpt-4o-2024-05-13",
              "citation": {
                  "position": 247,
                  "references": [{
                      "id": "s0",
                      "file": {
                          "status": "Available",
                          "id": "985edb6c-f649-4334-8f14-9a16b7039ab6",
                          "name": "PEPSICO_2022_10K.pdf",
                          "size": 2993516,
                          "metadata": {},
                          "updated_on": "2024-08-08T15:41:58.839846634Z",
                          "created_on": "2024-08-08T15:41:07.427879083Z",
                          "percent_done": 0,
                          "signed_url": "example.com",
                          "error_message": null
                      },
                      "pages": [
                          32
                      ]
                  }]
              }
          }
      ```
      - StreamChatResultModelMessageEnd
          - `type`: The type of the message, which is "message_end".
          - `id`: The unique identifier of the message.
          - `model`: The model used for the chat completion, e.g., "gpt-4o-2024-05-13".
          - `finish_reason`: The reason the response finished, e.g., "stop".
          - `usage`: An object with the following properties:
              - `prompt_tokens`: The number of prompt tokens used.
              - `completion_tokens`: The number of completion tokens used.
              - `total_tokens`: The total number of tokens used.
      ```json
          {
              "type": "message_end",
              "id": "0000000000000000116990b44044d21e",
              "model": "gpt-4o-2024-05-13",
              "finish_reason": "stop",
              "usage": {
                  "prompt_tokens": 1,
                  "completion_tokens": 1,
                  "total_tokens": 2
              }
          }
      ```


  Performs a chat completion request to the following assistant. If the stream bool is set to `true`, this function will stream the response in chunks by returning a generator.


  ```python
  from pinecone import Pinecone
  from pinecone_plugins.assistant.models.chat import Message

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  space_assistant = pc.assistant.Assistant(assistant_name="space")

  msg = Message(content="How old is the earth?")
  resp = space_assistant.chat_completions(messages=[msg])


  chunks = space_assistant.chat_completions(messages=[msg], stream=True)

  for chunk in chunks:
      if chunk:
          print(chunk)
  ```

  Arguments:
  - `messages`: The current context for the chat request. The final element in the list represents the user query to be made from this context.
      - type: `List[Message] or List[Dict]` where `Message/Dict` requires the following:
          - `role`: `str`, the role of the context ('user' or 'agent')
          - `content`: `str`, the content of the context

  - `stream`: If this flag is turned on, then the return type is an `Iterable[StreamingChatResultModel]` where data is returned as a generator/stream.
      - type: `bool`, default `false`

  Return:
  - The default result is a `ChatResultModel` with the following format:
      - `choices`: A list with the following structure:
          - `finish_reason`: The reason the response finished, e.g., "stop".
          - `index`: The index of the choice in the list.
          - `message`: An object with the following properties:
              - `content`: The content of the message.
              - `role`: The role of the message sender, e.g., "assistant".
          - `logprobs`: The log probabilities (if applicable), otherwise `null`.
      - `id`: The unique identifier of the chat completion.
      - `model`: The model used for the chat completion, e.g., "gpt-3.5-turbo-0613".

  See the example below
  ```json
  {
      "choices": [
          {
              "finish_reason": "stop",
              "index": 0,
              "message": {
                  "content": "The 2020 World Series was played in Texas at Globe Life Field in Arlington.",
                  "role": "assistant"
              },
              "logprobs": null
          }
      ],
      "id": "00000000000000005c12d4d71263b642",
      "model": "space"
  }
  ```
  - When `stream` is set to `true`, the response is an iterable of `StreamingChatResultModel` objects with the following properties:
      - `choices`: A list with the following structure:
          - `finish_reason`: The reason the response finished, which can be `null` while streaming.
          - `index`: The index of the choice in the list.
          - `delta`: An object with the following properties:
              - `content`: The incremental content of the message.
              - `role`: The role of the message sender, which can be empty while streaming.
          - `logprobs`: The log probabilities (if applicable), otherwise `null`.
      - `id`: The unique identifier of the chat completion.
      - `model`: The model used for the chat completion, e.g., "gpt-3.5-turbo-0613".

  See the example below
  ```json
      {
          "choices": [
              {
                  "finish_reason": null,
                  "index": 0,
                  "delta": {
                      "content": "The",
                      "role": ""
                  },
                  "logprobs": null
              }
          ],
          "id": "00000000000000005d487d0ba0cde006",
          "model": "space"
      }
  ```



  Performs a context request to the assistant and returns the content that might be used as part of a RAG system.
  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key='<<PINECONE_API_KEY>>')

  space_assistant = pc.assistant.Assistant(assistant_name="space")

  resp = space_assistant.context(query="How old is the earth?")

  print(resp)
  ```

  Arguments:
  - `query`: The query to be used in the context request.
      - type: `str`

  - `filter`: Optional dictionary to filter which documents can be used in this query. Use this to narrow down the context for the assistant's response.
      - type: `dict`, default `None`

  Return:
  - The default result is a `ContextResponse` with the following format:
      - `snippets`: A list of snippets with the following structure:
          - `type`: The type of the content.
          - `content`: The content of the snippet.
          - `reference`: The reference of the snippet. Can be of type `PdfReference`, `TextReference`, `MarkdownReference`, or `JsonReference`.
              - `type`: The type of the reference.
              - `file`: A dictionary with the following properties:
                  - `created_on`: The timestamp of when the file was created.
                  - `id`: The file ID.
                  - `name`: The name of the file.
                  - `status`: The status of the file.
                  - `updated_on`: The timestamp of the last update to the file.
                  - `metadata`: The metadata of the file.
                  - `percent_done`: The percentage of the file that has been processed.
                  - `signed_url`: The signed URL of the file.
                  - `error_message`: A message describing any error during file processing, provided only if an error occurs.
              - `pages`: The list of pages that the citation references. (Only available for `PdfReference`)
      - `usage`: An object with the following properties:
          - `prompt_tokens`: The number of prompt tokens used.
          - `completion_tokens`: The number of completion tokens used.
          - `total_tokens`: The total number of tokens used.
  The default result is a ChatModel with the following format:
  ```json
  {
    "snippets": [
      {
        "type":" text",
        "content": "The quick brown fox jumps over the lazy dog.",
        "score": 0.9946,
        "reference": {
          "type": "pdf",
          "file": {
            "id": "96e6e2de-82b2-494d-8988-7dc88ce2ac01",
            "metadata": null,
            "name": "sample.pdf",
            "percent_done": 1.0,
            "status": "Available",
            "created_on": "2024-11-13T14:59:53.369365582Z",
            "updated_on": "2024-11-13T14:59:55.369365582Z",
            "signed_url": "https://storage.googleapis.com/...",
            "error_message": null
          },
          "pages": [1]
        }
      }
    ],
    "usage": {
      "completion_tokens": 0,
      "prompt_tokens": 506,
      "total_tokens": 506
    }
  }
  ```


pkgId: 27ca73bd9e9ba3d591b92d028ffd57ace0d198c80bdd3e8305937504a3e2762a
name: python-pinecone-plugin-records-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for pinecone-plugin-records
url: https://www.pinecone.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pinecone-plugin-records-1.0.1-1.src.rpm
location_href: Packages/python-pinecone-plugin-records-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  The plugin is distributed separately from the core python SDK.

  ```

  pip install pinecone


  pip install pinecone-plugin-records
  ```



  This plugin extends the functionality of the `pinecone` SDK to allow creating indexes for specific embedding models, and upserting and searching records in these indexes. These operations are added to the existing `Pinecone` and `Index` classes.

  Models currently supported:

  - [multilingual-e5-large](https://arxiv.org/pdf/2402.05672)



  The following example highlights how to use the `Pinecone` class to create a new index for an embedding model, and then uses `Index` to upsert and search some records.

  ```python
  from pinecone import Pinecone

  pc = Pinecone(api_key="<<PINECONE_API_KEY>>")


  index_model = pc.create_index_for_model(
      name="my-model-index",
      cloud="aws",
      region="us-east-1",
      embed={
          "model":"multilingual-e5-large",
          "field_map": {"text": "my_text_field"}
      }
  )


  index = pc.Index(host=index_model.host)


  index.upsert_records(
      "my-namespace",
      [
          {
              "_id": "test1",
              "my_text_field": "Apple is a popular fruit known for its sweetness and crisp texture.",
          },
          {
              "_id": "test2",
              "my_text_field": "The tech company Apple is known for its innovative products like the iPhone.",
          },
          {
              "_id": "test3",
              "my_text_field": "Many people enjoy eating apples as a healthy snack.",
          },
          {
              "_id": "test4",
              "my_text_field": "Apple Inc. has revolutionized the tech industry with its sleek designs and user-friendly interfaces.",
          },
          {
              "_id": "test5",
              "my_text_field": "An apple a day keeps the doctor away, as the saying goes.",
          },
          {
              "_id": "test6",
              "my_text_field": "Apple Computer Company was founded on April 1, 1976, by Steve Jobs, Steve Wozniak, and Ronald Wayne as a partnership.",
          },
      ],
  )


  response = index.search_records(
      namespace="test-namespace",
      query={
          "inputs":{
              "text": "Apple corporation",
          },
          "top_k":3,
      },
      rerank={
          "model": "bge-reranker-v2-m3",
          "rank_fields": ["my_text_field"],
          "top_n": 3,
      },
  )
  ```


pkgId: ed2481f25517276cc609bc5ca6c3fdcd5ca9554de478e9433739d4378040a856
name: python-pins-help
arch: noarch
version: 0.8.7
epoch: 0
release: 1
summary: Development documents and examples for pins
url: https://github.com/rstudio/pins-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pins-0.8.7-1.src.rpm
location_href: Packages/python-pins-help-0.8.7-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://rstudio.github.io/pins-python/"><img src="docs/logo.png" align="right" height="138" /></a>

  ![PyPI - Version](https://img.shields.io/pypi/v/pins.svg) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pins) [![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)



  The pins package publishes data, models, and other Python objects,
  making it easy to share them across projects and with your colleagues.
  You can pin objects to a variety of pin *boards*, including folders (to
  share on a networked drive or with services like DropBox), Posit
  Connect, Amazon S3, and Google Cloud Storage. Pins can be automatically
  versioned, making it straightforward to track changes, re-run analyses
  on historical data, and undo mistakes.

  See the [documentation](https://rstudio.github.io/pins-python) for
  getting started.

  You can use pins from R as well as Python. For example, you can use one
  language to read a pin created with the other. Learn more about [pins
  for R](https://pins.rstudio.com).



  You can install the released version of pins from
  [PyPI](https://pypi.org/project/pins/):

  ``` shell
  python -m pip install pins
  ```

  And the development version from
  [GitHub](https://github.com/rstudio/pins-python) with:

  ``` shell
  python -m pip install git+https://github.com/rstudio/pins-python
  ```



  To use the pins package, you must first create a pin board. A good place
  to start is `board_folder()`, which stores pins in a directory you
  specify. Here I’ll use a special version of `board_folder()` called
  `board_temp()` which creates a temporary board that’s automatically
  deleted when your Python script or notebook session ends. This is great
  for examples, but obviously you shouldn’t use it for real work!

  ``` python
  import pins
  from pins.data import mtcars

  board = pins.board_temp()
  ```

  You can “pin” (save) data to a board with the `.pin_write()` method. It
  requires three arguments: an object, a name, and a pin type:

  ``` python
  board.pin_write(mtcars.head(), "mtcars", type="csv")
  ```

      Writing pin:
      Name: 'mtcars'
      Version: 20230523T115348Z-120a5

      Meta(title='mtcars: a pinned 5 x 11 DataFrame', description=None, created='20230523T115348Z', pin_hash='120a54f7e0818041', file='mtcars.csv', file_size=249, type='csv', api_version=1, version=Version(created=datetime.datetime(2023, 5, 23, 11, 53, 48, 555797), hash='120a54f7e0818041'), tags=None, name='mtcars', user={}, local={})

  Above, we saved the data as a CSV, but depending on what you’re saving
  and who else you want to read it, you might use the `type` argument to
  instead save it as a `joblib`, `parquet`, or `json` file.

  You can later retrieve the pinned data with `.pin_read()`:

  ``` python
  board.pin_read("mtcars")
  ```

          mpg  cyl   disp   hp  drat     wt   qsec  vs  am  gear  carb
      0  21.0    6  160.0  110  3.90  2.620  16.46   0   1     4     4
      1  21.0    6  160.0  110  3.90  2.875  17.02   0   1     4     4
      2  22.8    4  108.0   93  3.85  2.320  18.61   1   1     4     1
      3  21.4    6  258.0  110  3.08  3.215  19.44   1   0     3     1
      4  18.7    8  360.0  175  3.15  3.440  17.02   0   0     3     2

  A board on your computer is good place to start, but the real power of
  pins comes when you use a board that’s shared with multiple people. To
  get started, you can use `board_folder()` with a directory on a shared
  drive or in DropBox, or if you use [Posit
  Connect](https://posit.co/products/enterprise/connect/) you can use
  `board_connect()`:

  ``` python



  board = pins.board_connect()
  board.pin_write(tidy_sales_data, "hadley/sales-summary", type="csv")
  ```

  Then, someone else (or an automated report) can read and use your pin:

  ``` python
  board = board_connect()
  board.pin_read("hadley/sales-summary")
  ```

  You can easily control who gets to access the data using the Posit
  Connect permissions pane.

  The pins package also includes boards that allow you to share data on
  services like Amazon’s S3 (`board_s3()`), Google Cloud Storage
  (`board_gcs()`), and Azure blob storage (`board_azure()`).



  - This project is released with a [Contributor Code of
    Conduct](https://www.contributor-covenant.org/version/2/1/CODE_OF_CONDUCT.html).
    By contributing to this project, you agree to abide by its terms.

  - If you think you have encountered a bug, please [submit an
    issue](https://github.com/rstudio/pins-python/issues).


pkgId: c2cc16a9cf9935c4dd40630dca9b529c6a14cdf657415b1317d715efa38df1e6
name: python-pint-pal-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for pint-pal
url: https://github.com/nanograv/pint_pal
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pint-pal-0.3.0-1.src.rpm
location_href: Packages/python-pint-pal-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [PINT](https://github.com/nanograv/PINT) is necessary for core functionality of `pint_pal`, but the following packages are also required to do detailed outlier inspection and run noise analyses:
  - [enterprise](https://github.com/nanograv/enterprise)
  - [enterprise_extensions](https://github.com/nanograv/enterprise_extensions)
  - [enterprise_outliers](https://github.com/nanograv/enterprise_outliers)
  - [pypulse](https://github.com/mtlam/PyPulse)
  There are instructions for installing these packages and setting up your environment here: https://github.com/ipta/pulsar-env. Please note that installing `mamba` must be done from a clean (base) `conda` environment; you can make and activate a fresh environment with, e.g.:
  ```
  $ conda create --name installer && conda activate installer
  ```


pkgId: 3f7135ddb7f2f0602bb23cf8d490d67db4ccaee60b63afdd0111aedd27ae4b5c
name: python-pinterest-dl-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for pinterest-dl
url: https://github.com/sean1832/pinterest-dl
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pinterest-dl-0.3.2-1.src.rpm
location_href: Packages/python-pinterest-dl-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  **Scraping Images in anonymous mode:**
  Scrape images in anonymous mode, without login, to the `./images/art` directory from the Pinterest URL `https://www.pinterest.com/pin/1234567` with a limit of `30` images and a minimum resolution of `512x512`. Save scraped URLs to a `JSON` file.
  ```bash
  pinterest-dl scrape "https://www.pinterest.com/pin/1234567" "images/art" -l 30 -r 512x512 --json
  ```
  **Get Browser Cookies:**
  Get browser cookies for Pinterest login and save them to the `cookies.json` file in headful mode (with browser window).
  ```bash
  pinterest-dl login -o cookies.json --headful
  ```
  > [!TIP]
  > You will be prompted to enter your Pinterest email and password. The tool will save the browser cookies to the specified file for future use.
  **Scraping Private Boards:**
  Scrape images from a private Pinterest board using the cookies saved in the `cookies.json` file.
  ```bash
  pinterest-dl scrape "https://www.pinterest.com/pin/1234567" "images/art" -l 30 -c cookies.json
  ```
  > [!TIP]
  > You can use the `--client` option to use `chrome` or `firefox` Webdriver for scraping. This is slower but more reliable.
  > It will open a browser in headless mode to scrape images. You can also use the `--headful` flag to run the browser in windowed mode.
  **Downloading Images:**
  Download images from the `art.json` file to the `./downloaded_imgs` directory with a minimum resolution of `1024x1024`.
  ```bash
  pinterest-dl download art.json -o downloaded_imgs -r 1024x1024


pkgId: 4014fe124e0cba7d8414ec50d88bfbcec9a0a0a33f8c4db6ec5d95ca4256eb28
name: python-pip-audit-extra-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for pip-audit-extra
url: https://github.com/Kirill-Lekhov/pip-audit-extra
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pip-audit-extra-0.0.1-1.src.rpm
location_href: Packages/python-pip-audit-extra-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Extended version of [pip-audit](https://pypi.org/project/pip-audit/).


  * Viewing vulnerabilities of project dependencies along with severities.


  ```sh
  pip install pip-audit-extra
  ```


  ```sh
  cat requirements.txt | pip-audit-extra
  ```

  Poetry
  ```sh
  poetry export -f requirements.txt | pip-audit-extra
  ```

  UV
  ```sh
  uv export --format requirements-txt | pip-audit-extra
  ```


  If necessary, you can filter vulnerabilities by severity.
  By default, the filter selects vulnerabilities with the specified severity AND SEVERITIES WITH A HIGHER PRIORITY.
  It only affects the vulnerability table.
  ```sh
  cat requirements.txt | pip-audit-extra --severity CRITICAL
  ```

  To select only the specified level, add the prefix `~`, for example:
  ```sh
  cat requirements.txt | pip-audit-extra --severity ~CRITICAL
  ```


  You can set severity of vulnerability from which the audit will be considered to have failed.
  ```sh
  cat requirements.txt | pip-audit-extra --fail-level HIGH
  ```
  In this example, the audit will be considered failed if vulnerabilities of CRITICAL or HIGH severity are found.


  Caching is used to speed up re-auditing by maintaining the severity of vulnerabilities.

  By default, cached record is valid for a day from the moment of saving.
  You can control the lifetime of entries in the cache.

  ```sh

  cat requirements.txt | pip-audit-extra --cache-lifetime 1d


  cat requirements.txt | pip-audit-extra --cache-lifetime 0


  cat requirements.txt | pip-audit-extra --cache-lifetime 60


  cat requirements.txt | pip-audit-extra --cache-lifetime 604800


  cat requirements.txt | pip-audit-extra --cache-lifetime 15s


  cat requirements.txt | pip-audit-extra --cache-lifetime 30m


  cat requirements.txt | pip-audit-extra --cache-lifetime 12h


  cat requirements.txt | pip-audit-extra --cache-lifetime 7d
  ```


pkgId: 6cf5691b339e57bd9b7f44c699cb12b9bdd00c437292f36e6a23ac990cf6b597
name: python-pip-start-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for pip-start
url: https://github.com/Veillax/pip_start
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pip-start-0.1.2-1.src.rpm
location_href: Packages/python-pip-start-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/pip-start?label=Version)
  ![PyPI - License](https://img.shields.io/pypi/l/pip-start?label=License)
  ![GitHub Release Date](https://img.shields.io/github/release-date/Veillax/pip-start?label=Release%20Date)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/pip-start?label=Downloads)

  pip-start is a custom package I worte to allow simple and seamless auto-updating of packages that need it, such as game API Wrappers.


pkgId: b1446269858f1dbb85ca6cbe3365cb42057e1e88b66e9a429e7c5d99f9abf486
name: python-pipeline-gazprom-infotech-help
arch: noarch
version: 1.0
epoch: 0
release: 1
summary: Development documents and examples for pipeline-gazprom-infotech
url: https://github.com/vb64/pipeline.gazprom.infotech
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipeline-gazprom-infotech-1.0-1.src.rpm
location_href: Packages/python-pipeline-gazprom-infotech-help-1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/vb64/pipeline.gazprom.infotech/pep257.yml?label=Pep257&style=plastic&branch=main)](https://github.com/vb64/pipeline.gazprom.infotech/actions?query=workflow%3Apep257)
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/vb64/pipeline.gazprom.infotech/py3.yml?label=Python%203.8-3.12&style=plastic&branch=main)](https://github.com/vb64/pipeline.gazprom.infotech/actions?query=workflow%3Apy3)
  [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/6a82eaf82a6448f9ac8e9b73f8976eb2)](https://app.codacy.com/gh/vb64/pipeline.gazprom.infotech/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/6a82eaf82a6448f9ac8e9b73f8976eb2)](https://app.codacy.com/gh/vb64/pipeline.gazprom.infotech/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)

  The free, open source PipelineGazpromInfotech library is designed to making infotech.xml files.


pkgId: 93be6f42b94d95bf75740d25d2b7ed8a7870c43ac1690a554f95433b05594531
name: python-pipeline-gazprom-infotech-help
arch: noarch
version: 1.1
epoch: 0
release: 1
summary: Development documents and examples for pipeline-gazprom-infotech
url: https://github.com/vb64/pipeline.gazprom.infotech
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipeline-gazprom-infotech-1.1-1.src.rpm
location_href: Packages/python-pipeline-gazprom-infotech-help-1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/vb64/pipeline.gazprom.infotech/pep257.yml?label=Pep257&style=plastic&branch=main)](https://github.com/vb64/pipeline.gazprom.infotech/actions?query=workflow%3Apep257)
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/vb64/pipeline.gazprom.infotech/py3.yml?label=Python%203.8-3.13&style=plastic&branch=main)](https://github.com/vb64/pipeline.gazprom.infotech/actions?query=workflow%3Apy3)
  [![Codacy Badge](https://app.codacy.com/project/badge/Coverage/6a82eaf82a6448f9ac8e9b73f8976eb2)](https://app.codacy.com/gh/vb64/pipeline.gazprom.infotech/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/6a82eaf82a6448f9ac8e9b73f8976eb2)](https://app.codacy.com/gh/vb64/pipeline.gazprom.infotech/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)

  The free, open source PipelineGazpromInfotech library is designed to making infotech.xml files.



  ```bash
  pip install pipeline-gazprom-infotech
  ```



  ```bash
  git clone git@github.com:vb64/pipeline.gazprom.infotech.git
  cd pipeline.gazprom.infotech
  make setup PYTHON_BIN=/path/to/python3
  make tests
  ```


pkgId: 1a7e79470c940917dab922aee29b17a7847de9aa8769c17d66d05556f7b83f5b
name: python-pipelineer-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for pipelineer
url: https://pypi.org/project/pipelineer/
rpm_license: "MIT"
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipelineer-1.0.0-1.src.rpm
location_href: Packages/python-pipelineer-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  El comando `make template` configura las plantillas necesarias para trabajar con DAGs. Este comando sobrescribe el contenido de un archivo que comience con `dag_` en la raíz del proyecto con el contenido de una plantilla predefinida.

  ```bash
  pipelineer make template --type {oracle|api}
  ```

  - `--type`: Especifica el tipo de plantilla a utilizar. Las opciones disponibles son:
    - `oracle`: Configura la plantilla para trabajar con esquemas de Oracle.
    - `api`: Configura la plantilla para trabajar con APIs.

  ```bash
  pipelineer make template --type oracle
  ```

  - El archivo `dag_` debe estar presente en la raíz del proyecto. Si no se encuentra, se mostrará un mensaje de error.


pkgId: 32a05999880dd06f60be19dd7e275e88aae845729f86bc0e200a0f1d2cc6207b
name: python-pipelineer-help
arch: noarch
version: 2.0.3
epoch: 0
release: 1
summary: Development documents and examples for pipelineer
url: https://pypi.org/project/pipelineer/
rpm_license: "MIT"
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipelineer-2.0.3-1.src.rpm
location_href: Packages/python-pipelineer-help-2.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Pipelineer organiza sus funcionalidades en subcomandos bajo el comando principal `make`.

  Configura plantillas necesarias para trabajar con DAGs. Sobrescribe el contenido de un archivo con prefijo `dag_` en la raíz del proyecto utilizando una plantilla predefinida.

  ```bash
  pipelineer make template --type {oracle|api}
  ```

  | Argumento | Descripción                                      | Opciones       | Obligatorio |
  |-----------|--------------------------------------------------|----------------|-------------|
  | `--type`  | Especifica el tipo de plantilla a utilizar.      | `oracle`, `api`| Sí          |

  ```bash
  pipelineer make template --type oracle


pkgId: 37ef04fea8716496683e54d0c315f2c9181ed4d3182a0e5d6fd6e88fdc8bfd50
name: python-pipen-annotate-help
arch: noarch
version: 0.14.1
epoch: 0
release: 1
summary: Development documents and examples for pipen-annotate
url: https://pypi.org/project/pipen-annotate/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipen-annotate-0.14.1-1.src.rpm
location_href: Packages/python-pipen-annotate-help-0.14.1-1.noarch.rpm
checksum_type: sha256
description:
  Use docstring to annotate [pipen](https://github.com/pwwang/pipen) processes



  ```shell
  pip install -U pipen-annotate
  ```



  ```python
  from pprint import pprint
  from pipen import Proc
  from pipen_annotate import annotate


  class Process(Proc):
      """Short description

      Long description

      Input:
          infile: An input file
          invar: An input variable

      Output:
          outfile: The output file

      Envs:
          ncores (type=int): Number of cores
      """
      input = "infile:file, invar"
      output = "outfile:file:output.txt"
      args = {'ncores': 1}

  annotated = annotate(Process)

  {'Envs': {'ncores': {'attrs': {'type': 'int'},
                       'help': 'Number of cores',
                       'name': 'ncores',
                       'terms': {}}},
   'Input': {'infile': {'attrs': {'action': 'extend',
                                  'itype': 'file',
                                  'nargs': '+'},
                        'help': 'An input file',
                        'name': 'infile',
                        'terms': {}},
             'invar': {'attrs': {'action': 'extend',
                                 'itype': 'var',
                                 'nargs': '+'},
                       'help': 'An input variable',
                       'name': 'invar',
                       'terms': {}}},
   'Output': {'outfile': {'attrs': {'default': 'output.txt', 'otype': 'file'},
                          'help': 'The output file',
                          'name': 'outfile',
                          'terms': {}}},
   'Summary': {'long': 'Long description', 'short': 'Short description'}}
  ```


pkgId: 2aa6779e2e91a157f5c1e33d99f2039176d46573d8a2ba1d8af4788c640895ed
name: python-pipen-gcs-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for pipen-gcs
url: https://pypi.org/project/pipen-gcs/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipen-gcs-0.0.3-1.src.rpm
location_href: Packages/python-pipen-gcs-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  A plugin for [pipen][1] to handle files in Google Cloud Storage



  ```bash
  pip install -U pipen-gcs


  pip uninstall pipen-gcs
  ```



  ```python
  from pipen import Proc, Pipen

  class MyProc(Proc):
      input = "infile:file"
      input_data = ["gs://bucket/path/to/file"]
      output = "outfile:file:gs://bucket/path/to/output"
      script = "cat {{in.infile}} > {{out.outfile}}"

  class MyPipen(Pipen):
      starts = MyProc
      
      
      
      plugin_opts = {"gcs_localize": "/tmp"}

  if __name__ == "__main__":
      MyPipen().run()
  ```

  You can also disable localization, then you will have to handle the
  cloud storage files yourself.

  ```python
  from pipen import Proc, Pipen

  class MyProc(Proc):
      input = "infile:file"
      input_data = ["gs://bucket/path/to/file"]
      output = "outfile:file:gs://bucket/path/to/output"
      script = "gsutil cp {{in.infile}} {{out.outfile}}"

  class MyPipen(Pipen):
      starts = MyProc
      plugin_opts = {"gcs_localize": False}

  if __name__ == "__main__":
      MyPipen().run()
  ```



  - `gcs_localize`: The directory to localize the cloud storage files. If
    set to `False`, the files will not be localized. Default is `False`.
  - `gcs_localize_force`: If set to `True`, the files will be localized
    even if they exist locally. Default is `False`.
  - `gcs_credentials`: The path to the Google Cloud Service Account
    credentials file.

  [1]: https://github.com/pwwang/pipen


pkgId: 1fc543fb7ed0f71516f5ae46958d9f68e35f40fce4d433b9a50f5456855b8170
name: python-piperider-nightly-help
arch: noarch
version: 0.42.0.20241215
epoch: 0
release: 1
summary: Development documents and examples for piperider-nightly
url: https://github.com/InfuseAI/piperider
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-piperider-nightly-0.42.0.20241215-1.src.rpm
location_href: Packages/python-piperider-nightly-help-0.42.0.20241215-1.noarch.rpm
checksum_type: sha256
description:
  [![ci-tests](https://github.com/infuseai/piperider-cli/actions/workflows/tests.yaml/badge.svg)](https://github.com/infuseai/piperider-cli/actions/workflows/tests.yaml/badge.svg)
  [![codecov](https://codecov.io/gh/InfuseAI/piperider/branch/main/graph/badge.svg?token=iVbQKGM1JA)](https://codecov.io/gh/InfuseAI/piperider)
  [![release](https://img.shields.io/github/release/infuseAI/piperider-cli/all.svg?style=flat-square)](https://github.com/infuseAI/piperider-cli/releases)
  [![pipy](https://img.shields.io/pypi/v/piperider?style=flat-square)](https://pypi.org/project/piperider/)
  [![python](https://img.shields.io/pypi/pyversions/piperider?style=flat-square)](https://pypi.org/project/piperider/)
  [![downloads](https://img.shields.io/pypi/dw/piperider?style=flat-square)](https://pypi.org/project/piperider/#files)
  [![license](https://img.shields.io/github/license/infuseai/piperider?style=flat-square)](https://github.com/InfuseAI/piperider/blob/main/LICENSE)
  [![InfuseAI Discord Invite](https://img.shields.io/discord/664381609771925514?color=%237289DA&label=chat&logo=discord&logoColor=white&style=flat-square)](https://discord.com/invite/5zb2aK9KBV)

  <p align="left">
    <a href="https://docs.piperider.io/" alt="documentation site" title="Piperider Documentation"> Docs </a> |
    <a href="https://discord.com/invite/5zb2aK9KBV"> Discord </a> |
    <a href="https://blog.infuseai.io/data-reliability-automated-with-piperider-7a823521ef11"> Blog </a>
  </p>

  > \[!IMPORTANT\]
  > PipeRider has been superseded by [Recce](https://datarecce.io). We recommend that users requiring pre-merge data validation checks migrate to Recce. PipeRider will not longer be updated on a regular basis. You are still welcome to open a PR with bug fixes or feature requests. For questions and help regarding this update, please contact [product@piperider.io](mailto:product@infuseai.io) or leave a message in the [Recce Discord](https://discord.gg/VpwXRC34jz).



  PipeRider automatically compares your data to highlight the difference in impacted downstream dbt models so you can
  merge your Pull Requests with confidence.



  - Easy to connect your datasource -> PipeRider leverages
    the [connection profiles in your dbt project](https://docs.getdbt.com/docs/get-started/connection-profiles) to connect
    to the data warehouse
  - Generate profiling statistics of your models to get a high-level overview of your data
  - Compare target branch changes with the main branch in a HTML report
  - Post a quick summary of the data changes to your PR, so others can be confident too



  - **Easy to install**: Leveraging dbt's configuration settings, PipeRider can be installed within 2 minutes
  - **Fast comparison**: by collecting profiling statistics (e.g. uniqueness, averages, quantiles, histogram) and metric
    queries, comparing downstream data impact takes little time, speeding up your team's review time
  - **Valuable insights**: various profiling statistics displayed in the HTML report give fast insights into your data



  1. **Install PipeRider**

     ```bash
     pip install piperider[<connector>]
     ```

     You can find all supported data source connectors [here](https://docs.piperider.io/reference/supported-data-sources).

  1. **Add PipeRider tag on your model**: Go to your dbt project, and add the PipeRider tag on the model you want to
     profile.

     ```sql
     --models/staging/stg_customers.sql
     {{ config(
        tags=["piperider"]
     ) }}

     select ...
     ```

     and show the models would be run by piperider

     ```
      dbt list -s tag:piperider --resource-type model
     ```

  1. **Run PipeRider**

     ```bash
     piperider run
     ```

  To see the full quick start guide, please refer
  to [PipeRider documentation](https://docs.piperider.io/get-started/quick-start)



  - **Model profiling**: PipeRider can profile your [dbt models](https://docs.getdbt.com/docs/build/models) and obtain
    information such as basic data composition, quantiles, histograms, text length, top categories, and more.
  - **Metric queries**: PipeRider can integrate with [dbt metrics](https://docs.getdbt.com/docs/build/metrics) and present
    the time-series data of metrics in the report.
  - **HTML report**: PipeRider generates a static HTML report each time it runs, which can be viewed locally or shared.
  - **Report comparison**: You can compare two previously generated reports or use a single command to compare the
    differences between the current branch and the main branch. The latter is designed specifically for code review
    scenarios. In our pull requests on GitHub, we not only want to know which files have been changed, but also the impact
    of these changes on the data. PipeRider can easily generate comparison reports with a single command to provide this
    information.
  - **CI integration**: The key to CI is automation, and in the code review process, automating this workflow is even more
    meaningful. PipeRider can easily integrate into your CI process. When new commits are pushed to your PR branch,
    reports can be automatically generated to provide reviewers with more confidence in the changes made when reviewing.



  We use the example project [git-repo-analytics](https://github.com/InfuseAI/git-repo-analytics) to demonstrate how to
  use piperider+dbt+duckdb to analyze [dbt-core](https://github.com/dbt-labs/dbt-core) repository. Here is the generated
  result (daily update)

  [Run Report](https://piperider-github-readme.s3.ap-northeast-1.amazonaws.com/single-run-report/index.html)

  [Comparison Report](https://piperider-github-readme.s3.ap-northeast-1.amazonaws.com/comparison-report/index.html)

  [Comparison Summary in a PR](https://github.com/InfuseAI/git-repo-analytics/pull/19)



  [PipeRider Cloud](http://cloud.piperider.io/) allows you to upload reports and share them with your team members. For
  information on pricing plans, please refer to the [pricing page](https://www.piperider.io/#pricing).



  PipeRider provides the [PipeRider Compare Action](https://github.com/marketplace/actions/piperider-compare-action) to
  quickly integrate into your Github Actions workflow. It has the following features:

  - Automatically generates a report comparing the PR branch to the main branch
  - Uploads the report to GitHub artifacts or PipeRider cloud
  - Adds a comment to the pull request with a comparison summary and a link to the report.

  You can refer to
  example [workflow yaml](https://github.com/InfuseAI/jaffle_shop/blob/main/.github/workflows/pr-compare.yml) and
  the [example pull request](https://github.com/InfuseAI/jaffle_shop/pull/19).



  See [setup dev environment](DEVELOP.md) and the [contributing guildlines](CONTRIBUTING.md) to get started.

  **We love chatting with our users! [Let us know](mailto:product@infuseai.io) if you have any questions, feedback, or
  need help trying out PipeRider! :heart:**


pkgId: b2565e676c1ce744c3b711b48c7f3ec56343c724169e31c0e37060fa1f36b918
name: python-pipez-help
arch: noarch
version: 0.0.130
epoch: 0
release: 1
summary: Development documents and examples for pipez
url: https://github.com/tam2511/pipez
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pipez-0.0.130-1.src.rpm
location_href: Packages/python-pipez-help-0.0.130-1.noarch.rpm
checksum_type: sha256
description:
  For installing default version of library use

  ```
  pip install pipez
  ```

  If you want install specific version pipez - use

  ```
  pip install pipez[<your choice>]
  ```

  Now available `cv`, `fastapi` and `onnxruntime` versions.
  If you want install pypez with all depencies, you can use

  ```
  pip install pipez[all]
  ```

  If you want to install a few version - see nex example:

  ```
  pip install pipez[cv, onnxruntime]
  ```






  If you want use your node - you can use `Registry.add` as class decorator
  from `pipez.registry`. You should also import base `Node`
  class from `pipez.node`. For example:

  ```python
  from pipez.core.legacy_node import Node
  from pipez.core.legacy_registry import Registry

  Registry.add


  class MyNode(Node):
      ...
  ```

  Once required method which you should override: `work_func(...)` which
  handle `Batch` from `pipez.batch`. However, methods
  `post_init(...)` and `close(...)` also available. See next example:

  ```python
  from typing import Optional

  from pipez.core.legacy_batch import Batch, BatchStatus
  from pipez.core.legacy_node import Node
  from pipez.core.legacy_registry import Registry

  Registry.add


  class MyNode(Node):
      def __init__(
              self,
              a: int = 1,
              **kwargs
      ):
          super().__init__(**kwargs)
          self._a = a

      def post_init(self):
          self._a *= 10

      def close(self):
          self._a = 0

      def work_func(
              self,
              data: Optional[Batch] = None
      ) -> Batch:
          self._a *= 2
          if self._a > 1000:
              return Batch(status=BatchStatus.END)
          return Batch(data=[dict(a=self._a)])
  ```



  When you defined all nodes what you need, we build pipeline from them.
  You can use json describe or class for node. See next examples:

  For using json describing you must add `Registry.add` as class decorator
  for you node, else you will get error.
  ```python
  {
      "cls": "MyNode",
      "a": 5,
      "type": "Process",
      "output": "some_trash"
  }
  ```

  For using class you must import your node class.

  ```python
  from pipez.core.legacy_node import NodeType

  from ... import MyNode

  MyNode(
      a=5,
      type=NodeType.PROCESS,
      output='some_trash'
  )
  ```

  As we can see, we used `NodeType`, which define type of node.

  For building pipeline, we must use `build_pipeline` from `pipez.build`.
  For example:

  ```python
  from pipez.core.legacy_build import build_pipeline
  from pipez.nodes import DummyNode
  from pipez.core.legacy_node import NodeType
  from ... import MyNode

  watchdog = build_pipeline(
      pipeline=[
          MyNode(
              a=10,
              type=NodeType.THREAD,
              output='q1'
          ),
          DummyNode(
              type=NodeType.PROCESS,
              input='q1',
              output='q2'
          ),
          DummyNode(
              type=NodeType.THREAD,
              input=['q1, q2'],
              output='q3'
          ),
          {
              "cls": "DummyNode",
              "type": "thread",
              "input": "q3"
          }
      ]
  )
  ```

  As we can see, `build_pipeline` return `watchdog`.
  You can read about it in next section.




  TODO



  - Alexander, https://github.com/tam2511
  - Vitaly, https://github.com/purple63


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

  **The Python release cycle in your terminal!**

  [![Package Version](https://img.shields.io/pypi/v/pirel.svg)](https://pypi.org/project/pirel/)
  [![Python Version](https://img.shields.io/pypi/pyversions/pirel.svg)](https://pypi.org/project/pirel/)
  [![License](https://img.shields.io/github/license/RafaelWO/unparallel)](https://github.com/RafaelWO/unparallel/blob/main/LICENSE)

  </div>


  ![cli-example][cli-example]



  It is recommended to install Pirel as a globally available CLI tool via `pipx` (or `uv tool`, etc.).
  This way you Pirel will show you the status of your active Python interpreter.

  ```
  pipx install pirel
  ```

  You can also install Pirel into a specific virtual environment.

  ```
  pip install pirel
  ```





  ```
  Usage: pirel check [OPTIONS]

  Shows release information about your active Python interpreter.
  If no active Python interpreter is found, the program exits with code 2.

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────╮
  │ --verbose  -v      INTEGER  Enable verbose logging; can be supplied multiple times to increase         │
  │                             verbosity.                                                                 │
  │                             [default: 0]                                                               │
  │ --help                      Show this message and exit.                                                │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```



  ```
  Usage: pirel list [OPTIONS]

  Lists all Python releases in a table. Your active Python interpreter is highlighted.

  ╭─ Options ──────────────────────────────────────────────────────────────────────────────────────────────╮
  │ --verbose  -v      INTEGER  Enable verbose logging; can be supplied multiple times to increase         │
  │                             verbosity.                                                                 │
  │                             [default: 0]                                                               │
  │ --help                      Show this message and exit.                                                │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────────────╯

  ```

  > [!NOTE] FOO
  > You can still invoke `pirel` without a subcommand and you will get a table of all Python releases.
  > But note that this is **deprecated**, i.e. please use `pirel list`.




  To generate the video demo on the top, I used [vhs](https://github.com/charmbracelet/vhs).

  If you change something in the "tape" file `./assets/cli_demo.tape` do the following to
  update the GIF.

  1. `cd assets`
  2. `vhs cli_demo.tape`



  PRs are welcome! 🤗

  This project uses [uv](https://github.com/astral-sh/uv) to manage packaging.
  Please check the [corresponding docs](https://docs.astral.sh/uv/) for installation instructions.

  Before you commit any changes, please ensure that you have [pre-commit](https://pre-commit.com)
  available on your system. Run `pre-commit install` to install the project's hooks.


  <!-- Links -->
  [cli-example]: https://raw.githubusercontent.com/RafaelWO/pirel/refs/heads/main/assets/images/cli_demo.gif

rpm_license:
  The MIT License (MIT) Copyright (c) 2024 RafaelWO  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: 4b2a03e779661b2c6a1ad9206efebd5e39b742ed79318df5e528397e103d043b
name: python-piscola-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for piscola
url: https://github.com/temuller/piscola
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-piscola-3.0.0-1.src.rpm
location_href: Packages/python-piscola-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
  **Supernova light-curve fitting code in python**

  Although the main purpose of PISCOLA is to fit type Ia supernovae, it can be used to fit other types of supernovae or even other transients.

  [![repo](https://img.shields.io/badge/GitHub-temuller%2Fpiscola-blue.svg?style=flat)](https://github.com/temuller/piscola)
  [![documentation status](https://readthedocs.org/projects/piscola/badge/?version=latest&style=flat)](https://piscola.readthedocs.io/en/latest/?badge=latest)
  [![license](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://github.com/temuller/piscola/blob/master/LICENSE)
  [![Build and Tests](https://github.com/temuller/piscola/actions/workflows/main.yml/badge.svg)](https://github.com/temuller/piscola/actions/workflows/main.yml)
  [![Coverage](https://raw.githubusercontent.com/temuller/piscola/master/coverage.svg)](https://raw.githubusercontent.com/temuller/piscola/master/coverage.svg)
  ![Python Version](https://img.shields.io/badge/Python-3.10%2B-blue)
  [![PyPI](https://img.shields.io/pypi/v/piscola?label=PyPI&logo=pypi&logoColor=white)](https://pypi.org/project/piscola/)
  [![ADS -  2022MNRAS.512.3266M ](https://img.shields.io/badge/ADS-_2022MNRAS.512.3266M_-2ea44f)](https://ui.adsabs.harvard.edu/abs/2022MNRAS.512.3266M/abstract)

  Read the full documentation at: [piscola.readthedocs.io](http://piscola.readthedocs.io/). See below for a summary. Check [https://github.com/temuller/piscola_templates](https://github.com/temuller/piscola_templates) for spectral templates of different types of supernovae.

  ___


  PISCOLA can be installed in the usual way, via pip:

  ```
  pip install piscola
  ```

  or from source:

  ```
  git clone https://github.com/temuller/piscola.git
  cd piscola
  pip install .
  ```

  If you are using a Mac with M1 or M2 chip and you encounter `RuntimeError: This version of jaxlib was built using AVX instructions, which your CPU and/or operating system do not support. You may be able work around this issue by building jaxlib from source.`, try installing `jax` from anaconda (as suggested [here](https://stackoverflow.com/questions/68327863/importing-jax-fails-on-mac-with-m1-chip)):

  ```
  pip uninstall jax jaxlib
  conda install -c conda-forge jaxlib
  conda install -c conda-forge jax
  ```



  The requirements can be found in the `requirements.txt` file.



  To run the tests, go to the parent directory and run the following command:

  ```
  pytest -v
  ```



  PISCOLA can fit the supernova light curves and correct them in a few lines of code:


  ```python
  sn = piscola.call_sn(<sn_file>)
  sn.fit()
  ```

  The light-curve parameters are saved in a dictionary and can be accessed directly:

  ```python
  sn.lc_parameters  # dictionary
  ```

  You can find an example of input file in the [data](https://github.com/temuller/piscola/tree/master/data) directory.



  If you make use of PISCOLA in your projects, please cite [Müller-Bravo et al. (2022)](https://ui.adsabs.harvard.edu/abs/2022MNRAS.512.3266M/abstract). See below for the bibtex format:

  ```code
  @ARTICLE{2022MNRAS.512.3266M,
         author = {{M{\"u}ller-Bravo}, Tom{\'a}s E. and {Sullivan}, Mark and {Smith}, Mathew and {Frohmaier}, Chris and {Guti{\'e}rrez}, Claudia P. and {Wiseman}, Philip and {Zontou}, Zoe},
          title = "{PISCOLA: a data-driven transient light-curve fitter}",
        journal = {\mnras},
       keywords = {supernovae: general, cosmology: observations, distance scale, Astrophysics - High Energy Astrophysical Phenomena, Astrophysics - Cosmology and Nongalactic Astrophysics, Astrophysics - Instrumentation and Methods for Astrophysics, Astrophysics - Solar and Stellar Astrophysics},
           year = 2022,
          month = may,
         volume = {512},
         number = {3},
          pages = {3266-3283},
            doi = {10.1093/mnras/stab3065},
  archivePrefix = {arXiv},
         eprint = {2110.11340},
   primaryClass = {astro-ph.HE},
         adsurl = {https://ui.adsabs.harvard.edu/abs/2022MNRAS.512.3266M},
        adsnote = {Provided by the SAO/NASA Astrophysics Data System}
  }
  ```



  The recommended way is to use the [issues](https://github.com/temuller/piscola/issues) page or send a pull request. Otherwise, you can contact me directly.


pkgId: 1357557d3c99f6616235ef8296195adf961b871eeebaa3d10db1b8e2eac65e64
name: python-piva-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for piva
url: https://github.com/pudeIko/piva.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-piva-2.2.0-1.src.rpm
location_href: Packages/python-piva-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  PIVA is a graphical user interface (GUI) application built with `PyQt5` and
  `pyqtgraph` toolkits, designed for the interactive and intuitive examination
  of large image-like datasets. While it can display any multidimensional data,
  most of its functionalities are specifically tailored for users conducting
  Angle-Resolved Photoemission Spectroscopy (ARPES) experiments.

  ![](./docs/img/showcase.gif)

  A variety of standard methods and image processing algorithms (such as
  momentum-space conversion, energy distribution curve symmetrization, and
  derivative analysis) are available directly from the GUI. Additionally,
  several utilities are particularly useful during the experimental phase when
  decisions about subsequent steps need to be made quickly. These utilities
  include automated methods for locating the highest symmetry points, azimuthal
  rotation, and autogenerated experimental notebooks. These features are
  implemented for various beamlines at different synchrotron sources around the
  world.




  The installation of PIVA has been tested on macOS, Windows and Linux.

  The easiest way to install the package is to use `pip`. Just type the following
  on a command line:

      pip install piva

  or directly from this repo:

      pip install git+https://github.com/pudeIko/piva.git




  More details on the installation and full description of the package can be
  found on the [documentation](https://piva.readthedocs.io/en/latest/) site.


pkgId: 60b6b81dcc810ef2b3dfba30b11e1c9eaab9e6a9951a938ca1eb1dd7fdf932c6
name: python-pix2text-help
arch: noarch
version: 1.1.2.3
epoch: 0
release: 1
summary: Development documents and examples for pix2text
url: https://github.com/breezedeus/pix2text
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pix2text-1.1.2.3-1.src.rpm
location_href: Packages/python-pix2text-help-1.1.2.3-1.noarch.rpm
checksum_type: sha256
description:
  Official code base: [https://github.com/breezedeus/pix2text](https://github.com/breezedeus/pix2text). Please cite it properly.
  For more information on Pix2Text (P2T), visit: [https://www.breezedeus.com/article/pix2text](https://www.breezedeus.com/article/pix2text).


pkgId: d32b413909555ea4ce6b656bc9b22713a7fe69480f240661a31f45e70e2df7e1
name: python-pixelpalette-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for pixelpalette
url: https://github.com/imparth7/pixelpalette
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pixelpalette-1.0.0-1.src.rpm
location_href: Packages/python-pixelpalette-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python package to extract dominant colors from an image and display them in RGB, Hex, and HSL formats.



  Install the package using pip:

  ```bash
  pip install pixelpalette
  ```



  ```py
  from pixelpalette import extract_colors

  image_path = "you_image_path"
  colors = extract_colors(image_path, n_colors=10)

  for i, color in enumerate(colors):
      print(f"Color {i+1}:")
      print(f"  RGB: {color['RGB']}")
      print(f"  Hex: {color['Hex']}")
      print(f"  HSL: {color['HSL']}")
  ```



  ```bash
  Color 1:
    RGB: rgb(255, 200, 100)
    Hex: #ffc864
    HSL: hsl(30, 100%, 70%)
  ...
  ```


  - numpy
  - matplotlib
  - scikit-learn


pkgId: 67dfd0b6201b406f18dee15040f252104039d0cadd5fcf11bc0665201484cfaf
name: python-pkg-platzi-final-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for pkg-platzi-final
url: https://github.com/Odelgadoo/pkg_platzi_final
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pkg-platzi-final-0.4.0-1.src.rpm
location_href: Packages/python-pkg-platzi-final-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  ﻿# Paquete Platzi Final curso: Fundamentos de Programación y Python

  Este paquete implementa un ejemplo de un sistema básico de gestión de reservas en Python.


  Para instalar la librería, usa el siguiente comando:

  pip install pkg-platzi-final==0.4.0



  Para usarlo, crea un archivo `.py` y copia el siguiente script:

  ```python
  import asyncio
  from pkg_platzi_final.main import main
  asyncio.run(main())
  ```


  Luego de instalar la librería y ejecutar el código de ejemplo, el resultado esperado debería ser:
  ```
  La habitación número 101 ha sido agregada!
  La habitación número 102 ha sido agregada!
  El cliente Alice ha sido adicionado!
  El cliente Juan ha sido adicionado!
  La habitación 101 está disponible!
  Reserva creada para Alice en la habitación 101
  Procesando el pago del cliente Alice por valor de $100
  Pago completado para el cliente Alice por valor de $100
  La habitación 101 ahora NO está disponible!
  La habitación 102 está disponible!
  Reserva creada para Juan en la habitación 102
  Procesando el pago del cliente Juan por valor de $200
  Pago completado para el cliente Juan por valor de $200
  La habitación 102 ahora NO está disponible!
  Reserva 2 cancelada
  La habitación 102 ahora está disponible!
  Reserva no encontrada!!!
  ```


pkgId: 50cf9fb19f43fe6c032328a9fb75a5e37711322c5b7dec7d09d7bf82a7053693
name: python-plain-help
arch: noarch
version: 0.13.1
epoch: 0
release: 1
summary: Development documents and examples for plain
url: https://pypi.org/project/plain/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plain-0.13.1-1.src.rpm
location_href: Packages/python-plain-help-0.13.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- This file is compiled from plain/plain/README.md. Do not edit this file directly. -->



  Plain is a web framework for building products with Python.

  With the core `plain` package you can build an app that:

  - Matches [URL patterns](https://plainframework.com/docs/plain/plain/urls) to Python [views](https://plainframework.com/docs/plain/plain/views)
  - Handles [HTTP requests and responses](https://plainframework.com/docs/plain/plain/http)
  - Renders [HTML templates](https://plainframework.com/docs/plain/plain/templates) with Jinja
  - Processes user input via [forms](https://plainframework.com/docs/plain/plain/forms)
  - Has a [CLI interface](https://plainframework.com/docs/plain/plain/cli)
  - Serves static [assets](https://plainframework.com/docs/plain/plain/assets) (CSS, JS, images)
  - Can be modified with [middleware](https://plainframework.com/docs/plain/plain/middleware)
  - Integrates first-party and third-party [packages](https://plainframework.com/docs/plain/plain/packages)
  - Has a [preflight check system](https://plainframework.com/docs/plain/plain/preflight)

  With the official Plain ecosystem packages you can:

  - Integrate a full-featured [database ORM](https://plainframework.com/docs/plain-models/)
  - Use a built-in [user authentication](https://plainframework.com/docs/plain-auth/) system
  - [Lint and format code](https://plainframework.com/docs/plain-code/)
  - Run a [database-backed cache](https://plainframework.com/docs/plain-cache/)
  - [Send emails](https://plainframework.com/docs/plain-mail/)
  - Streamline [local development](https://plainframework.com/docs/plain-dev/)
  - Manage [feature flags](https://plainframework.com/docs/plain-flags/)
  - Integrate [HTMX](https://plainframework.com/docs/plain-htmx/)
  - Style with [Tailwind CSS](https://plainframework.com/docs/plain-tailwind/)
  - Add [OAuth login](https://plainframework.com/docs/plain-oauth/) and API access
  - Run tests with [pytest](https://plainframework.com/docs/plain-test/)
  - Run a [background job worker](https://plainframework.com/docs/plain-worker/)
  - Build [staff tooling and admin dashboards](https://plainframework.com/docs/plain-staff/)

  Learn more at [plainframework.com](https://plainframework.com).


pkgId: 99360dfbfa0e69d46907812c0f5fe0cffa1238a8f3635b50fba21946e22624f1
name: python-plain.dev-help
arch: noarch
version: 0.14.1
epoch: 0
release: 1
summary: Development documents and examples for plain.dev
url: https://plainframework.com
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plain.dev-0.14.1-1.src.rpm
location_href: Packages/python-plain.dev-help-0.14.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- This file is compiled from plain-dev/plain/dev/README.md. Do not edit this file directly. -->



  A single command that runs everything you need for local development.

  ![Plain dev command example](https://github.com/dropseed/plain/assets/649496/3643bb64-a99b-4a8e-adab-8c6b81791ea9)

  The `plain.dev` package can be [installed from PyPI](https://pypi.org/project/plain.dev/), and does *not* need to be added to `INSTALLED_PACKAGES`.

  - [`plain dev`](#plain-dev)
  - [`plain dev services`](#plain-dev-services)
  - [`plain pre-commit`](#plain-pre-commit)
  - [`plain contrib`](#plain-contrib)
  - [VS Code debugging](#vscode-debugging)



  The `plain dev` command does several things:

  - Sets `PLAIN_CSRF_TRUSTED_ORIGINS` to localhost by default
  - Runs `plain preflight` to check for any issues
  - Executes any pending model migrations
  - Starts `gunicorn` with `--reload`
  - Runs `plain tailwind compile --watch`, if `plain.tailwind` is installed
  - Any custom process defined in `pyproject.toml` at `tool.plain.dev.run`
  - Necessary services (ex. Postgres) defined in `pyproject.toml` at `tool.plain.dev.services`



  Use services to define databases or other processes that your app *needs* to be functional. The services will be started automatically in `plain dev`, but also in `plain pre-commit` (so preflight and tests have a database).

  Ultimately, how you run your development database is up to you. But a recommended starting point is to use Docker:

  ```toml

  [tool.plain.dev.services]
  postgres = {cmd = "docker run --name app-postgres --rm -p 54321:5432 -v $(pwd)/.plain/dev/pgdata:/var/lib/postgresql/data -e POSTGRES_PASSWORD=postgres postgres:15 postgres"}
  ```



  Unlike [services](#services), custom processes are *only* run during `plain dev`. This is a good place to run something like [ngrok](https://ngrok.com/) or a [Plain worker](../../../plain-worker), which you might need to use your local site, but don't need running for executing tests, for example.

  ```toml

  [tool.plain.dev.run]
  ngrok = {command = "ngrok http $PORT"}
  ```



  Starts your [services](#services) by themselves.



  A built-in pre-commit hook that can be installed with `plain pre-commit --install`.

  Runs:

  - Custom commands defined in `pyproject.toml` at `tool.plain.pre-commit.run`
  - `plain code check`, if [`plain.code`](https://plainframework.com/docs/plain-code/plain/code/) is installed
  - `poetry check --lock`, if using [Poetry](https://python-poetry.org/)
  - `plain preflight --database default`
  - `plain migrate --check`
  - `plain makemigrations --dry-run --check`
  - `plain compile`
  - `plain test`



  ![Debug Plain with VS Code](https://github.com/dropseed/plain-public/assets/649496/250138b6-7702-4ab6-bf38-e0c8e3c56d06)

  Since `plain dev` runs multiple processes at once, the regular [pdb](https://docs.python.org/3/library/pdb.html) debuggers don't quite work.

  Instead, we include [microsoft/debugpy](https://github.com/microsoft/debugpy) and an `attach` function to make it even easier to use VS Code's debugger.

  First, import and run the `debug.attach()` function:

  ```python
  class HomeView(TemplateView):
      template_name = "home.html"

      def get_template_context(self):
          context = super().get_template_context()

          
          from plain.dev import debug; debug.attach()

          
          breakpoint()

          return context
  ```

  When you load the page, you'll see "Waiting for debugger to attach...".

  You can then run the VS Code debugger and attach to an existing Python process, at localhost:5678.


pkgId: 19d67b6645f1137caa65cdf562e9077fc25a467ea54724d2fb2616eb1fd4ec2b
name: python-plain.oauth-help
arch: noarch
version: 0.7.4
epoch: 0
release: 1
summary: Development documents and examples for plain.oauth
url: https://plainframework.com
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plain.oauth-0.7.4-1.src.rpm
location_href: Packages/python-plain.oauth-help-0.7.4-1.noarch.rpm
checksum_type: sha256
description:
  <!-- This file is compiled from plain-oauth/plain/oauth/README.md. Do not edit this file directly. -->

  <!-- This file is compiled from plain-oauth/plain/oauth/README.md. Do not edit this file directly. -->



  Let users log in with OAuth providers.

  [Watch on YouTube (3 mins) →](https://www.youtube.com/watch?v=UxbxBa6AFsU)

  This library is intentionally minimal.
  It has no dependencies and a single database model.
  If you simply want users to log in with GitHub, Google, Twitter, etc. (and maybe use that access token for API calls),
  then this is the library for you.

  There are three OAuth flows that it makes possible:

  1. Signup via OAuth (new user, new OAuth connection)
  2. Login via OAuth (existing user, existing OAuth connection)
  3. Connect/disconnect OAuth accounts to a user (existing user, new OAuth connection)




  Install the package from PyPi:

  ```sh
  pip install plain-oauth
  ```

  Add `plain.oauth` to your `INSTALLED_PACKAGES` in `settings.py`:

  ```python
  INSTALLED_PACKAGES = [
      ...
      "plain.oauth",
  ]
  ```

  In your `urls.py`, include `plain.oauth.urls`:

  ```python
  urlpatterns = [
      path("oauth/", include("plain.oauth.urls")),
      ...
  ]
  ```

  Then run migrations:

  ```sh
  python manage.py migrate plain.oauth
  ```

  Create a new OAuth provider ([or copy one from our examples](https://github.com/forgepackages/plain-oauth/tree/master/provider_examples)):

  ```python

  import requests

  from plain.oauth.providers import OAuthProvider, OAuthToken, OAuthUser


  class ExampleOAuthProvider(OAuthProvider):
      authorization_url = "https://example.com/login/oauth/authorize"

      def get_oauth_token(self, *, code, request):
          response = requests.post(
              "https://example.com/login/oauth/token",
              headers={
                  "Accept": "application/json",
              },
              data={
                  "client_id": self.get_client_id(),
                  "client_secret": self.get_client_secret(),
                  "code": code,
              },
          )
          response.raise_for_status()
          data = response.json()
          return OAuthToken(
              access_token=data["access_token"],
          )

      def get_oauth_user(self, *, oauth_token):
          response = requests.get(
              "https://example.com/api/user",
              headers={
                  "Accept": "application/json",
                  "Authorization": f"token {oauth_token.access_token}",
              },
          )
          response.raise_for_status()
          data = response.json()
          return OAuthUser(
              
              id=data["id"],
              
              email=data["email"],
              username=data["username"],
          )
  ```

  Create your OAuth app/consumer on the provider's site (GitHub, Google, etc.).
  When setting it up, you'll likely need to give it a callback URL.
  In development this can be `http://localhost:8000/oauth/github/callback/` (if you name it `"github"` like in the example below).
  At the end you should get some sort of "client id" and "client secret" which you can then use in your `settings.py`:

  ```python
  OAUTH_LOGIN_PROVIDERS = {
      "github": {
          "class": "yourapp.oauth.GitHubOAuthProvider",
          "kwargs": {
              "client_id": environ["GITHUB_CLIENT_ID"],
              "client_secret": environ["GITHUB_CLIENT_SECRET"],
              

              
              
              
              
          },
      },
  }
  ```

  Then add a login button (which is a form using POST rather than a basic link, for security purposes):

  ```html
  <h1>Login</h1>
  <form action="{% url 'oauth:login' 'github' %}" method="post">
      {{ csrf_input }}
      <button type="submit">Login with GitHub</button>
  </form>
  ```

  Depending on your URL and provider names,
  your OAuth callback will be something like `https://example.com/oauth/{provider}/callback/`.

  That's pretty much it!





  The most common error you'll run into is if an existing user clicks a login button,
  but they haven't yet connected that provider to their account.
  For security reasons,
  the required flow here is that the user actually logs in with another method (however they signed up) and then *connects* the OAuth provider from a settings page.

  For this error (and a couple others),
  there is an error template that is rendered.
  You can customize this by copying `oauth/error.html` to one of your own template directories:

  ```html
  {% extends "base.html" %}

  {% block content %}
  <h1>OAuth Error</h1>
  <p>{{ oauth_error }}</p>
  {% endblock %}
  ```

  ![Django OAuth duplicate email address error](https://user-images.githubusercontent.com/649496/159065848-b4ee6e63-9aa0-47b5-94e8-7bee9b509e60.png)



  To connect and disconnect OAuth accounts,
  you can add a series of forms to a user/profile settings page.
  Here's an very basic example:

  ```html
  {% extends "base.html" %}

  {% block content %}
  Hello {{ request.user }}!

  <h2>Existing connections</h2>
  <ul>
      {% for connection in request.user.oauth_connections.all %}
      <li>
          {{ connection.provider_key }} [ID: {{ connection.provider_user_id }}]
          <form action="{% url 'oauth:disconnect' connection.provider_key %}" method="post">
              {{ csrf_input }}
              <input type="hidden" name="provider_user_id" value="{{ connection.provider_user_id }}">
              <button type="submit">Disconnect</button>
          </form>
      </li>
      {% endfor %}
  </ul>

  <h2>Add a connection</h2>
  <ul>
      {% for provider_key in oauth_provider_keys %}
      <li>
          {{ provider_key}}
          <form action="{% url 'oauth:connect' provider_key %}" method="post">
              {{ csrf_input }}
              <button type="submit">Connect</button>
          </form>
      </li>
      {% endfor %}
  </ul>

  {% endblock %}
  ```

  The `get_provider_keys` function can help populate the list of options:

  ```python
  from plain.oauth.providers import get_provider_keys

  class ExampleView(TemplateView):
      template_name = "index.html"

      def get_context(self, **kwargs):
          context = super().get_context(**kwargs)
          context["oauth_provider_keys"] = get_provider_keys()
          return context
  ```

  ![Connecting and disconnecting Django OAuth accounts](https://user-images.githubusercontent.com/649496/159065096-30239a1f-62f6-4ee2-a944-45140f45af6f.png)



  ```python
  import requests


  connection = user.oauth_connections.get(provider_key="github")


  if connection.access_token_expired():
      connection.refresh_access_token()


  token = connection.access_token
  response = requests.get(...)
  ```



  This library comes with a Django system check to ensure you don't *remove* a provider from `settings.py` that is still in use in your database.
  You do need to specify the `--database` for this to run when using the check command by itself:

  ```sh
  python manage.py check --database default
  ```





  The short answer is that *it does less*.

  In [django-allauth](https://github.com/pennersr/django-allauth)
  (maybe the most popular alternative)
  you get all kinds of other features like managing multiple email addresses,
  email verification,
  a long list of supported providers,
  and a whole suite of forms/urls/views/templates/signals/tags.
  And in my experience,
  it's too much.
  It often adds more complexity to your app than you actually need (or want) and honestly it can just be a lot to wrap your head around.
  Personally, I don't like the way that your OAuth settings are stored in the database vs when you use `settings.py`,
  and the implications for doing it one way or another.

  The other popular OAuth libraries have similar issues,
  and I think their *weight* outweighs their usefulness for 80% of the use cases.



  One thing you'll notice is that we don't have a long list of pre-configured providers in this library.
  Instead, we have some examples (which you can usually just copy, paste, and use) and otherwise encourage you to wire up the provider yourself.
  Often times all this means is finding the two OAuth URLs ("oauth/authorize" and "oauth/token") in their docs,
  and writing two class methods that do the actual work of getting the user's data (which is often customized anyway).

  We've written examples for the following providers:

  - [GitHub](https://github.com/forgepackages/plain-oauth/tree/master/provider_examples/github.py)
  - [GitLab](https://github.com/forgepackages/plain-oauth/tree/master/provider_examples/gitlab.py)
  - [Bitbucket](https://github.com/forgepackages/plain-oauth/tree/master/provider_examples/bitbucket.py)

  Just copy that code and paste it in your project.
  Tweak as necessary!

  This might sound strange at first.
  But in the long run we think it's actually *much* more maintainable for both us (as library authors) and you (as app author).
  If something breaks with a provider, you can fix it immediately!
  You don't need to try to run changes through us or wait for an upstream update.
  You're welcome to contribute an example to this repo,
  and there won't be an expectation that it "works perfectly for every use case until the end of time".



  If you're doing local development through a proxy/tunnel like [ngrok](https://ngrok.com/),
  then the callback URL might be automatically built as `http` instead of `https`.

  This is the Django setting you're probably looking for:

  ```python
  HTTPS_PROXY_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
  ```


pkgId: d5595c6335e30b545fd0e436b527e46a704702791eda68fe5923e0a1324a15ec
name: python-plain.tunnel-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for plain.tunnel
url: https://plainframework.com
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plain.tunnel-0.2.1-1.src.rpm
location_href: Packages/python-plain.tunnel-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  <!-- This file is compiled from plain-pytest/plain/pytest/README.md. Do not edit this file directly. -->



  Write and run tests with pytest.

  Django includes its own test runner and [unittest](https://docs.python.org/3/library/unittest.html#module-unittest) classes.
  But a lot of people (myself included) prefer [pytest](https://docs.pytest.org/en/latest/contents.html).

  In Plain I've removed the Django test runner and a lot of the implications that come with it.
  There are a few utilities that remain to make testing easier,
  and `plain-test` is a wrapper around `pytest`.


pkgId: 856d4f69cb54fe0c71a3ccf142162765c3d0c428446f27971d176873fd546ecc
name: python-planet-help
arch: noarch
version: 2.13.1
epoch: 0
release: 1
summary: Development documents and examples for planet
url: https://pypi.org/project/planet/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-planet-2.13.1-1.src.rpm
location_href: Packages/python-planet-help-2.13.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/planetlabs/planet-client-python/actions/workflows/test.yml/badge.svg)](https://github.com/planetlabs/planet-client-python/actions/workflows/test.yml)

  The [Planet](https://planet.com) Software Development Kit (SDK) for Python
  provides both a Python API and a command-line interface (CLI)
  to make use of [the Planet APIs](https://developers.planet.com/docs/apis/).
  Everything you need to get started is found in our
  [online documentation](https://planet-sdk-for-python-v2.readthedocs.io/en/latest/).

  Version 2.0 includes support for the core workflows of the following APIs:

  * [Data](https://developers.planet.com/docs/data/) - Search for imagery from Planet's data catalog.
  * [Orders](https://developers.planet.com/docs/orders/) - Process and download or deliver imagery.
  * [Subscriptions](https://developers.planet.com/docs/subscriptions/) - Set up a search to auto-process and deliver imagery.

  After the initial 2.0 release there will be additional work to support the
  remaining Planet APIs: [basemaps](https://developers.planet.com/docs/basemaps/),
  [tasking](https://developers.planet.com/docs/tasking/) and
  [analytics](https://developers.planet.com/docs/analytics/).



  The SDK follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html) and therefore only major releases should break compatibility. Minor versions may include new functionality and patch versions address bugs or trivial changes (like documentation).

  If depending upon official packages from PyPI, a developer should feel comfortable specifying `planet == 2.*` unless depending on a specific feature introduced at a minor version, in which case `planet == 2.x.*` (where x is the minor version of the new feature) should suffice.

  The default branch is always `main` and should be considered in-development but with tests and other build steps succeeding.



  The Planet SDK for Python is [hosted on PyPI](https://pypi.org/project/planet/) and can simply be installed via:

  ```console
  pip install planet
  ```

  To install from source, first clone this repository, then navigate to the root directory (where `setup.py` lives) and run:

  ```console
  pip install .
  ```

  Note that the above commands will install the Planet SDK into the global system Python unless a virtual environment is enabled.  For more information on configuring a virtual environment from system Python, see the official Python [venv](https://docs.python.org/3/library/venv.html) documentation.  For users who are running multiple versions of Python via [pyenv](https://github.com/pyenv/pyenv), see the [pyenv-virtualenv](https://github.com/pyenv/pyenv-virtualenv) extension documentation.

  Detailed installation instructions for the Planet SDK can be found in the [Quick Start Guide](https://planet-sdk-for-python-v2.readthedocs.io/en/latest/get-started/quick-start-guide/) of the documentation.



  To contribute or develop with this library, see [CONTRIBUTING.md](CONTRIBUTING.md).



  Documentation is currently [hosted online](https://planet-sdk-for-python-v2.readthedocs.io/en/latest/)
  It should be considered 'in progress', with many updates to come. It can also
  be built and hosted locally (see [CONTRIBUTING.md](CONTRIBUTING.md)) or can be
  read from source in the [docs](/docs) directory.



  Planet's APIs require an account for use. To get started you need to
  [Get a Planet Account](https://planet-sdk-for-python-v2.readthedocs.io/en/latest/get-started/get-your-planet-account/).

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


pkgId: fef966e546ccca30a44212aabb6cae5e52b7769b1161337c7b476553446edcb2
name: python-planky-help
arch: noarch
version: 0.1
epoch: 0
release: 1
summary: Development documents and examples for planky
url: https://github.com/BonePolk/Planky
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-planky-0.1-1.src.rpm
location_href: Packages/python-planky-help-0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![icon.png](https://raw.githubusercontent.com/BonePolk/Planky/refs/heads/master/icon.png)

  <details>
  <summary>🇬🇧 English</summary>



  **Planky** is an easy-to-use and highly customizable tool for building your own **tcp/tls** server.


  ```commandline
  pip install Planky
  ```



  ```python
  from Planky.events.messageEvent import MessageEvent
  from Planky.messages.parsedMessage import ParsedMessage
  from Planky.plankyData import PlankyData
  from Planky.plankyServer import PlankyServer

  server = PlankyServer("127.0.0.1", port=1111)

  @server.on_message(ParsedMessage)
  async def parsed_message(handler, event: MessageEvent):
      if event.message.content == b"hello":
          await handler.send_data(PlankyData(payload=b"world"))
      else:
          await handler.send_data(PlankyData(payload=event.message.content))

  if __name__ == "__main__":
      server.mainloop()
  ```



  - Simple usage
  - TLS support
  - Server side certificate validation support
  - Custom parsers support
  - Async support



  - [ReadTheDocs](https://planky.readthedocs.io/en/stable/)



  Nobody...

  </details>

  <details>
  <summary>🇷🇺 Русский</summary>


  **Planky** — это простой и гибкий инструмент для создания собственного асинхронного **tcp/tls** сервера.


  ```commandline
  pip install Planky
  ```



  ```python
  from Planky.events.messageEvent import MessageEvent
  from Planky.messages.parsedMessage import ParsedMessage
  from Planky.plankyData import PlankyData
  from Planky.plankyServer import PlankyServer

  server = PlankyServer("127.0.0.1", port=1111)

  @server.on_message(ParsedMessage)
  async def parsed_message(handler, event: MessageEvent):
      if event.message.content == b"hello":
          await handler.send_data(PlankyData(payload=b"world"))
      else:
          await handler.send_data(PlankyData(payload=event.message.content))

  if __name__ == "__main__":
      server.mainloop()
  ```



  - Простое использование
  - Поддержка tls
  - Поддержка проверки сертификата на сервере
  - Поддержка кастомных парсеров
  - Поддержка асинхронности



  - [ReadTheDocs](https://planky.readthedocs.io/en/stable/)



  Пока нету

  </details>


pkgId: 744221113beb93cd77586f77bcbcf54885c58a33751b7a18947fc1509e1721f0
name: python-plantcv-help
arch: noarch
version: 4.6
epoch: 0
release: 1
summary: Development documents and examples for plantcv
url: https://plantcv.org
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plantcv-4.6-1.src.rpm
location_href: Packages/python-plantcv-help-4.6-1.noarch.rpm
checksum_type: sha256
description:
  ![builds](https://github.com/danforthcenter/plantcv/workflows/builds/badge.svg)
  [![DeepSource](https://app.deepsource.com/gh/danforthcenter/plantcv.svg/?label=code+coverage&show_trend=true&token=og8rSyKxywOCGkIk8UNiF7B_)](https://app.deepsource.com/gh/danforthcenter/plantcv/)
  [![DeepSource](https://app.deepsource.com/gh/danforthcenter/plantcv.svg/?label=active+issues&show_trend=true&token=og8rSyKxywOCGkIk8UNiF7B_)](https://app.deepsource.com/gh/danforthcenter/plantcv/)
  [![Documentation Status](https://readthedocs.org/projects/plantcv/badge/?version=stable)](https://plantcv.readthedocs.io/en/stable/?badge=stable)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/danforthcenter/plantcv-binder.git/master?filepath=index.ipynb)
  [![Docker Pulls](https://img.shields.io/docker/pulls/danforthcenter/plantcv.svg)](https://hub.docker.com/r/danforthcenter/plantcv/)
  [![GitHub release](https://img.shields.io/github/release/danforthcenter/plantcv.svg)](https://github.com/danforthcenter/plantcv/releases)
  [![PyPI version](https://badge.fury.io/py/plantcv.svg)](https://badge.fury.io/py/plantcv)
  ![Conda](https://img.shields.io/conda/v/conda-forge/plantcv)
  [![license](https://img.shields.io/github/license/danforthcenter/plantcv.svg)](https://github.com/danforthcenter/plantcv/blob/main/LICENSE)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](docs/CODE_OF_CONDUCT.md)
  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-60-orange.svg?style=flat-square)](#contributors-)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->



  Please use, cite, and [contribute to](http://plantcv.readthedocs.io/en/latest/CONTRIBUTING/) PlantCV!
  If you have questions, please submit them via the
  [GitHub issues page](https://github.com/danforthcenter/plantcv/issues).
  Follow us on twitter [@plantcv](https://twitter.com/plantcv).

  ***



  PlantCV is an open-source image analysis software package targeted for plant phenotyping. PlantCV provides a common
  programming and documentation interface to a collection of image analysis techniques that are integrated from a variety
  of source packages and algorithms. PlantCV utilizes a modular architecture that enables flexibility in the design of
  analysis workflows and rapid assimilation and integration of new methods. For more information about the project,
  links to recorded presentations, and publications using PlantCV, please visit our homepage:
  <https://plantcv.danforthcenter.org/>.



  * [Documentation](http://plantcv.readthedocs.io/)
  * [Interactive Documentation](https://mybinder.org/v2/gh/danforthcenter/plantcv-binder.git/master?filepath=index.ipynb)
  * [Installation Instructions](https://plantcv.readthedocs.io/en/stable/installation/)
  * [Updating/Changelog](https://plantcv.readthedocs.io/en/stable/updating/)
  * [Public Image Datasets](http://plantcv.danforthcenter.org/pages/data.html)
  * [Contribution Guide](https://plantcv.readthedocs.io/en/stable/CONTRIBUTING/)
  * [Code of Conduct](https://plantcv.readthedocs.io/en/stable/CODE_OF_CONDUCT/)
  * Downloads
    * [GitHub](https://github.com/danforthcenter/plantcv)
    * [PyPI](https://pypi.org/project/plantcv/)
    * [Conda-forge](https://anaconda.org/conda-forge/plantcv)
    * [Docker](https://hub.docker.com/r/danforthcenter/plantcv)
    * [Zenodo](https://doi.org/10.5281/zenodo.595522)



  If you use PlantCV, please cite the [PlantCV publications](https://plantcv.danforthcenter.org/#plantcv-publications)
  relevant to your work. To see how others have used PlantCV in their research, check out our list of
  [publications using PlantCV](https://plantcv.danforthcenter.org/#publications-using-plantcv).

  ***



  Please file any PlantCV suggestions/issues/bugs via our
  [GitHub issues page](https://github.com/danforthcenter/plantcv/issues). Please check to see if any related
  issues have already been filed.

  ***



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/AFis-245"><img src="https://avatars.githubusercontent.com/u/145135602?v=4?s=100" width="100px;" alt="AFis-245"/><br /><sub><b>AFis-245</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=AFis-245" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.adonline.id.au/"><img src="https://avatars.githubusercontent.com/u/5926320?v=4?s=100" width="100px;" alt="Adam Dimech"/><br /><sub><b>Adam Dimech</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=AdamDimech" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=AdamDimech" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=AdamDimech" title="Tests">⚠️</a> <a href="#ideas-AdamDimech" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://alexanderkutschera.com/"><img src="https://avatars.githubusercontent.com/u/20026476?v=4?s=100" width="100px;" alt="Alexander Kutschera"/><br /><sub><b>Alexander Kutschera</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=vektorious" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=vektorious" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=vektorious" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aapokor"><img src="https://avatars.githubusercontent.com/u/39534960?v=4?s=100" width="100px;" alt="Alexandria Pokorny"/><br /><sub><b>Alexandria Pokorny</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=aapokor" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=aapokor" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=aapokor" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/AzlinII"><img src="https://avatars.githubusercontent.com/u/15007726?v=4?s=100" width="100px;" alt="Andy Lin"/><br /><sub><b>Andy Lin</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=AzlinII" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://calizarr.github.io/resume"><img src="https://avatars.githubusercontent.com/u/3262069?v=4?s=100" width="100px;" alt="Cesar Lizarraga"/><br /><sub><b>Cesar Lizarraga</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=calizarr" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=calizarr" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=calizarr" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cluebbert"><img src="https://avatars.githubusercontent.com/u/47461392?v=4?s=100" width="100px;" alt="Collin Luebbert"/><br /><sub><b>Collin Luebbert</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=cluebbert" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://www.linkedin.com/in/david-peery-344882126/"><img src="https://avatars.githubusercontent.com/u/63679152?v=4?s=100" width="100px;" alt="David Peery"/><br /><sub><b>David Peery</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=jdavidpeery" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jdavidpeery" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jdavidpeery" title="Tests">⚠️</a> <a href="#ideas-jdavidpeery" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dhiraj-ms"><img src="https://avatars.githubusercontent.com/u/39856917?v=4?s=100" width="100px;" alt="Dhiraj Srivastava"/><br /><sub><b>Dhiraj Srivastava</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=dhiraj-ms" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=dhiraj-ms" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=dhiraj-ms" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://data-folks.masto.host/@dschneiderch"><img src="https://avatars.githubusercontent.com/u/7461221?v=4?s=100" width="100px;" alt="Dominik Schneider"/><br /><sub><b>Dominik Schneider</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=dschneiderch" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=dschneiderch" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=dschneiderch" title="Tests">⚠️</a> <a href="#ideas-dschneiderch" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://rayngrowingsystems.com/"><img src="https://avatars.githubusercontent.com/u/129968640?v=4?s=100" width="100px;" alt="Dr. Alexander Kutschera"/><br /><sub><b>Dr. Alexander Kutschera</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=rayn-alex" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/issues?q=author%3Arayn-alex" title="Bug reports">🐛</a> <a href="#question-rayn-alex" title="Answering Questions">💬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/emmanuel-ferdman"><img src="https://avatars.githubusercontent.com/u/35470921?v=4?s=100" width="100px;" alt="Emmanuel Ferdman"/><br /><sub><b>Emmanuel Ferdman</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/issues?q=author%3Aemmanuel-ferdman" title="Bug reports">🐛</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=emmanuel-ferdman" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ic"><img src="https://avatars.githubusercontent.com/u/64160?v=4?s=100" width="100px;" alt="Eric Platon"/><br /><sub><b>Eric Platon</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=ic" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=ic" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=ic" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.datamaplab.com"><img src="https://avatars.githubusercontent.com/u/2442821?v=4?s=100" width="100px;" alt="Fabian Dubois"/><br /><sub><b>Fabian Dubois</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=fabid" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://fabiobarbero.eu"><img src="https://avatars.githubusercontent.com/u/20724986?v=4?s=100" width="100px;" alt="Fabio Barbero"/><br /><sub><b>Fabio Barbero</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=fbarbe00" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ygarrot"><img src="https://avatars.githubusercontent.com/u/33935239?v=4?s=100" width="100px;" alt="Garrot Yoan"/><br /><sub><b>Garrot Yoan</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=ygarrot" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/GrantKonkel"><img src="https://avatars.githubusercontent.com/u/78433847?v=4?s=100" width="100px;" alt="GrantKonkel"/><br /><sub><b>GrantKonkel</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=GrantKonkel" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=GrantKonkel" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/HaleySchuhl"><img src="https://avatars.githubusercontent.com/u/44006936?v=4?s=100" width="100px;" alt="Haley Schuhl"/><br /><sub><b>Haley Schuhl</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=HaleySchuhl" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=HaleySchuhl" title="Documentation">📖</a> <a href="#maintenance-HaleySchuhl" title="Maintenance">🚧</a> <a href="#tutorial-HaleySchuhl" title="Tutorials">✅</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=HaleySchuhl" title="Tests">⚠️</a> <a href="#talk-HaleySchuhl" title="Talks">📢</a> <a href="#ideas-HaleySchuhl" title="Ideas, Planning, & Feedback">🤔</a> <a href="#question-HaleySchuhl" title="Answering Questions">💬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hkmanching"><img src="https://avatars.githubusercontent.com/u/8751385?v=4?s=100" width="100px;" alt="Heather Manching"/><br /><sub><b>Heather Manching</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/issues?q=author%3Ahkmanching" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/DannieSheng"><img src="https://avatars.githubusercontent.com/u/28633120?v=4?s=100" width="100px;" alt="Hudanyun Sheng"/><br /><sub><b>Hudanyun Sheng</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=DannieSheng" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=DannieSheng" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=DannieSheng" title="Tests">⚠️</a> <a href="#ideas-DannieSheng" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://jakejasper.xyz"><img src="https://avatars.githubusercontent.com/u/35571955?v=4?s=100" width="100px;" alt="Jake"/><br /><sub><b>Jake</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=Jake-Jasper" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=Jake-Jasper" title="Documentation">📖</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jberry47"><img src="https://avatars.githubusercontent.com/u/20114985?v=4?s=100" width="100px;" alt="Jeffrey Berry"/><br /><sub><b>Jeffrey Berry</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=jberry47" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jberry47" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jberry47" title="Tests">⚠️</a> <a href="#ideas-jberry47" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JoeDuenwald"><img src="https://avatars.githubusercontent.com/u/101900627?v=4?s=100" width="100px;" alt="JoeDuenwald"/><br /><sub><b>JoeDuenwald</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=JoeDuenwald" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://sites.google.com/view/jorge-gutierrezor/home"><img src="https://avatars.githubusercontent.com/u/26798565?v=4?s=100" width="100px;" alt="Jorge Gutierrez"/><br /><sub><b>Jorge Gutierrez</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=JorgeGtz" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=JorgeGtz" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=JorgeGtz" title="Tests">⚠️</a> <a href="#talk-JorgeGtz" title="Talks">📢</a> <a href="#ideas-JorgeGtz" title="Ideas, Planning, & Feedback">🤔</a> <a href="#question-JorgeGtz" title="Answering Questions">💬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/joshqsumner"><img src="https://avatars.githubusercontent.com/u/51797700?v=4?s=100" width="100px;" alt="Josh Sumner"/><br /><sub><b>Josh Sumner</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=joshqsumner" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=joshqsumner" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=joshqsumner" title="Tests">⚠️</a> <a href="#tutorial-joshqsumner" title="Tutorials">✅</a> <a href="#ideas-joshqsumner" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kaitlynrying"><img src="https://avatars.githubusercontent.com/u/156353832?v=4?s=100" width="100px;" alt="Kaitlyn Ying"/><br /><sub><b>Kaitlyn Ying</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=kaitlynrying" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.danforthcenter.org/our-work/core-facilities/phenotyping/"><img src="https://avatars.githubusercontent.com/u/58490237?v=4?s=100" width="100px;" alt="Katie Murphy"/><br /><sub><b>Katie Murphy</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=kmurphy61" title="Documentation">📖</a> <a href="#tutorial-kmurphy61" title="Tutorials">✅</a> <a href="#talk-kmurphy61" title="Talks">📢</a> <a href="#ideas-kmurphy61" title="Ideas, Planning, & Feedback">🤔</a> <a href="#promotion-kmurphy61" title="Promotion">📣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/k034b363"><img src="https://avatars.githubusercontent.com/u/156026125?v=4?s=100" width="100px;" alt="KeelyBrown"/><br /><sub><b>KeelyBrown</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=k034b363" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://gehan-lab.org"><img src="https://avatars.githubusercontent.com/u/6978303?v=4?s=100" width="100px;" alt="Malia Gehan"/><br /><sub><b>Malia Gehan</b></sub></a><br /><a href="#projectManagement-maliagehan" title="Project Management">📆</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=maliagehan" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=maliagehan" title="Documentation">📖</a> <a href="#fundingFinding-maliagehan" title="Funding Finding">🔍</a> <a href="#mentoring-maliagehan" title="Mentoring">🧑‍🏫</a> <a href="#talk-maliagehan" title="Talks">📢</a> <a href="#tutorial-maliagehan" title="Tutorials">✅</a> <a href="#ideas-maliagehan" title="Ideas, Planning, & Feedback">🤔</a> <a href="#question-maliagehan" title="Answering Questions">💬</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=maliagehan" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/maldil"><img src="https://avatars.githubusercontent.com/u/20140049?v=4?s=100" width="100px;" alt="Malinda"/><br /><sub><b>Malinda</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=maldil" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/afinit"><img src="https://avatars.githubusercontent.com/u/6353304?v=4?s=100" width="100px;" alt="Mark Wilson"/><br /><sub><b>Mark Wilson</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=afinit" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=afinit" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=afinit" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mlohbihler"><img src="https://avatars.githubusercontent.com/u/1182059?v=4?s=100" width="100px;" alt="Matthew Lohbihler"/><br /><sub><b>Matthew Lohbihler</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/issues?q=author%3Amlohbihler" title="Bug reports">🐛</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=mlohbihler" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/maxjfeldman"><img src="https://avatars.githubusercontent.com/u/6977566?v=4?s=100" width="100px;" alt="Max"/><br /><sub><b>Max</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=maxjfeldman" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=maxjfeldman" title="Documentation">📖</a> <a href="#ideas-maxjfeldman" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://danforthcenter.org"><img src="https://avatars.githubusercontent.com/u/6233508?v=4?s=100" width="100px;" alt="Noah Fahlgren"/><br /><sub><b>Noah Fahlgren</b></sub></a><br /><a href="#projectManagement-nfahlgren" title="Project Management">📆</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=nfahlgren" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=nfahlgren" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=nfahlgren" title="Tests">⚠️</a> <a href="#fundingFinding-nfahlgren" title="Funding Finding">🔍</a> <a href="#mentoring-nfahlgren" title="Mentoring">🧑‍🏫</a> <a href="#talk-nfahlgren" title="Talks">📢</a> <a href="#tutorial-nfahlgren" title="Tutorials">✅</a> <a href="#ideas-nfahlgren" title="Ideas, Planning, & Feedback">🤔</a> <a href="#question-nfahlgren" title="Answering Questions">💬</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Sanazjd"><img src="https://avatars.githubusercontent.com/u/40071989?v=4?s=100" width="100px;" alt="Sanazjd"/><br /><sub><b>Sanazjd</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=Sanazjd" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=Sanazjd" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=Sanazjd" title="Tests">⚠️</a> <a href="#ideas-Sanazjd" title="Ideas, Planning, & Feedback">🤔</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/SethPolydore"><img src="https://avatars.githubusercontent.com/u/65034463?v=4?s=100" width="100px;" alt="SethPolydore"/><br /><sub><b>SethPolydore</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=SethPolydore" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=SethPolydore" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=SethPolydore" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://orcid.org/0000-0002-1338-8900"><img src="https://avatars.githubusercontent.com/u/2046665?v=4?s=100" width="100px;" alt="Steen Hoyer"/><br /><sub><b>Steen Hoyer</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=jshoyer" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jshoyer" title="Documentation">📖</a> <a href="#ideas-jshoyer" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/stiphyMT"><img src="https://avatars.githubusercontent.com/u/15986230?v=4?s=100" width="100px;" alt="Stephan Summerer"/><br /><sub><b>Stephan Summerer</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=stiphyMT" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/stevenhwu"><img src="https://avatars.githubusercontent.com/u/1005078?v=4?s=100" width="100px;" alt="Steven Wu"/><br /><sub><b>Steven Wu</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=stevenhwu" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Stylopidae1793"><img src="https://avatars.githubusercontent.com/u/128506162?v=4?s=100" width="100px;" alt="Stylopidae1793"/><br /><sub><b>Stylopidae1793</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=Stylopidae1793" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://tj-schultz.github.io/"><img src="https://avatars.githubusercontent.com/u/73593696?v=4?s=100" width="100px;" alt="TJ Schultz"/><br /><sub><b>TJ Schultz</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=tj-schultz" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/issues?q=author%3Atj-schultz" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/adrianethompson"><img src="https://avatars.githubusercontent.com/u/85243018?v=4?s=100" width="100px;" alt="adrianethompson"/><br /><sub><b>adrianethompson</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=adrianethompson" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=adrianethompson" title="Documentation">📖</a> <a href="#tutorial-adrianethompson" title="Tutorials">✅</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/annacasto"><img src="https://avatars.githubusercontent.com/u/61164490?v=4?s=100" width="100px;" alt="annacasto"/><br /><sub><b>annacasto</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=annacasto" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=annacasto" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=annacasto" title="Tests">⚠️</a> <a href="#tutorial-annacasto" title="Tutorials">✅</a> <a href="#talk-annacasto" title="Talks">📢</a> <a href="#ideas-annacasto" title="Ideas, Planning, & Feedback">🤔</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bganglia"><img src="https://avatars.githubusercontent.com/u/48276939?v=4?s=100" width="100px;" alt="bganglia"/><br /><sub><b>bganglia</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=bganglia" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=bganglia" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=bganglia" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ghernandez-57"><img src="https://avatars.githubusercontent.com/u/170016226?v=4?s=100" width="100px;" alt="ghernandez-57"/><br /><sub><b>ghernandez-57</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=ghernandez-57" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=ghernandez-57" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jbraley1107"><img src="https://avatars.githubusercontent.com/u/186077704?v=4?s=100" width="100px;" alt="jbraley1107"/><br /><sub><b>jbraley1107</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/pulls?q=is%3Apr+reviewed-by%3Ajbraley1107" title="Reviewed Pull Requests">👀</a> <a href="#userTesting-jbraley1107" title="User Testing">📓</a> <a href="https://github.com/danforthcenter/plantcv/issues?q=author%3Ajbraley1107" title="Bug reports">🐛</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jgerardhodge"><img src="https://avatars.githubusercontent.com/u/11335765?v=4?s=100" width="100px;" alt="jgerardhodge"/><br /><sub><b>jgerardhodge</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=jgerardhodge" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jgerardhodge" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jgerardhodge" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jmgordon1223"><img src="https://avatars.githubusercontent.com/u/128613726?v=4?s=100" width="100px;" alt="jmgordon1223"/><br /><sub><b>jmgordon1223</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=jmgordon1223" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jwheeler5"><img src="https://avatars.githubusercontent.com/u/86489506?v=4?s=100" width="100px;" alt="jwheeler5"/><br /><sub><b>jwheeler5</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=jwheeler5" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jwheeler5" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=jwheeler5" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kbgilbert"><img src="https://avatars.githubusercontent.com/u/13541110?v=4?s=100" width="100px;" alt="kbgilbert"/><br /><sub><b>kbgilbert</b></sub></a><br /><a href="#design-kbgilbert" title="Design">🎨</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lacostag"><img src="https://avatars.githubusercontent.com/u/72940710?v=4?s=100" width="100px;" alt="lacostag"/><br /><sub><b>lacostag</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=lacostag" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lchavez037"><img src="https://avatars.githubusercontent.com/u/18586794?v=4?s=100" width="100px;" alt="lchavez037"/><br /><sub><b>lchavez037</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=lchavez037" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/leowlima"><img src="https://avatars.githubusercontent.com/u/123584304?v=4?s=100" width="100px;" alt="leowlima"/><br /><sub><b>leowlima</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=leowlima" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mtwatso2-eng"><img src="https://avatars.githubusercontent.com/u/55025422?v=4?s=100" width="100px;" alt="mtwatso2-eng"/><br /><sub><b>mtwatso2-eng</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=mtwatso2-eng" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/natejly"><img src="https://avatars.githubusercontent.com/u/141955513?v=4?s=100" width="100px;" alt="natejly"/><br /><sub><b>natejly</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=natejly" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/scallen81"><img src="https://avatars.githubusercontent.com/u/21960021?v=4?s=100" width="100px;" alt="scallen81"/><br /><sub><b>scallen81</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=scallen81" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/sdkenney42"><img src="https://avatars.githubusercontent.com/u/128510721?v=4?s=100" width="100px;" alt="sdkenney42"/><br /><sub><b>sdkenney42</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=sdkenney42" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/typelogic"><img src="https://avatars.githubusercontent.com/u/45341970?v=4?s=100" width="100px;" alt="typelogic"/><br /><sub><b>typelogic</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=typelogic" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/wurDevTim"><img src="https://avatars.githubusercontent.com/u/81219429?v=4?s=100" width="100px;" alt="wurDevTim"/><br /><sub><b>wurDevTim</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=wurDevTim" title="Code">💻</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=wurDevTim" title="Documentation">📖</a> <a href="https://github.com/danforthcenter/plantcv/commits?author=wurDevTim" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/zeeuqsze"><img src="https://avatars.githubusercontent.com/u/107494588?v=4?s=100" width="100px;" alt="zeeuqsze"/><br /><sub><b>zeeuqsze</b></sub></a><br /><a href="https://github.com/danforthcenter/plantcv/commits?author=zeeuqsze" title="Documentation">📖</a> <a href="#tutorial-zeeuqsze" title="Tutorials">✅</a> <a href="#talk-zeeuqsze" title="Talks">📢</a> <a href="#mentoring-zeeuqsze" title="Mentoring">🧑‍🏫</a></td>
      </tr>
    </tbody>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->

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


pkgId: 693d0f10e603cff0297d1a34adc3ee1d94d1642f28f0bdd9a1da73f34bcb048f
name: python-platzky-redirections-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for platzky-redirections
url: https://pypi.org/project/platzky-redirections/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-platzky-redirections-0.1.0-1.src.rpm
location_href: Packages/python-platzky-redirections-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Platzky Redirections is a plugin for the Platzky framework that allows you to set up URL redirections easily. This can be useful for maintaining SEO, handling outdated URLs, or simply redirecting traffic from one part of your site to another.



  To install Platzky Redirections, you can use pip:

  ```sh
  pip install platzky-redirections
  ```



  ```json
  "plugins": [
  {
    "name": "redirections",
    "config": {
      "/old-path": "/new-path"
    }
  }
  ]
  ```


pkgId: 2603b994703cb9640423a137c6cca8f94dbe610743ed21eef102227686a9c86d
name: python-playa-pdf-help
arch: noarch
version: 0.2.5
epoch: 0
release: 1
summary: Development documents and examples for playa-pdf
url: https://dhdaines.github.io/playa
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-playa-pdf-0.2.5-1.src.rpm
location_href: Packages/python-playa-pdf-help-0.2.5-1.noarch.rpm
checksum_type: sha256
description:
  There are already too many PDF libraries, unfortunately none of which
  does everything that everybody wants it to do, and we probably don't
  need another one. It is not recommended that you use this library for
  anything at all, but if you were going to use it for something, it
  would be specifically one of these things and nothing else:

  1. Accessing the document catalog, page tree, structure tree, content
     streams, cross-reference table, XObjects, and other low-level PDF
     metadata.
  2. Obtaining the absolute position and attributes of every character,
     line, path, and image in every page of a PDF.

  If you just want to extract text from a PDF, there are a lot of better
  and faster tools and libraries out there, see [these
  benchmarks](https://github.com/py-pdf/benchmarks) for a summary (TL;DR
  pypdfium2 is probably what you want, but pdfplumber does a nice job of
  converting PDF to ASCII art).

  The purpose of PLAYA is to provide an efficent, pure-Python and
  Pythonic (for its author's definition of the term), lazy interface to
  the internals of PDF files.



  Installing it should be really simple as long as you have Python 3.8
  or newer:

      pipx install playa-pdf

  Yes it's not just "playa".  Sorry about that.



  Do you want to get stuff out of a PDF?  You have come to the right
  place!  Let's open up a PDF and see what's in it:

  ```python
  pdf = playa.open("my_awesome_document.pdf")
  raw_byte_stream = pdf.buffer
  a_bunch_of_tokens = list(pdf.tokens)
  a_bunch_of_indirect_objects = list(pdf)
  ```

  The raw PDF tokens and objects are probably not terribly useful to
  you, but you might find them interesting.  Note that these are
  "indirect objects" where the actual object is accompanied by an object
  number and generation number:

  ```python
  for objid, genno, obj in pdf:
      ...

  for obj in pdf:
      obj.objid, obj.genno, obj.obj
  ```

  Also, these will only be the top-level objects and not those found
  inside object streams (the streams are themselves indirect objects).
  You can iterate over all indirect objects including object streams
  using the `objects` property:

  ```python
  for obj in pdf.objects:
      obj.objid, obj.genno, obj.obj
  ```

  In this case it is possible you will encounter multiple objects with
  the same `objid` due to the "incremental updates" feature of PDF.
  Currently, iterating over the objects in a particular stream is
  possible, but complicated.  It may be simplified in PLAYA 0.3.

  You can also access indirect objects by number (this will return the
  object with most recent generation number):

  ```python
  a_particular_object = pdf[42]
  ```

  Your PDF document probably has some pages.  How many?  What are their
  numbers/labels?  (they could be things like "xviii", 'a", or "42", for
  instance)

  ```python
  npages = len(pdf.pages)
  page_numbers = [page.label for page in pdf.pages]
  ```

  What's in the table of contents?  (NOTE: this API will likely change
  in PLAYA 0.3 as it is not Lazy nor does it properly represent the
  hierarchy of the document outline)

  ```python
  for entry in pdf.outlines:
      level, title, dest, action, struct_element = entry
      
      entry.level, entry.title, entry.dest, entry.action, entry.se
      ...
  ```

  If you are lucky it has a "logical structure tree".  The elements here
  might even be referenced from the table of contents!  (or, they might
  not... with PDF you never know).  (NOTE: this API will definitely
  change in PLAYA 0.3 as it is not the least bit Lazy)

  ```python
  structure = pdf.structtree
  for element in structure:
     for child in element:
         ...
  ```

  Now perhaps we want to look at a specific page.  Okay!  You can also
  look at its contents, more on that in a bit:

  ```python
  page = pdf.pages[0]        # they are numbered from 0
  page = pdf.pages["xviii"]  # but you can get them by label (a string)
  page = pdf.pages["42"]     # or "logical" page number (also a string)
  print(f"Page {page.label} is {page.width} x {page.height}")
  ```



  What are these "contents" of which you speak, which were surely
  created by a Content Creator?  Well, you can look at the stream of
  tokens or mysterious PDF objects:

  ```python
  for token in page.tokens:
      ...
  for object in page.contents:
      ...
  ```

  But that isn't very useful, so you can also access actual textual and
  graphical objects (if you wanted to, for instance, do layout
  analysis).

  ```python
  for item in page:
      ...
  ```

  Because it is quite inefficient to expand, calculate, and copy every
  possible piece of information, PLAYA gives you some options here.
  Wherever possible this information can be computed lazily, but this
  involves some more work on the user's part.



  If, on the other hand, **you** are lazy, then you can just use
  `page.layout`, which will flatten everything for you into a friendly
  dictionary representation (but it is a
  [`TypedDict`](https://typing.readthedocs.io/en/latest/spec/typeddict.html#typeddict))
  which, um, looks a lot like what `pdfplumber` gives you, except possibly in
  a different
  coordinate space, as defined [below](#an-important-note-about-coordinate-spaces).

  ```python
  for dic in page.layout:
      print("it is a {dic['object_type']} at ({dic['x0']}", {dic['y0']}))
      print("    the color is {dic['stroking_color']}")
      print("    the text is {dic['text']}")
      print("    it is in MCS {dic['mcid']} which is a {dic['tag']}")
      print("    it is also in Form XObject {dic['xobjid']}")
  ```

  This is for instance quite useful for doing "Artificial Intelligence",
  or if you like wasting time and energy for no good reason, but I
  repeat myself.  For instance, you can write `page.layout` to a CSV file:

  ```python
  writer = DictWriter(outfh, fieldnames=playa.fieldnames)
  writer.writeheader()
  for dic in pdf.layout:
      writer.writerow(dic)
  ```

  you can also create a Pandas DataFrame:

  ```python
  df = pandas.DataFrame.from_records(pdf.layout)
  ```

  or a Polars DataFrame or LazyFrame:

  ```python
  df = polars.DataFrame(pdf.layout, schema=playa.schema)
  ```

  If you have more specific needs or want better performance, then read on.



  Wait, what is this "absolute position" of which you speak, and which
  PLAYA gives you?  It's important to understand that there is no
  definition of "device space" in the PDF standard, and I quote (PDF 1.7
  sec 8.3.2.2):

  > A particular device’s coordinate system is called its device
  space. The origin of the device space on different devices can fall in
  different places on the output page; on displays, the origin can vary
  depending on the window system. Because the paper or other output
  medium moves through different printers and imagesetters in different
  directions, the axes of their device spaces may be oriented
  differently.

  You may immediately think of CSS when you hear the phrase "absolute
  position" and this is exactly what PLAYA gives you as its default
  device space, specifically:

  - Units are default user space units (1/72 of an inch).
  - `(0, 0)` is the top-left corner of the page, as defined by its
    `MediaBox` after rotation is applied.
  - Coordinates increase from the top-left corner of the page towards
    the bottom-right corner.

  However, for compatibility with `pdfminer.six`, you can also pass
  `space="page"` to `playa.open`.  In this case, `(0, 0)` is the
  bottom-left corner of the page as defined by the `MediaBox`, after
  rotation, and coordinates increase from the bottom-left corner of the
  page towards the top-right, as they do in PDF user space.

  If you don't care about absolute positioning, you can use
  `space="default"`, which may be somewhat faster in the future (currently
  it isn't).  In this case, no translation or rotation of the default
  user space is done (in other words any values of `MediaBox` or
  `Rotate` in the page dictionary are simply ignored).  This is **definitely**
  what you want if you wish to take advantage of the coordinates that
  you may find in `outlines`, `dests`, tags and logical structure
  elements.



  Fundamentally you may just want to know *what* is *where* on the page,
  and PLAYA has you covered there (note that the bbox is normalized, and
  in the aforementioned interpretation of "device space"):

  ```python
  for obj in page:
      print(f"{obj.object_type} at {obj.bbox}")
      left, top, right, bottom = obj.bbox
      print(f"  top left is {left, top}")
      print(f"  bottom right is {right, botom}")
  ```

  Another important piece of information (which `pdfminer.six` does not
  really handle) is the relationship between layout and logical
  structure, done using *marked content sections*:

  ```python
  for obj in page:
      print(f"{obj.object_type} is in marked content section {obj.mcs.mcid}")
      print(f"    which is tag {obj.mcs.tag.name}")
      print(f"    with properties {obj.mcs.tag.props}")
  ```

  The `mcid` here is the same one referenced in elements of the
  structure tree as shown above (but remember that `tag` has nothing to
  do with the structure tree element, because Reasons).  A marked
  content section does not necessarily have a `mcid` or `props`, but it
  will *always* have a `tag`.

  PDF also has the concept of "marked content points". PLAYA suports
  these with objects of `object_type == "tag"`.  The tag name and
  properties are also accessible via the `mcs` attribute.



  A PDF page may also contain "Form XObjects" which are like tiny
  embedded PDF documents (they have nothing to do with fillable forms).
  The lazy API (because it is lazy) **will not expand these for you**
  which may be a source of surprise.  You can identify them because they
  have `object_type == "xobject"`.  The layout objects inside them are
  accessible by iteration, as with pages (but **not** documents):

  ```python
  for obj in page:
      if obj.object_type == "xobject":
          for item in obj:
              ...
  ```

  You can also iterate over them in the page context with `page.xobjects`:

  ```python
  for xobj in page.xobjects:
      for item in xobj:
          ...
  ```

  Exceptionally, these have a few more features than the ordinary
  `ContentObject` - you can look at their raw stream contents as well as
  the tokens, and you can also see raw, mysterious PDF objects with
  `contents`.



  You may also wish to know what color an object is, and other aspects of
  what PDF refers to as the *graphics state*, which is accessible
  through `obj.gstate`.  This is a mutable object, and since there are
  quite a few parameters in the graphics state, PLAYA does not create a
  copy of it for every object in the layout - you are responsible for
  saving them yourself if you should so desire.  This is not
  particularly onerous, because the parameters themselves are immutable:

  ```python
  for obj in page:
      print(f"{obj.object_type} at {obj.bbox} is:")
      print(f"    {obj.gstate.scolor} stroking color")
      print(f"    {obj.gstate.ncolor} non-stroking color")
      print(f"    {obj.gstate.dash} dashing style")
      my_stuff = (obj.dash, obj.gstate.scolor, obj.gstate.ncolor)
      other_stuff.append(my_stuff)  # it's safe there
  ```

  For compatbility with `pdfminer.six`, PLAYA, even though it is not a
  layout analyzer, can do some basic interpretation of paths.  Again,
  this is lazy.  If you don't care about them, you just get objects with
  `object_type` of `"path"`, which you can ignore.  PLAYA won't even
  compute the bounding box (which isn't all that slow, but still).  If
  you *do* care, then you have some options.  You can look at the actual
  path segments in user space (fast):

  ```python
  for seg in path.raw_segments:
     print(f"segment: {seg}")
  ```

  Or in PLAYA's "device space" (not so fast):

  ```python
  for seg in path.segments:
     print(f"segment: {seg}")
  ```

  This API doesn't try to interpret paths for you.  You only get
  `PathSegment`s.  But for convenience you can get them grouped by
  subpaths as created using the `m` or `re` operators:

  ```python
  for subpath in path:
     for seg in subpath.segments:
         print(f"segment: {seg}")
  ```



  Since most PDFs consist primarily of text, obviously you may wish to
  know something about the actual text (or the `ActualText`, which you
  can sometimes find in `obj.mcs.tag.props["ActualText"]`).  This is
  more difficult than it looks, as fundamentally PDF just positions
  arbitrarily numbered glyphs on a page, and the vast majority of PDFs
  embed their own fonts, using *subsetting* to include only the glyphs
  actually used.

  Whereas `pdfminer.six` would break down text objects into their
  individual glyphs (which might or might not correspond to characters),
  this is not always what you want, and moreover it is computationally
  quite expensive.  So PLAYA, by default, does not do this.  If you
  don't need to know the actual bounding box of a text object, then
  don't access `obj.bbox` and it won't be computed.  If you don't need
  to know the position of each glyph but simply want the Unicode
  characters, then just look at `obj.chars`.

  It is important to understand that `obj.chars` may or may not correspond
  to the actual text that a human will read on the page.  To
  actually extract *text* from a PDF necessarily involves Heuristics
  or Machine Learning (yes, capitalized, like that) and PLAYA does not do
  either of those things.

  This is because PDFs, especially ones produced by OCR, don't organize
  text objects in any meaningful fashion, so you will want to actually
  look at the glyphs.  This becomes a matter of iterating over the item,
  giving you, well, more items, which are the individual glyphs:

  ```python
  for glyph in item:
      print("Glyph has CID {glyph.cid} and Unicode {glyph.text}")
  ```

  By default PLAYA, following the PDF specification, considers the
  grouping of glyphs into strings irrelevant by default.  I *might*
  consider separating the strings in the future.

  PDF has the concept of a *text state* which determines some aspects of
  how text is rendered.  You can obviously access this though
  `glyph.textstate` - note that the text state, like the graphics state,
  is mutable, so you will have to copy it or save individual parameters
  that you might care about.  This may be a major footgun so watch out.

  PLAYA doesn't guarantee that text objects come at you in anything
  other than the order they occur in the file (but it does guarantee
  that).

  In some cases might want to look at the abovementioned `ActualText`
  attribute to reliably extract text, particularly if the PDF was
  created by certain versions of LibreOffice, but in their infinite
  wisdom, Adobe made `ActualText` a property of *marked content
  sections* and not *text objects*, so you may be out of luck if you
  want to actually match these characters to glyphs.  Sorry, I don't
  write the standards.



  As mentioned earlier, if you really just want to do text extraction,
  there's always pdfplumber, pymupdf, pypdfium2, pikepdf, pypdf, borb,
  etc, etc, etc.



  This repository obviously includes code from `pdfminer.six`.  Original
  license text is included in
  [LICENSE](https://github.com/dhdaines/playa/blob/main/LICENSE).  The
  license itself has not changed!


pkgId: 531b3bf971742ac72b8ecce64a77f552445118657a16802218097d3865c63adc
name: python-player-performance-ratings-help
arch: noarch
version: 5.18.0
epoch: 0
release: 1
summary: Development documents and examples for player-performance-ratings
url: https://github.com/Hiderdk/player-performance-ratings
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-player-performance-ratings-5.18.0-1.src.rpm
location_href: Packages/python-player-performance-ratings-help-5.18.0-1.noarch.rpm
checksum_type: sha256
description:
  Framework designed to predict outcomes in sports games using player-based ratings or other forms of engineered features such as rolling means.
  Ratings can be used to predict game-winner, but also other outcomes such as total points scored, total yards gained, etc.



  ```
  pip install player-performance-ratings
  ```



  Ensure you have a dataset where each row is a unique combination of game_ids and player_ids.
  There are multiple different use-cases for the framework, such as:
  1. Creating ratings for players/teams.
  2. Predicting the outcome.
  3. Creating features or other types of data-transformations



  If you only desire to generate ratings this is quite simple:
  ```
  import pandas as pd
  from player_performance_ratings import PredictColumnNames

  from player_performance_ratings.ratings import UpdateRatingGenerator, RatingEstimatorFeatures

  from player_performance_ratings.data_structures import ColumnNames

  df = pd.read_pickle("data/game_player_subsample.pickle")


  column_names = ColumnNames(
      team_id='team_id',
      match_id='game_id',
      start_date="start_date",
      player_id="player_name",
  )

  df = df.sort_values(by=[column_names.start_date, column_names.match_id, column_names.team_id, column_names.player_id])


  df[PredictColumnNames.TARGET] = df['won']


  df = (
      df.assign(team_count=df.groupby(column_names.match_id)[column_names.team_id].transform('nunique'))
      .loc[lambda x: x.team_count == 2]
      .drop(columns=['team_count'])
  )


  most_recent_10_games = df[column_names.match_id].unique()[-10:]
  historical_df = df[~df[column_names.match_id].isin(most_recent_10_games)]
  future_df = df[df[column_names.match_id].isin(most_recent_10_games)].drop(columns=[PredictColumnNames.TARGET, 'won'])



  rating_generator = UpdateRatingGenerator(performance_column='won')


  historical_df_with_ratings = rating_generator.generate_historical(historical_df, column_names=column_names)


  team_ratings = rating_generator.team_ratings
  print(team_ratings[:10])


  future_df_with_ratings = rating_generator.generate_future(future_df)
  ```



  Ensure you have a dataset where each row is a unique combination of game_ids and player_ids.
  Even if the concept of a player doesn't exist in the dataset, you can use team_id instead of player_id.

  Utilizing a rating model can be as simple as:

  ```
  import pandas as pd
  from player_performance_ratings import PredictColumnNames

  from player_performance_ratings.pipeline import Pipeline
  from player_performance_ratings.predictor import GameTeamPredictor

  from player_performance_ratings.ratings import UpdateRatingGenerator

  from player_performance_ratings.data_structures import ColumnNames

  df = pd.read_pickle("data/game_player_subsample.pickle")


  column_names = ColumnNames(
      team_id='team_id',
      match_id='game_id',
      start_date="start_date",
      player_id="player_name",
  )

  df = df.sort_values(by=[column_names.start_date, column_names.match_id, column_names.team_id, column_names.player_id])


  df[PredictColumnNames.TARGET] = df['won']


  df = (
      df.assign(team_count=df.groupby(column_names.match_id)[column_names.team_id].transform('nunique'))
      .loc[lambda x: x.team_count == 2]
      .drop(columns=['team_count'])
  )


  most_recent_10_games = df[column_names.match_id].unique()[-10:]
  historical_df = df[~df[column_names.match_id].isin(most_recent_10_games)]
  future_df = df[df[column_names.match_id].isin(most_recent_10_games)].drop(columns=[PredictColumnNames.TARGET, 'won'])



  rating_generator = UpdateRatingGenerator(performance_column='won')




  predictor = GameTeamPredictor(
      game_id_colum=column_names.match_id,
      team_id_column=column_names.team_id,
      estimator_features=['location']
  )



  pipeline = Pipeline(
      rating_generators=rating_generator,
      predictor=predictor,
      column_names=column_names,
  )


  historical_predictions = pipeline.train_predict(df=historical_df)


  future_predictions = pipeline.future_predict(df=future_df)


  team_grouped_predictions = future_predictions.groupby(column_names.match_id).first()[
      [column_names.start_date, column_names.team_id, 'team_id_opponent', predictor.pred_column]]

  print(team_grouped_predictions)
  ```



  If the user simply wants to calculate features without directly feeding into a prediction-model, this can be done using PipelineTransformer.
  The example below calculates rolling-means and lags for kills, deaths, the result and calculates a rating based on the result.
  It then outputs the dataframe with the new features.
  ```
  import pandas as pd

  from player_performance_ratings import ColumnNames, PredictColumnNames
  from player_performance_ratings.pipeline_transformer import PipelineTransformer
  from player_performance_ratings.ratings import UpdateRatingGenerator, MatchRatingGenerator, StartRatingGenerator, \
      RatingEstimatorFeatures
  from player_performance_ratings.transformers import LagTransformer
  from player_performance_ratings.transformers.lag_generators import RollingMeanTransformerPolars

  column_names = ColumnNames(
      team_id='teamname',
      match_id='gameid',
      start_date="date",
      player_id="playername",
      league='league',
      position='position',
  )
  df = pd.read_parquet("data/subsample_lol_data")
  df = (
      df.loc[lambda x: x.position != 'team']
      .assign(team_count=df.groupby('gameid')['teamname'].transform('nunique'))
      .loc[lambda x: x.team_count == 2]
      .assign(player_count=df.groupby(['gameid', 'teamname'])['playername'].transform('nunique'))
      .loc[lambda x: x.player_count == 5]
  )
  df = (df
  .assign(team_count=df.groupby('gameid')['teamname'].transform('nunique'))
  .loc[lambda x: x.team_count == 2]
  )



  most_recent_10_games = df[column_names.match_id].unique()[-10:]
  historical_df = df[~df[column_names.match_id].isin(most_recent_10_games)]
  future_df = df[df[column_names.match_id].isin(most_recent_10_games)].drop(columns=['result'])

  rating_generator = UpdateRatingGenerator(
      estimator_features_out=[RatingEstimatorFeatures.RATING_DIFFERENCE_PROJECTED],
      performance_column='result'
  )

  lag_generators = [
      LagTransformer(
          features=["kills", "deaths", "result"],
          lag_length=3,
          granularity=['playername']
      ),
      RollingMeanTransformerPolars(
          features=["kills", "deaths", "result"],
          window=20,
          min_periods=1,
          granularity=['playername']
      )
  ]


  transformer = PipelineTransformer(
      column_names=column_names,
      rating_generators=rating_generator,
      lag_generators=lag_generators
  )

  historical_df = transformer.fit_transform(historical_df)

  future_df = transformer.transform(future_df)
  print(future_df.head())
  ```


  Tuning the parameters can often lead to higher accuracy.
  For player-performance-ratings, hyperparameter-tuning is easy to implement.
  Hyperparameter-tuning can be used for the predictor-parameters, but also for the rating-generator-parameters.
  In the example below, the optimal way to calculate the margin of victory by determining the weight of multiple columns is designed as a hyperparameter-tuning problem

  ```
  import pandas as pd

  from player_performance_ratings.pipeline import Pipeline
  from player_performance_ratings.predictor import GameTeamPredictor
  from player_performance_ratings.tuner.performances_generator_tuner import PerformancesSearchRange
  from player_performance_ratings.tuner.predictor_tuner import PredictorTuner

  from player_performance_ratings.tuner.rating_generator_tuner import UpdateRatingGeneratorTuner
  from player_performance_ratings.ratings import UpdateRatingGenerator

  from player_performance_ratings.data_structures import ColumnNames

  from player_performance_ratings.tuner import PipelineTuner, PerformancesGeneratorTuner
  from player_performance_ratings.tuner.utils import ParameterSearchRange, get_default_team_rating_search_range

  column_names = ColumnNames(
      team_id='teamname',
      match_id='gameid',
      start_date="date",
      player_id="playername",
      league='league',
      position='position',
  )
  df = pd.read_parquet("data/subsample_lol_data")
  df = df.sort_values(by=['date', 'gameid', 'teamname', "playername"])
  df['champion_position'] = df['champion'] + df['position']
  df['__target'] = df['result']

  df = df.drop_duplicates(subset=['gameid', 'teamname', 'playername'])

  df = (
      df.assign(team_count=df.groupby('gameid')['teamname'].transform('nunique'))
      .loc[lambda x: x.team_count == 2]
      .drop(columns=['team_count'])
  )
  df = df.drop_duplicates(subset=['gameid', 'teamname', 'playername'])

  rating_generator = UpdateRatingGenerator(performance_column='performance')

  predictor = GameTeamPredictor(
      game_id_colum="gameid",
      team_id_column="teamname",
  )

  pipeline = Pipeline(
      rating_generators=rating_generator,
      predictor=predictor,
      column_names=column_names
  )


  performance_generator_tuner = PerformancesGeneratorTuner(
      performances_search_range=PerformancesSearchRange(search_ranges=[
          ParameterSearchRange(
              name='damagetochampions',
              type='uniform',
              low=0,
              high=0.45
          ),
          ParameterSearchRange(
              name='deaths',
              type='uniform',
              low=0,
              high=.3,
              lower_is_better=True
          ),
          ParameterSearchRange(
              name='kills',
              type='uniform',
              low=0,
              high=0.3
          ),
          ParameterSearchRange(
              name='result',
              type='uniform',
              low=0.25,
              high=0.85
          ),
      ]),
      n_trials=3
  )

  rating_generator_tuner = UpdateRatingGeneratorTuner(
      team_rating_search_ranges=get_default_team_rating_search_range(),
      start_rating_search_ranges=start_rating_search_range,
      optimize_league_ratings=True,
      team_rating_n_trials=3
  )

  tuner = PipelineTuner(
      performances_generator_tuners=performance_generator_tuner,
      predictor_tuner=PredictorTuner(n_trials=1, search_ranges=[
          ParameterSearchRange(name='C', type='categorical', choices=[1.0, 0.5])]),
      fit_best=True,
      pipeline=pipeline,
  )
  best_match_predictor, df = tuner.tune(df=df, return_df=True, return_cross_validated_predictions=True)

  ```



  The listed examples above are quite simple.
  However, the framework is designed to be flexible and can easily be extended in order to create better models:
  Examples:

  * Create a better margin of victory bombine multiple columns to create a performance_column which ratings will be calculated based on.
  * Combine rolling-means, lags with ratings to create a more complex model.
  * Add other features such as weather, home/away, etc.
  * Predict other outcomes than game-winner, such as total points scored, total yards gained, etc.
  * Create custom transformations utilizing domain knowledge of the sport.


pkgId: 50f18d10b0877e8a51e6f508e4a28421311f89ab100910271cd3df1a0fb0a8fa
name: python-playsound3-help
arch: noarch
version: 2.5.1
epoch: 0
release: 1
summary: Development documents and examples for playsound3
url: https://pypi.org/project/playsound3/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-playsound3-2.5.1-1.src.rpm
location_href: Packages/python-playsound3-help-2.5.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPi version](https://img.shields.io/badge/dynamic/json?label=latest&query=info.version&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fplaysound3%2Fjson)](https://pypi.org/project/playsound3)
  [![PyPI license](https://img.shields.io/badge/dynamic/json?label=license&query=info.license&url=https%3A%2F%2Fpypi.org%2Fpypi%2Fplaysound3%2Fjson)](https://pypi.org/project/playsound3)

  Cross platform library to play sound files in Python.



  Install via pip:

  ```
  pip install playsound3
  ```



  Once installed, you can use the playsound function to play sound files:

  ```python
  from playsound3 import playsound

  playsound("/path/to/sound/file.mp3")


  playsound("http://url/to/sound/file.mp3")
  ```



  The `playsound3` module contains a single function named `playsound`:

  ```python
  def playsound(
          sound: str | Path,
          block: bool = True,
          backend: str | None = None,
          daemon: bool = True,
      ) -> Thread | None:
      """Play a sound file using an audio backend availabile in your system.

      Args:
          sound: Path or URL to the sound file. Can be a string or pathlib.Path.
          block: If True, the function will block execution until the sound finishes playing.
                 If False, sound will play in a background thread.
          backend: Name of the audio backend to use. Use None for automatic selection.
          daemon: If True, and `block` is True, the background thread will be a daemon thread.
                  This means that the thread will stay alive even after the main program exits.

      Returns:
          If `block` is True, the function will return None after the sound finishes playing.
          If `block` is False, the function will return the background thread object.

      """
      ...
  ```

  It requires one argument: `sound` - the path to the file with the sound you'd like to play.
  This should be a local file or a URL.
  There's an optional second argument: `block` which is set to `True` by default.
  Setting it to `False` makes the function run asynchronously.
  You can manually specify a backend by passing its name as the third argument.
  You can browse available backends by using `playsound3.AVAILABLE_BACKENDS`.
  It is recommended to use the default value of `None` to let the library choose the best backend available.



  * **Linux** using one of the below backends, whichever is available:
      * GStreamer
      * FFmpeg
      * aplay for .wav and mpg123 .mp3
  * **Windows** using winmm.dll (built-in on Windows)
  * **macOS** using afplay utility (built-in on macOS)



  This repository was originally forked from [playsound](https://github.com/TaylorSMarks/playsound) library created by Taylor Marks. The original library is unfortunately not maintained anymore and doesn't accept pull requests. This library: `playsound3` is a major rewrite of the original, including its own set of tests hosted using GitHub Actions.

  Compared to the original, `playsound3`:
  * Drops support for Python 2
  * Adheres to the latest PEP standards
  * Offers multiple backends with a fallback mechanism if the default backend is not available
  * Accepts contributions


pkgId: af066ac8b0a377f0f31404448fa0f40d535eaab5b0c2ceda03470b8092ac536c
name: python-plivo-help
arch: noarch
version: 4.58.1
epoch: 0
release: 1
summary: Development documents and examples for plivo
url: https://github.com/plivo/plivo-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plivo-4.58.1-1.src.rpm
location_href: Packages/python-plivo-help-4.58.1-1.noarch.rpm
checksum_type: sha256
description:
  The Plivo Python SDK makes it simpler to integrate communications into your
  Python applications using the Plivo REST API. Using the SDK, you will be able
  to make voice calls, send SMS and generate Plivo XML to control your call flows.

  See https://github.com/plivo/plivo-python for more information.


pkgId: 7154f7fa1f062659833ade97b2eceb5ac761a733d0e5e00684051b61a41a78b5
name: python-plm-cs-help
arch: noarch
version: 2.2
epoch: 0
release: 1
summary: Development documents and examples for plm-cs
url: https://github.com/doorpro/predict-chemical-shifts-from-protein-sequence.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plm-cs-2.2-1.src.rpm
location_href: Packages/python-plm-cs-help-2.2-1.noarch.rpm
checksum_type: sha256
description:
  learning rate|0.02|5e-4|0.002|0.01|5e-4|5e-4
  optimizer| SGD|Adam|Adam|SGD|Adam|Adam


  For convenience, the reasoning process of the ESM model is separate from the training process of our regression model. Therefore, we first use ESM-650M to process the data. In [esm_process.py](./esm_process.py) we provide a transformation function for the esm model, you need to provide three parameters：*protein sequence*, *chemical shifts*, *mask*. The sequence representing the protein, the sequence specifying the chemical shift of the atom, and the mask sequence (if any of the tags for a particular sequence are missing). These three sequences should be of equal length. The function outputs four processed data, you need to concat multiple sequences of data in the batch size dimension and save them as the tensordataset in this manner.
  ```python
  dataset = TensorDataset(all_esm_vec, all_label, all_mask, all_padding_mask)
  ```
  The final dimension of each parameter should be:
  *n&#215;512&#215;1280*, *n&#215;512&#215;1*, *n&#215;512&#215;1*, *n&#215;512&#215;1*. *n* refers to the number of sequences.

  Modify the path in the [train.py](./train.py) to your own path. Also, be aware that this can only train a model of one type of atom at a time.


  ```python
  pip install plm-cs
  ```

  After cloning the complete project file locally, run the following command in the folder containing setup.py
  ```python
  pip install .
  ```

  Using commands similar to the one below, enter the protein sequence and the path to save the result to generate a csv file predicting the chemical shift at the specified location
  ```python
  plm-cs YOURSEQUENCE -your_save_path
  ```
  Note that the first time you use it, it takes a lot of time because you need to download the weights of the esm model.


pkgId: 814fe236cd3116ae931f7b4067075ae14edbf66248a52d53eaef4d64240d0998
name: python-plone.api-help
arch: noarch
version: 2.2.4
epoch: 0
release: 1
summary: Development documents and examples for plone.api
url: https://github.com/plone/plone.api
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.api-2.2.4-1.src.rpm
location_href: Packages/python-plone.api-help-2.2.4-1.noarch.rpm
checksum_type: sha256
description:
     You should create a file in the news directory instead.
     For helpful instructions, please see:
     https://github.com/plone/plone.releaser/blob/master/ADD-A-NEWS-ITEM.rst


pkgId: dd323a63137360e3566af7ae29cd69e9aa80e4c2cddedcf21ed36837f2ebe6c5
name: python-plone.app.dexterity-help
arch: noarch
version: 4.0.2
epoch: 0
release: 1
summary: Development documents and examples for plone.app.dexterity
url: http://plone.org/products/dexterity
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.app.dexterity-4.0.2-1.src.rpm
location_href: Packages/python-plone.app.dexterity-help-4.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Dexterity wants to make some things really easy. These are:
  * Create a "real" content type entirely through-the-web without having to
    know programming.
  * As a business user, create a schema using visual or through-the-web tools,
    and augment it with adapters, event handlers, and other Python code written
    on the filesystem by a Python programmer.
  * Create content types in filesystem code quickly and easily, without losing
    the ability to customise any aspect of the type and its operation later if
    required.
  * Support general "behaviours" that can be enabled on a custom type in a
    declarative fashion. Behaviours can be things like title-to-id naming,
    support for locking or versioning, or sets of standard metadata with
    associated UI elements.
  * Easily package up and distribute content types defined through-the-web, on
    the filesystem, or using a combination of the two.


pkgId: 6f26084bad7e9fa15f5e5adab94c8bd260002c32d52a00c77654e0f84e7b534a
name: python-plone.app.discussion-help
arch: noarch
version: 4.1.4
epoch: 0
release: 1
summary: Development documents and examples for plone.app.discussion
url: https://pypi.org/project/plone.app.discussion
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.app.discussion-4.1.4-1.src.rpm
location_href: Packages/python-plone.app.discussion-help-4.1.4-1.noarch.rpm
checksum_type: sha256
description:
  plone.app.discussion is the commenting system used since Plone 4.1.
  It was initially developed as part of the Google Summer of Code 2009 by Timo Stollenwerk (student) and Martin Aspeli (mentor).


pkgId: d1aba20483cf414712242692d66420d69654728f09ea9ae67367632c98855cdf
name: python-plone.app.locales-help
arch: noarch
version: 6.0.27
epoch: 0
release: 1
summary: Development documents and examples for plone.app.locales
url: https://github.com/collective/plone.app.locales
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.app.locales-6.0.27-1.src.rpm
location_href: Packages/python-plone.app.locales-help-6.0.27-1.noarch.rpm
checksum_type: sha256
description:
  The *plone.app.locales* package contains the translation files for Plone Core.
  This version is compatible with Plone 6
  `How to contribute to Plone Core translations <https://6.docs.plone.org/i18n-l10n/contributing-translations.html>`_
  Plone Core i18n domains:
  - cmfeditions
  - cmfplacefulworkflow
  - plone
  - plonefrontpage
  - plonelocales
  - widgets (mockup)


pkgId: 98efe1933264ddb4f53771ff8642359daf87865d7d6c46098d48e1bd3b16a87e
name: python-plone.app.multilingual-help
arch: noarch
version: 8.2.0
epoch: 0
release: 1
summary: Development documents and examples for plone.app.multilingual
url: https://github.com/plone/plone.app.multilingual
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.app.multilingual-8.2.0-1.src.rpm
location_href: Packages/python-plone.app.multilingual-help-8.2.0-1.noarch.rpm
checksum_type: sha256
description:
  In the old days before Plone 4.3, talking about multi-language support in Plone was talk about Products.LinguaPlone. It has been the *defacto* standard for managing translations of Archetypes-based content types in Plone through the years. Somehow its functionality never made its way into the Plone core and today it is in legacy status. Nowadays, Plone faces the rising of Dexterity content types and its adoption into the core since Plone 4.3. With Plone 5 released, the transition is completed and Dexterity is shipped as its default content type story.
  plone.app.multilingual was designed originally to add a whole multilingual story to Plone. Using ZCA technologies, it enables translations to Dexterity and Archetypes content types managed via a unified UI.
  This module provides the user interface for managing content translations. It's the app package of the next generation Plone multilingual engine. It's designed to work with Dexterity content types and the *old fashioned* Archetypes based content types as well. It only works with Plone 4.1 and above due to the use of UUIDs for referencing the translations.
  After more than 7 years, a GSOC, redesigns, reimplementations due to deprecated libraries and two major Plone versions we are finally able to say that plone.app.multilingual has arrived.


pkgId: 531bf6f28fcf43706bda1dcfb5657d346a844e9f7fcc19a9219a65c8203bc82e
name: python-plone.app.users-help
arch: noarch
version: 3.0.9
epoch: 0
release: 1
summary: Development documents and examples for plone.app.users
url: https://pypi.org/project/plone.app.users
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.app.users-3.0.9-1.src.rpm
location_href: Packages/python-plone.app.users-help-3.0.9-1.noarch.rpm
checksum_type: sha256
description:
  This package provides the registration form and the user profile form.
  It allows the site administrator to define the fields those forms will display.


pkgId: e4439cb9be202585c1af8d15e6aba22dab6249e192df71c31999fa1c1ce51dd9
name: python-plone.base-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for plone.base
url: https://github.com/plone/plone.base
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.base-2.0.2-1.src.rpm
location_href: Packages/python-plone.base-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This package is the base package of the `CMS Plone <https://plone.org>`_.
  It contains only interface contracts and basic features and utilities.
  It was created to be able to maintain a clean dependency graph (`PLIP 3395 <https://github.com/plone/Products.CMFPlone/issues/3395>`_).
  In details this package contains:
  ``interfaces`` (package)
      All ``zope.interface`` based contracts for the Plone core packages.
      In Plone 5 and below this was at ``Products.CMFPlone.interfaces``.
  ``i18nl10n`` (module)
      Plone specific internationalization and localization helpers.
      In Plone 5 and below this was at ``Products.CMFPlone.i18nl10n``.
  ``batch`` (module)
      Plone specific Batch based on ``plone.batching``.
      In Plone 5 and below this was at ``Products.CMFPlone.PloneBatch``.
  ``defaultpage`` (module)
      Plone specific handling of default pages with ``CMFDynamicViewFTI``.
      In Plone 5 and below this was at ``Products.CMFPlone.defaultpage``.
  ``permissions`` (module)
      CMFCore permissions declared public.
      In Plone 5 and below this was at ``Products.CMFPlone.permissions``.
  ``utils`` (module)
      A subset of commonly used and low-dependency utilities.
      In Plone 5 and below those been at ``Products.CMFPlone.utils`` (but not all were moved).
  ``navigationroot`` (module)
      Plone specific handling of navigation roots.
      Before those been at ``plone.app.layout.navigation.root``.
  ``__init__``
      ``PloneMessageFactory`` with ``plone`` i18n-domain and ``PloneLocalesMessageFactory`` with ``plonelocales`` domain.
      In Plone 5 and below this was at ``Products.CMFPlone.__init__``.


pkgId: ccfe40fc46c5b36e97ea0fbd37353c06acec3c7713060a4131d6c66dda83ca1e
name: python-plone.distribution-help
arch: noarch
version: 3.0.0b2
epoch: 0
release: 1
summary: Development documents and examples for plone.distribution
url: https://plone.org
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.distribution-3.0.0b2-1.src.rpm
location_href: Packages/python-plone.distribution-help-3.0.0b2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-logo.png">
  </p>

  <h1 align="center">
    Plone Distributions
  </h1>

  Package supporting the (easy) implementation of a Plone distribution.




  A Plone distribution is a pre-packaged version of Plone that includes specific features, themes, modules, and configurations.
  It is a convenient way to get a specific type of website up and running quickly, as the distribution includes everything needed to run that type of site.

  Examples of Plone distributions include:

  - [SENAITE](https://www.senaite.com)
  - [Quaive](https://quaivecloud.com/)
  - [Portal Modelo](https://www.interlegis.leg.br/produtos-servicos/portal-modelo/)
  - [Portal Padrão](https://identidade-digital-de-governo-plone.readthedocs.io/en/latest/)



  - **Drupal:** Drupal has distributions for blogs, e-commerce sites, and intranet portals.

  - **WordPress:** WordPress has a similar concept in the form of "WordPress Multisite," which allows users to run multiple websites from a single installation of WordPress.

  - **Joomla:** Joomla has a similar concept in the form of "Joomla Templates," which are pre-designed templates for Joomla websites.

  - **TYPO3:** TYPO3 has a similar concept in the form of "TYPO3 Distributions," which are pre-configured installations of TYPO3 for specific types of websites.



  | Releases |Description | Status | Supported Plone Versions |
  | --- | --- | --- | --- |
  | 3.x | Core package of Plone | In development  | 6.1 |
  | 2.x | Add-on package, uses plone.exportimport for content creation. | Maintenance | 6.0 |
  | 1.x | Add-on package, uses collective.exportimport for content creation. | Deprecated | 6.0 |



  A Plone distribution is a Python Package that can be installed by `pip`.



  The package will follow some conventions, to make it "discoverable" by others.

  In `setup.py`, always add the correct Trove classifiers:

  ```python
          "Framework :: Plone",
          "Framework :: Plone :: 6.0",
          "Framework :: Plone :: Distribution",
  ```

  and also require `plone.distribution` to be available:

  ```python
      install_requires=[
          "Plone",
          "setuptools",
          "plone.distribution",
      ],
  ```



  In your main `configure.zcml`, make sure to have the `plone` XML namespace declared:

  ```xml
  <configure
      xmlns="http://namespaces.zope.org/zope"
      xmlns:plone="http://namespaces.plone.org/plone"
      >
  ```

  And also include `plone.distribution`:

  ```xml
  <include package="plone.distribution" />
  ```

  Then declare the distributions included in your package:

  ```xml
    <plone:distribution
        name="blog"
        title="Personal Blog"
        description="A Plone site already configured to host a personal Blog."
        directory="distributions/blog"
        />
  ```

  The registered distribution will configure a Personal Blog, with some default content.



  When registering a distribution, you can provide a `pre_handler`, a `handler` and a `post_handler` which must be
  functions with the following signatures.

  ```python
  def pre_handler(answers: dict) -> dict:
      return answers

  def handler(distribution: Distribution, site, answers: dict):
      return site

  def post_handler(distribution: Distribution, site, answers: dict):
      return site
  ```

  Each of those handlers will be called in this way:

  - `pre_handler`: it will process the answers to do modifications on them before creating the site
  - `handler`: it will be run after the bare Plone site will be created, but instead of the default handler that installs the required GenericSetup profiles and creates the content.
  - `post_handler`: it will be run after the site is set up.

  If you have added some extra fields in the Plone site creation form and want to do some extra configuration in the
  Plone site, you can add your own handler and register as follows:

  ```xml
    <plone:distribution
        name="blog"
        title="Personal Blog"
        description="A Plone site already configured to host a personal Blog."
        directory="distributions/blog"
        post_handler=".handlers.blog.post_handler"
        />
  ```



  A convention is to use the `distributions/<distribution_name>`folder in the root of your package to organize your distribution configuration.

  In that folder, you will need to provide:



  A 1080x768 image of your distribution. It could be the default page of a new site, your logo, or any other way of representing this distribution.



  A `JSON` file with the GenericSetup profiles that are used by your distribution during installation.

  This file needs to contain two keys:

  - **base**: List of profiles installed in every new site using this distribution.

  - **content**: List of profiles installed when the user decides to create a site with example content.

  The configuration for a new Volto site is:

  ```json
  {
    "base": [
      "plone.app.contenttypes:default",
      "plone.app.caching:default",
      "plonetheme.barceloneta:default",
      "plone.volto:default"
    ],
    "content": [
      "plone.volto:default-homepage"
    ]
  }
  ```



  If you want to add a Plone backend add-on to your Plone distribution, then you must perform the following steps.

  Add your add-on, such as `collective.person`, to your `setup.py`:

  ```python
      install_requires=[
          "setuptools",
          "Plone",
          "plone.distribution>=1.0.0b2",
          "plone.api",
          "collective.person",
      ],
  ```

  Add it to your `dependencies.zcml`:

  ```xml
    <!-- List all packages you depend here -->
    <include package="plone.volto" />
    <include package="plone.restapi" />
    <include package="collective.person" />
    <include package="plone.distribution" />

  </configure>
  ```

  Add it to your `profiles.json`:

  ```json
    "base": [
      "plone.app.contenttypes:default",
      "plone.app.caching:default",
      "plone.restapi:default",
      "plone.volto:default",
      "collective.person:default",
      "plonetheme.barceloneta:default"
    ],
  ```



  In case you require additional input from the user during site creation, you can customize the form using the `schema.json` file.

  The file should contain two keys:

  - **schema**: A JSON Schema definition.
  - **uischema**: A [react-jsonschema-form](https://rjsf-team.github.io/react-jsonschema-form/docs/) configuration to modify how the form is displayed.

  The **schema** should have at least the following keys:

  - site_id
  - title
  - description
  - default_language
  - portal_timezone
  - setup_content

  The `schema.json` used for the default site creation is:

  ```json
  {
    "schema": {
      "title": "Create a Plone site",
      "description": "Adds a new Plone content management system site to the underlying application server.",
      "type": "object",
      "required": [
        "site_id",
        "title"
      ],
      "properties": {
        "site_id": {
          "type": "string",
          "title": "Path Identifier",
          "default": "Plone",
          "description": "The ID of the site. No special characters or spaces are allowed. This ends up as part of the URL unless hidden by an upstream web server."
        },
        "title": {
          "type": "string",
          "title": "Title",
          "default": "Site",
          "description": "A short title for the site. This will be shown as part of the title of the browser window on each page."
        },
        "description": {
          "type": "string",
          "title": "Site Description",
          "default": "A Plone Site"
        },
        "default_language": {"$ref": "#/definitions/languages"},
        "portal_timezone": {"$ref": "#/definitions/timezones"},
        "setup_content": {
          "type": "boolean",
          "title": "Create Content",
          "description": "Should example content be added during site creation?",
          "default": false
        }
      }
    },
    "uischema": {
    }
  }

  ```

  **Important**
  You probably noticed the entries for
  default_language:

  ```
  {"$ref": "#/definitions/languages"}
  ```
  and portal_timezone:

  ```
  {"$ref": "#/definitions/timezones"}
  ```

  Both definitions are added in runtime by `plone.distribution` to provide a list of languages and timezones available on the installation.



  Folder containing JSON data representing this distribution's content.

  To export content from a site into this folder, use the `bin/export-distribution` script.

  ```shell
  bin/export-distribution path/to/zope.conf Plone
  ```

  > In the example above, "Plone" is the ID of the Plone site to export.





  By default, `plone.distribution` ships with two ready-to-use distributions:

  - **default**: Plone Site (Volto frontend)
  - **classic**: Plone Site (Classic UI)

  If you want to limit your users option to select a distribution, it is possible to set the environment variable `ALLOWED_DISTRIBUTIONS` with fewer options:

  ```shell
  ALLOWED_DISTRIBUTIONS=default
  ```



  <p align="left">
      <a href="https://plone.org/foundation/">
        <img alt="Plone Logo" width="200px" src="https://raw.githubusercontent.com/plone/.github/main/plone-foundation.png">
      </a>
  </p>



  The project is licensed under the GPLv2.




  <!--
     You should *NOT* be adding new change log entries to this file.
     You should create a file in the news directory instead.
     For helpful instructions, please see:
     https://github.com/plone/plone.releaser/blob/master/ADD-A-NEWS-ITEM.rst
  -->

  <!-- towncrier release notes start -->






  - Fix logic for suggested id for new site.
    It could suggest an id that was already taken.
    @mauritsvanrees #97




  - Fix test that failed because an extra distribution was found.
    @mauritsvanrees #104






  - Fix bug where launch screen was blank in Chrome. @davisagli #101






  - Move internal classic distribution to plone.classicui [@mauritsvanrees][@ericof] #79




  - Move internal default distribution to plone.volto [@mauritsvanrees][@ericof] #80




  - Clarify RestTraverser code.
    [maurits]






  - Redesign the site creation page [@danalvrz] #63






  - plone.distribution is now based on plone.exportimport instead of collective.exportimport.

    There are some backwards-incompatible changes in the export format.
    To convert an existing distribution to the new format, use the following steps:
    1. Create a site from the distribution using plone.distribution 1.0.x
    2. Install plone.distribution 2.0.x
    3. Delete the distribution's `contents/items` folder.
    4. Export the distribution in the new format using the `bin/export-distribution` script.

    @davisagli, @ericof #61




  - Default distribution: Allow users to upload a logo during site creation [@ericof] #66
  - Classic distribution: Allow users to upload a logo during site creation [@ericof] #67
  - Remove dependency on Plone package, add dependency on Products.CMFPlone [@ericof] #70




  - Get the name of the existing distribution from the report, not the answers [@ericof] #60
  - Fix issue with payload for new site creation breaking with certain plone.rest versions [@ericof] #71
  - Read profile.json by the pathlib.Path.read_text method to avoid the unclosed file exception [@folix-01] #75




  - Update `plone/meta` configuration [@ericof] #73
  - Log traceback when creating a site fails [@pbauer] #82
  - Bump `plone.exportimport` to 1.0.0a5 [@ericof] #83






  - Fix exporting files.
    [pbauer] #58






  - Fix importing blocks on the site-root.
    [pbauer] #56




  - Update configuration files.
    [plone devs] 6e36bcc4






  - Remove old blobs before exporting content [@ericof] #34
  - Support to new export/import format with one content item per json file [@ericof] #47







  - Validate answers payload against jsonschema [@ericof] #38
  - Allow distribution to pre process answers before site creation [@ericof] #39
  - Override @system from plone.restapi to display distribution information [@ericof] #45







  - Allow setting default_language "default" value [@ericof] #36







  - Bump @rjsf/core to version 5.8.2 [@ericof] #35







  - Fix content export to json [@ericof] #33







  - Improve support for testing distributions [@ericof] #24
  - Allow export only for distributions still in development [@ericof] #28
  - Create a report for Plone sites created from a distribution [@ericof] #30
  - Clean up exported content to remove references to portal.absolute_url() [@ericof] #32




  - Content language should be allowed in portal configuration [@ericof] #23




  - Update configuration files.
    [plone devs] 047ec50d, 55bda5c9, d7e9e748







  - Import did not import any steps except content and portal. [pbauer] #22







  - Increase test coverage.
    [ericof] #12
  - Implement JSON import of content [pbauer] #13
  - Use mxdev.
    [ericof] #18
  - Implement default content for default and classic distributions as JSON.
    [ericof] #20







  - Fix Basic Authentication for Chrome [@ericof] #10







  - Change overview page favicon to use Plone logo [@ericof] #7
  - Set content creation on `default` and `classic` distributions to be default. [@ericof] #9




  - Use [ajv8](https://rjsf-team.github.io/react-jsonschema-form/docs/usage/validation#ajvclass) with Ajv2019 class validator to fix `function nested too deeply` on Firefox [@ericof] #4
  - Handle authentication when /acl_users does not support cookie extraction [@ericof] #6







  - Initial implementation of plone.distribution [@ericof] #1


pkgId: 8c4621e942fc7ebe347d325d770b7f1ad809161aa89d78ef955f06e99d6c51ef
name: python-plone.schemaeditor-help
arch: noarch
version: 4.0.8
epoch: 0
release: 1
summary: Development documents and examples for plone.schemaeditor
url: https://github.com/plone/plone.schemaeditor
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plone.schemaeditor-4.0.8-1.src.rpm
location_href: Packages/python-plone.schemaeditor-help-4.0.8-1.noarch.rpm
checksum_type: sha256
description:
  plone.schemaeditor provides a through-the-web interface for modifying Zope 3
  schemata (interfaces).
  Currently there is support for:
  * adding and removing fields
  * editing attributes of existing fields
  * reordering fields
  * renaming fields
  * organizing fields into fieldsets
  plone.schemaeditor only handles the actual schema editing.  To be useful, it
  requires some integration code to take care of the following pieces:
  * traversing to a schema that is used as the context of the editor
  * persisting schema changes across Zope restarts
  See plone.app.dexterity (along with plone.dexterity and plone.supermodel) for
  one approach to this integration.
  The following field types (from zope.schema) are currently supported:
  * TextLine
  * Text
  * Int
  * Float
  * Bool
  * Password
  * Datetime
  * Choice (with simple list of values)
  * List of Choice (with simple list of values)
  Third-party packages can make additional field types available by registering
  new IFieldFactory utilities.


pkgId: 082db4a41ddc221ecf6d4b18450c73fb353b49f3960db81b9cab7602ce2af241
name: python-plonemeeting.portal.core-help
arch: noarch
version: 2.0.5
epoch: 0
release: 1
summary: Development documents and examples for plonemeeting.portal.core
url: https://github.com/collective/plonemeeting.portal.core
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plonemeeting.portal.core-2.0.5-1.src.rpm
location_href: Packages/python-plonemeeting.portal.core-help-2.0.5-1.noarch.rpm
checksum_type: sha256
description:
  ``plonemeeting.portal.core`` is a comprehensive package designed to facilitate public access
  to decisions and publications from local authorities. By leveraging this package, municipalities and other institutions
  can ensure transparency and foster public trust by making their decisions readily available to the public.


pkgId: ed9f9e60a67028cb530687fa0e44f30a14d18e9e57887e7f559d7b3807a4fcd9
name: python-plonetheme.barceloneta-help
arch: noarch
version: 3.2.1
epoch: 0
release: 1
summary: Development documents and examples for plonetheme.barceloneta
url: https://github.com/plone/plonetheme.barceloneta
rpm_license: GPL version 2
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plonetheme.barceloneta-3.2.1-1.src.rpm
location_href: Packages/python-plonetheme.barceloneta-help-3.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Classic theme resources for Plone 6 - based on Bootstrap 5

  This package provides scss resources to build your own theme based on the Plone default theme for (backend rendered) Classic UI of Plone.

  Latest version on [npmjs.com](https://www.npmjs.com/package/@plone/plonetheme-barceloneta-base)


  The documentation for `plonetheme.barceloneta` is part of the official Plone documentation, [Classic UI theming based on Barceloneta](https://6.docs.plone.org/classic-ui/theming/barceloneta.html).


  https://github.com/plone/plonetheme.barceloneta/blob/master/CHANGES.md




  Please read the document [Contributing to Plone](https://6.docs.plone.org/contributing/index.html). Also consult the document [Contributing to `plone.api`](https://6.docs.plone.org/plone.api/contribute/index.html).


  Plone code repository hosted at Github https://github.com/plone/plonetheme.barceloneta.


  Please use the [Issue-Tracker](https://github.com/plone/plonetheme.barceloneta/issues)



  <!--
     You should *NOT* be adding new change log entries to this file.
     You should create a file in the news directory instead.
     For helpful instructions, please see:
     https://github.com/plone/plone.releaser/blob/master/ADD-A-NEWS-ITEM.rst
  -->

  <!-- towncrier release notes start -->






  - Upgrade TinyMCE 7.6.0
    [petschki] #384




  - Upgrade development dependencies.
    [petschki] #384






  - Upgrade dependencies.
    [petschki] #382






  - Upgrade dependencies.
    [petschki] #380






  - Add styles for details/summary based collapsibles.
    Add support for labels wrapping input fields.

    Ref: https://github.com/plone/Products.CMFPlone/pull/3976 #374
  - [yurj] Add the portal_url parameter to be used with Diazo rules and implement it in backend.xml #376






  - TinyMCE 7.0
    this is a version bump only. There are no CSS changes from TinyMCE 6 -> 7
    [petschki] #371




  - Remove deprecated SVG font resources
    [petschki] #357
  - Fix sticky `.formControls` to not break modals with buttons.
    [petschki] #367






  - pat-plone-modal works fine now and also this would remove "nav-link dropdown-item" classes, unstyling the menu entries
    [yurj] #358
  - Sticky formControls in edit forms.
    Dependency updates.
    [petschki] #361






  - Sanitize color variables to more Bootstrap like approach with main `$primary` color.
    [petschki] #251
  - Upgrade dependencies.
    [petschki] #356







  - Upgrade TinyMCE styles to version 6
    [petschki] #350







  - Fix typo (BS version) in README
    [petschki] #0







  - Update Bootstrap to ``5.3.2``
    [petschki] #346







  - Update Bootstrap to ``5.3.1``
    [petschki] #343




  - Update configuration files.
    [plone devs] cfffba8c




  - Fix broken links in the readme.
    [maurits] #338







  - Update to Bootstrap 5.3 final release.
    [petschki] #333




  - Add "!optional" to extended grid breakpoints selectors to avoid errors when `$grid-breakpoints` is customized.
    [petschki] #329






  - Upgrade Bootstrap `5.3.0-alpha3`
    [petschki] (#325)



  - Update configuration files. [plone devs] (7032e1d4)





  - Update to Bootstrap 5.3.0-alpha2. [toalba,lenadax] (#324)





  - Simplify alert related styles. [lenadax] (#321)
  - Adopt colormode related variables from Bootstrap 5.3. [lenadax]
    (#321)
  - Update Bootstrap -> 5.3.0 [agitator] (#320)



  - Fix Diazo rule problem with undefined footer_portlets and
    footer_portlets_count variables. See:
    <https://community.plone.org/t/error-theme-inherited-from-barceloneta-footer-portlets-count/8455>
    (#239)





  - Update Bootstrap -> 5.2.3 [petschki] (#316)





  - Bootstrap 5.2.2 [petschki] (#313)



  - Add TinyMCE ui styles in non-inline mode. [petschki] (#307)
  - Add content table styles [MrTango] (#311)





  - Fix npm release, rm npmignore, use explicit whitelist in
    package.json, rm legacy scss [MrTango] (#306)





  - prefix icon ptch in index.html with ++theme++barceloneta to prevent
    broken icon in other themes [MrTango] (#304)





  - Include tinymce-formats.css in theme, so that they have an effect.
    [MrTango] (#301)

  - Define max-height for toolbar dropdown so it scrolls if item list is
    too long. [petschki] (#302)

  - disable diazo for manage-viewlets view, because Diazo is messing with viewlets and viewlet manager, which is more confusing than helpful
    [MrTango] (#303)





  - Update Bootstrap 5.2.0 [petschki] (#300)



  - Show footer portlets when managing all portlets from
    @@manage-portlets [frapell] (#281)





  - Example for extra styles that get automatically populated to the
    TinyMCE formats menu added. [agitator] (#282)
  - Reimplement dropout toolbar submenus and collapsed icons. Create CSS
    variables for Plone colors. [petschki, agitator] (#283)
  - Update to Bootstrap 5.2.0-beta1 and make use of CSS variables.
    [agitator] (#286)
  - Global sections: add support for css variables and color modes
    barceloneta, dark, light [agitator] (#288)



  - Fix columns-order when only col-one is displayed. [pbauer] (#279)
  - Fix text wrapping of long toolbar labels. [agitator] (#289)
  - Toolbar width and wrapping tweaks. [agitator] (#292)
  - Ensure pointer cursor on toolbar toggle icon. [petschki] (#294)





  - Styling for liveSearch results with images. [agitator] (#278)





  - moved toolbar css from mockup to barceloneta [petschki] (#267)
  - Optimize image floating for content [MrTango] (#269)
  - Mobile navigation as offcanvas sidebar and integration of search
    into main navigation. [agitator] (#271)
  - Sticky footer [agitator] (#274)
  - update title and preview for Plone 6 [petschki] (#275)



  - Reintroduce diff-styles for CMFEditions [pbauer] (#268)
  - Update main grid breakpoint to lg. [agitator] (#277)





  - del favicons from index.html and rules [talarias] (plip-favicon)



  - Be more specific where replacing the head title element [ale-rt]
    (#264)





  - Refactored the scss for the alerts. [klye] (#250)



  - Remove unused IBarcelonetaLayer. [agitator] (#254)
  - Add print styles. Disable important for utility classes. Enable
    negative margin utility classes. [agitator] (#255)





  - Make loading of webfont optional. Move Barceloneta specific styles
    out of base.scss. Update to Bootstrap 5.1.3. [agitator] (#253)



  - event listing datecard style [petschki] (#252)





  - Added npm packaging info [agitator] (#251)





  - Update to Bootstrap 5.1.0 [petschki] (#247)
  - Update to Bootstrap 5.1.1 [petschki] (#248)





  - Optimize responsive header behavior. [agitator] (#1)





  - Update to Bootstrap 5.0.1 [agitator] (#241)
  - Update to Bootstrap 5.0.2 Update sitenav with Bootstrap defaults and
    cleanup. [agitator] (#243)





  - Rework contenttype views. Update to Bootstrap 5.0.0-beta3
    [agitator] (#236)
  - Update to Bootstrap 5.0.1 [agitator] (#238)





  - Remove hero move to top from rules. [jensens] (hero)
  - Change Templates to Bootstrap 5. [agitator, santonelli] (#137)
  - Change to relative xml include path to make external includes
    possible [gomez] (#212)
  - Add styling for comments. [santonelli] (#225)
  - Update markup for document byline [santonelli] (#235) (#235)
  - Use CSS class grid marker in body tag and Bootstrap mixins to
    define the grid, instead injecting them with Diazo. This will
    work even without Diazo and is more flexible. [MrTango] (#245)



  - Update `lodash` via @dependabot notification. [jensens] (#209)
  - Cleanup code base:
    - Black code style,
    - Remove unnecessary code snippets, e.g. the magic utf8 header not
      needed in Python 3 and unused ZCML namespaces,
    - Remove skins.xml GS import step,
    - Remove unused less resource directory. (#229)
  - Also leave `#edit-bar` intact when copying the toolbar html into the
    theme using backend.xml, as was fixed two years to in the normal
    rules.xml. [fredvd] (#3191)





  - Revert "Fix the different width of Hide and Show button in action
    control panel" [vincentfretin] (#187)





  - Load zcml of `plone.resource` for our use of the `plone:static`
    directive. [maurits] (#2952)





  - Allow long photoAlbumEntryTitle entries to break to fit width.
    [agitator] (#183)





  - Fix submenu width for long entries [agitator] (#182)





  - Navigation style and overflow improvements [agitator] (#180)
  - Further navigation style improvements - increase button touch area
    [agitator] (#181)





  - Fix sitemap links (#173)
  - Sitenav style improvements (#176)
  - Fix overlapping css issue of Remove and Save button in pattern
    option of Resource Registries (#1111)





  - Added styles for multilevel dropdown navigation [agitator] (#2516)



  - Fix the different width of Hide and Show button in action control
    panel (#2480)





  - Make final release. [maurits] (#170)
  - Initialize towncrier. [gforcada] (#2548)



  Breaking changes:

  - Re-ordering of content columns: Have content container before
    column1 before column2. [tmassman]



  - Additional footer portlets show in a doormat footer. [tmassman]





  - Do not strip the `#edit-bar` section from the toolbar. Refs:
    https://github.com/plone/Products.CMFPlone/issues/2322 [thet]





  - Integrated plone.app.event styles and further cleanup. [agitator]





  - Fix nested navigation tree and icon visibility [petschki]





  - Fix missing colons in less variables [pnicolli]





  - Pagination: made label and arrows easier to customise. [iham]



  - fix overlapping of images when portlets exist
    https://github.com/plone/Products.CMFPlone/issues/2179 [fgrcon]
  - Fix horizontal scrollbar issue on some screen sizes. [agitator,
    davilima6]
  - Remove duplicate definition of container size variables [agitator,
    davilima6]
  - Added extra large & extra small break points [agitator, davilima6]





  - Add more HTML text based input types. [thet]
  - Fix disabled styles for readonly and disabled inputs, selects,
    textareas and fieldsets. [thet]
  - Define variable `cursor-disabled` in variables.less for better
    reuse. [thet]
  - Add theme classifier. [tmassman]



  Breaking changes:

  - Simplify `contents.plone.less`. Contenttype icons now use the
    `::before` instead of `::after` pseudo element selector. [thet]



  - Do not use nested selectors for contenttype-icons, so that they can
    be shown anywhere, also outside the Plone main wrappers. Still use
    specific styles for the toolbar. This solves a problem, where
    contenttype-icons couldn't be shown in DOM nodes injected by
    JavaScript outside the main Plone wrapper. [thet]



  - Force state colors everywhere. Fixes #133. [thet]
  - Limited printed data to page content only #139. [enkidulan]
  - Fixed vertical align of nav items thumbs in navigation portlet
    
  - Change `:before` and `:after` to `::before` and `::after` to follow
    CSS3 specs. [thet]





  - Added Bootstrap-Dropdown default styles. [agitator]





  - remove paperclip fontello icon for file types (is being replaced by
    mimetype icons) remove superfluous bullets in portlets ... fix icons
    in select default page pop up
    <https://github.com/plone/Products.CMFPlone/issues/1734> [fgrcon]



  - Fix position of checkboxes with long fieldhelp [agitator]





  - Added styles for input type number. [agitator]





  - Remove redundant PickADate rules. [thet]





  - fix weird nav scrollbars on mobile [agitator]





  - Add default content type icon to add menu only. Add missing npm
    dependency. [alecm]



  - Unset select width and display [agitator]
  - Isolate the autotabs class for `ul` elements to
    `.autotabs ul.autotoc-nav`. Fixes an issue, where list elements in
    an inline TinyMCE content area were displayed wrong. [thet]
  - Fix buttons alignment in ordered selection widget [ale-rt]





  - Remove references to discarded offcanvas feature [davilima6]





  - Set news lead image background for transparent images
    <https://github.com/plone/plonetheme.barceloneta/issues/107>
    [staeff]



  New:

  - Add styles for manage portlets jumplist [davilima6]

  Fixes:

  - Use `.alert.status` selector as an alternative to `.portalMessage`.
    This class is used by the structure pattern. [thet]
  - Make search button grow with the search buttons text. Fixes an issue
    where translated button texts were not fitting into the button.
    [kkhan, thet]



  New:

  - Add missing caret styles. [thet]
  - Extended form styles for input type="email". [agitator]
  - Isolate calendar portlet styles. [agitator]
  - Added invisible-grid table styles. [agitator]
  - Action control panel specific rendering. [ebrehault]

  Fixes:

  - Improved "feel" for the Site Setup (@@overview-controlpanel)
    <https://github.com/plone/Products.CMFPlone/issues/1435>
    [pigeonflight]
  - Fix code analysis errors reported by
    <http://jenkins.plone.org/view/Pkgs/job/package-plonetheme.barceloneta>
    [gforcada]
  - Drop toolbar for anonymous users.
  - Fixed html validation:
    - the banner role is unnecessary for element header,
    - element main does not need a role attribute,
    - the contentinfo role is unnecessary for element footer.
    [maurits]



  New:

  - Modernize pagination markup and switches deprecated `listingBar` CSS
    class to `pagination`. [davilima6]

  Fixes:

  - Move hero to content Issue
    <https://github.com/plone/Products.CMFPlone/issues/974> [gyst]
  - Add `barceloneta-mixin-font` to the registerless profile.
    [pcdummy]
  - Inline `style` tags in head are no more skipped [keul]
  - Follow best practice for readme.rst [allcaps]
  - Center the leadimage on the modal window. Partially close
    [#321](https://github.com/plone/plone.app.contenttypes/issues/321).
    [keul]
  - Fix filenames for roboto-lightitalic.ttf, -mediumitalic.ttd and
    -bolditalic.ttf to match those in less files [datakurre]



  Fixes:

  - Add 2014 Roboto [allcaps]
  - Fix @font-face. Load eot, svg and woff. [allcaps]
  - Add Roboto fonts with full glyph set [allcaps]
  - Add weight to all fonts (contributes to
    [#24](https://github.com/plone/plonetheme.barceloneta/issues/24)).
    [allcaps]
  - Restore the principal aka jumbotron background. [allcaps]
  - Fix sitemap layout. Drop the columns. (closes
    [#57](https://github.com/plone/plonetheme.barceloneta/issues/57)).
    [allcaps]
  - Remove trailing comma's in Grunt file. [allcaps]
  - Use border radius variables in portlets. [allcaps]
  - Mismatched properties and values. [allcaps]
  - Ignore diff of map file. [allcaps]



  Fixes:

  - Fixed some css rules (missing clearfixes, aligning thumbs, ...).
    <https://github.com/plone/plonetheme.barceloneta/issues/62>
    [fgrcon]
  - Added css-rules for thumbnails in listings and portlets. Related to
    [#1226](https://github.com/plone/Products.CMFPlone/issues/1226).
    [fgrcon]
  - Underline links in #content-core (criterion 1.4.1). [polyester]
  - Increased contrast, eliminated contrast-checker false positives.
    [polyester]
  - Title under thumb in albumview (closes
    [#1091](https://github.com/plone/Products.CMFPlone/issues/1091)).
    [polyester]
  - Don't include diazo bundle in backend theme. [instification]
  - Discard duplicated ids for columns (closes
    [#1105](https://github.com/plone/Products.CMFPlone/issues/1105))
    [davilima6]
  - Add comment to alert on duplicate resource registering [davilima6]



  - Fix in barceloneta word wrap in event listing. [sneridagh]



  - Add spaces between checks and labels in search filter (closes
    [#982](https://github.com/plone/Products.CMFPlone/issues/982)).
    [rodfersou]
  - Center buttons on ordered selection lists (closes
    [#1017](https://github.com/plone/Products.CMFPlone/issues/1017)).
    [rodfersou]
  - Center checkboxes on user/group matrix (closes
    [#1003](https://github.com/plone/Products.CMFPlone/issues/1003)).
    [rodfersou]
  - Remove hero-element from index.html. Instead include a view @@hero.
    Fixes <https://github.com/plone/Products.CMFPlone/issues/974>
    [pbauer]
  - Harmonize plone.app.discussion styles and discussion.plone.less
    styles refs (refs
    [#764](https://github.com/plone/Products.CMFPlone/issues/764))
    [ichim-david]
  - Fix display of date widget arrows and footer buttons (refs
    [#891](https://github.com/plone/Products.CMFPlone/issues/891)).
    [ichim-david]
  - Clean Gruntfile.js, package.json and HOWTO_DEVELOP.rst of grunt
    plugins and information which this package no longer uses since
    commit 9f5434 [ichim-david]
  - provide basic table styles [vangheem]
  - Fixed (refs
    [#979](https://github.com/plone/Products.CMFPlone/issues/979) and
    [#981](https://github.com/plone/Products.CMFPlone/issues/981))
    related to text not wrapping when unusual (and artificial) text with
    no white-space exists in the page [sneridagh]
  - Fixed styling problems when figcaption is very long [sneridagh]
  - Renamed the news.plone.less into behaviors.plone.less as it no
    longer make sense [sneridagh]



  - Fix display of album_view title links (closes
    [#911](https://github.com/plone/Products.CMFPlone/issues/911)).
    [ichim-david]



  - Bring back document byline (closes
    [#741](https://github.com/plone/Products.CMFPlone/issues/741)).
    [rodfersou]
  - Prefer rules with CSS selectors over XPath whenever possible
    [davilima6]



  - Add a pared down version of barceloneta to include in your theme to
    save you making a custom backend theme. [djay]



  - Hide searchbox, personaltools, breadcrumbs in print.css [gomez]
  - Updated font-weight on portlet headers [pigeonflight]
  - Update font-weight on portlet management items [vangheem]
  - Updated to index.html: link to plone.com opens in new window/tab
    [tkimnguyen]



  - New control panel overview and portlet layout. [sneridagh]
  - Fixed bug in portlet navigation due to a CSS error. [sneridagh]
  - Fix problem with CSS leaking from the cp overview to the portlet.
    [sneridagh]
  - Fix map. [sneridagh]
  - Added a:hover styles for h1 h2 h3. [agitator]
  - Role for gigantic is complementary. [bloodbare]
  - Do not use absolute prefix to reference index.html to copying themes
    does not reference original theme file. [vangheem]
  - Toolbar fixes. [bloodbare]
  - Various mobile fixes. [agitator]
  - Update index.html. Change plone.org link to plone.com.
    [tkimnguyen]
  - Do not uppercase the colophon. [gforcada]



  - provide more sane default widths and heights to select[multiple]
    and textareas [vangheem]
  - hide crud-form select header by default [vangheem]
  - remove loader since it is in mockup now [vangheem]
  - tweak manage portlets styles [vangheem]
  - fixed rules for copying content. [hvozdovych]



  - provide some spacing between event summary and content [vangheem]



  - Fix extending barceloneta with xi:include [pbauer]



  - fix in and out widget button style [vangheme]
  - no one likes the star for required field label, try circle
    [vangheem]
  - add plone-loader style so you can add decent loader to javascript
    [vangheem]
  - add styles for search form [vangheem]
  - Cleanup: Remove unused resources. [thet]
  - Fix toggling navigation at mobile widths. [davisagli]
  - Remove sticky footer (it required a hardcoded height, which does not
    work for an element that may have varying content). [davisagli]
  - Add clearfix to `.row`. [davisagli]
  - pat-modal pattern has been renamed to pat-plone-modal [jcbrand]



  - Add language selector widget [bloodbare]



  - Change font family of `form.widgets.IRichText.text` textareas to
    monospace. This affects the texteditor only in non-Richtext mode and
    helps editing e.g. Restructured Text. [thet]
  - Change `min-height` of textarea fields from auto to `4em`
    (description, etc.), respectively `12em` for IRichText widgets (e.g.
    when displayed without a visual editor). [thet]
  - Return to being a clean Diazo theme so that we are a safe starting
    point for people building their own themes and a good practice
    example that works when copying the theme in the TTW theme editor.
    [optilude, bloodbare]



  - Remind committers to add changelog entries. I'm not your monkey.
    [esteele]



  - Initial release [esteele]


pkgId: 1015d885326de0971d40e3f3ef4f1152422f9b163931c62d0a18068ce611cf29
name: python-plotastrodata-help
arch: noarch
version: 1.0.4
epoch: 0
release: 1
summary: Development documents and examples for plotastrodata
url: https://github.com/yusukeaso-astron/plotastrodata
rpm_license: GNU General Public License Version 3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plotastrodata-1.0.4-1.src.rpm
location_href: Packages/python-plotastrodata-help-1.0.4-1.noarch.rpm
checksum_type: sha256
description:
  Python package to make figures from radio astronomical data by astropy and matplotlib.




  The file example.py will help to find how to use this package.
  ```bash
  git clone https://github.com/yusukeaso-astron/plotastrodata
  cd plotastrodata
  python example.py
  ```
  To keep the package updated, type the command below in the directory plotastrodata, always before you use.
  ```bash
  git pull
  ```
  Also, setting the path in .bashrc (or .zshrc etc.) will be useful.
  ```bash
  export PYTHONPATH=${PYTHONPATH}:/YOUR_PATH_TO/plotastrodata
  ```
  Or directly in your script,
  ```Python
  import  sys
  sys.path.append( "/YOUR_PATH_TO/plotastrodata" )
  ```
  The Sphinx html document is available from docs/_build/index.html or [readthedocs](https://plotastrodata.readthedocs.io/en/latest/).



  plotastrodata can do the following things.
  * Make 3D channel maps, 3D rotatable html cube, or 2D images including position-velocity diagrams.
  * Color scale can be linear, log, and asinh.
  * Make a figure of line profiles with Gaussian fitting.
  * Plot images to externally given fig and ax (2D images only).
  * Combine color, contour, segment, and RGB maps using images with different spatial grids.
  * Input fits files or 2D/3D numpy arrays.
  * Select the R.A.-Dec. style or the offset style as the x/y tick labels.
  * Fill channel maps with a 2D image.
  * Add line, arrow, ellipse, rectangle, text, and marker in specified channels.
  * Use original arguments of matplotlib (pcolormesh, contour, quiver, plot, text, Ellipse, Rectangle).
  * Other functions for plotting line profiles and a spatial 1D slice.
  * example_advanced.py includes how to make a movie of channel maps.
  * There are other utilities for Fourier transform and fitting.



  * astropy
  * corner (only for fitting)
  * dynesty (only for fitting)
  * ffmpeg (only for movie)
  * matplotlib
  * multiprocess (only for fitting)
  * numpy
  * pillow (only for RGB figures)
  * plotly (only for html cube)
  * ptemcee (only for fitting)
  * scikit-image (only for html cube)
  * scipy
  * tqdm (only for fitting)




  Download from https://github.com/yusukeaso-astron/plotastrodata or git clone.
  ```bash
  git clone https://github.com/yusukeaso-astron/plotastrodata
  ```



  * For 3D data, a 1D velocity array or a FITS file with a velocity axis must be given to set up channels in each page.
  * For 2D/3D data, the spatial center can be read from a FITS file or manually given.
  * len(v)=1 (default) means to make a 2D figure.
  * Spatial lengths are in the unit of arcsec, or au if dist (!= 1) is given.
  * Angles are in the unit of degree.
  * For region, line, arrow, label, and marker, a single input can be treated without a list, e.g., anglelist=60, as well as anglelist=[60].
  * Each element of poslist supposes a text coordinate like '01h23m45.6s 01d23m45.6s' or a list of relative x and y like [0.2, 0.3] (0 is left or bottom, 1 is right or top).
  * Parameters for original methods in matplotlib.axes.Axes can be used as kwargs; see the default kwargs0 for reference.
  * Position-velocity diagrams (pv=True) does not yet suppot region, line, arrow, and segment because the units of abscissa and ordinate are different.



  * Name: Yusuke Aso
  * Affiliation: Korea Astronomy and Space Science Institute
  * E-mail: yaso@kasi.re.kr



  "plotastrodata" is under [GNU General Public License Version 3](https://www.gnu.org/licenses/gpl-3.0.html).


pkgId: 5612352089d30889ce9470455695eb122afe776904a8f6cb779434427710c262
name: python-plotnine-help
arch: noarch
version: 0.14.4
epoch: 0
release: 1
summary: Development documents and examples for plotnine
url: https://pypi.org/project/plotnine/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plotnine-0.14.4-1.src.rpm
location_href: Packages/python-plotnine-help-0.14.4-1.noarch.rpm
checksum_type: sha256
description:
  Plotnine has tests that generate images which are compared to baseline images known
  to be correct. To generate images that are consistent across all systems you have
  to install matplotlib from source. You can do that with ``pip`` using the command.
  ```console
  $ pip install matplotlib --no-binary matplotlib
  ```
  Otherwise there may be small differences in the text rendering that throw off the
  image comparisons.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2022 Hassan Kibirige  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: 611182717a82f1e368af4a0e88114a995b225fa0d7867fead37ae9319525b09b
name: python-pltx-help
arch: noarch
version: 0.0.3
epoch: 0
release: 1
summary: Development documents and examples for pltx
url: https://gitee.com/summry/pltx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pltx-0.0.3-1.src.rpm
location_href: Packages/python-pltx-help-0.0.3-1.noarch.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

          import pltx

          y_true = [1, 1, 1, 0, 0, 0]
          y_pred = [1, 0, 1, 0, 0, 0]
          y_prob = [0.9, 0.1, 0.8, 0.2, 0.7, 0.3]

          pltx.plot_roc(y_true, y_prob)
          pltx.plot_confusion_matrix2(y_true, y_pred)


pkgId: 4beef2853abe9f22bea269d82c6a8994942bba09695121aa8fac5285b0e9ad1b
name: python-pluggy-sdk-help
arch: noarch
version: 1.0.0.post31
epoch: 0
release: 1
summary: Development documents and examples for pluggy-sdk
url: https://github.com/diraol/pluggy-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pluggy-sdk-1.0.0.post31-1.src.rpm
location_href: Packages/python-pluggy-sdk-help-1.0.0.post31-1.noarch.rpm
checksum_type: sha256
description:
  *AccountApi* | [**accounts_list**](docs/AccountApi.md#accounts_list) | **GET** /accounts | List
  *AccountApi* | [**accounts_retrieve**](docs/AccountApi.md#accounts_retrieve) | **GET** /accounts/{id} | Retrieve
  *AuthApi* | [**auth_create**](docs/AuthApi.md#auth_create) | **POST** /auth | Create API Key
  *AuthApi* | [**connect_token_create**](docs/AuthApi.md#connect_token_create) | **POST** /connect_token | Create Connect Token
  *BenefitApi* | [**benefit_retrieve_by_id**](docs/BenefitApi.md#benefit_retrieve_by_id) | **GET** /benefits/{id} | Retrieve
  *BenefitApi* | [**benefits_list**](docs/BenefitApi.md#benefits_list) | **GET** /benefits | List
  *BillApi* | [**bills_list**](docs/BillApi.md#bills_list) | **GET** /bills | List
  *BillApi* | [**bills_retrieve**](docs/BillApi.md#bills_retrieve) | **GET** /bills/{id} | Retrieve
  *BulkPaymentApi* | [**bulk_payment_create**](docs/BulkPaymentApi.md#bulk_payment_create) | **POST** /payments/bulk | Create
  *BulkPaymentApi* | [**bulk_payment_delete**](docs/BulkPaymentApi.md#bulk_payment_delete) | **DELETE** /payments/bulk/{id} | Delete
  *BulkPaymentApi* | [**bulk_payment_retrieve**](docs/BulkPaymentApi.md#bulk_payment_retrieve) | **GET** /payments/bulk/{id} | Retrieve
  *BulkPaymentApi* | [**bulk_payments_list**](docs/BulkPaymentApi.md#bulk_payments_list) | **GET** /payments/bulk | List
  *CategoryApi* | [**categories_list**](docs/CategoryApi.md#categories_list) | **GET** /categories | List
  *CategoryApi* | [**categories_retrieve**](docs/CategoryApi.md#categories_retrieve) | **GET** /categories/{id} | Retrieve
  *CategoryApi* | [**client_category_rules_create**](docs/CategoryApi.md#client_category_rules_create) | **POST** /categories/rules | Create Category Rule
  *CategoryApi* | [**client_category_rules_list**](docs/CategoryApi.md#client_category_rules_list) | **GET** /categories/rules | List Category Rules
  *ConnectorApi* | [**connector_retrieve**](docs/ConnectorApi.md#connector_retrieve) | **GET** /connectors/{id} | Retrieve
  *ConnectorApi* | [**connectors_list**](docs/ConnectorApi.md#connectors_list) | **GET** /connectors | List
  *ConnectorApi* | [**connectors_validate**](docs/ConnectorApi.md#connectors_validate) | **POST** /connectors/{id}/validate | Validate
  *ConsentApi* | [**consent_retrieve**](docs/ConsentApi.md#consent_retrieve) | **GET** /consents/{id} | Retrieve
  *ConsentApi* | [**consents_list**](docs/ConsentApi.md#consents_list) | **GET** /consents | List
  *IdentityApi* | [**identity_find_by_item**](docs/IdentityApi.md#identity_find_by_item) | **GET** /identity | Find by item
  *IdentityApi* | [**identity_retrieve**](docs/IdentityApi.md#identity_retrieve) | **GET** /identity/{id} | Retrieve
  *InvestmentApi* | [**investment_transactions_list**](docs/InvestmentApi.md#investment_transactions_list) | **GET** /investments/{id}/transactions | List investment transactions
  *InvestmentApi* | [**investments_list**](docs/InvestmentApi.md#investments_list) | **GET** /investments | List
  *InvestmentApi* | [**investments_retrieve**](docs/InvestmentApi.md#investments_retrieve) | **GET** /investments/{id} | Retrieve
  *ItemsApi* | [**items_create**](docs/ItemsApi.md#items_create) | **POST** /items | Create
  *ItemsApi* | [**items_delete**](docs/ItemsApi.md#items_delete) | **DELETE** /items/{id} | Delete
  *ItemsApi* | [**items_retrieve**](docs/ItemsApi.md#items_retrieve) | **GET** /items/{id} | Retrieve
  *ItemsApi* | [**items_send_mfa**](docs/ItemsApi.md#items_send_mfa) | **POST** /items/{id}/mfa | Send MFA
  *ItemsApi* | [**items_update**](docs/ItemsApi.md#items_update) | **PATCH** /items/{id} | Update
  *LoanApi* | [**loans_list**](docs/LoanApi.md#loans_list) | **GET** /loans | List
  *LoanApi* | [**loans_retrieve**](docs/LoanApi.md#loans_retrieve) | **GET** /loans/{id} | Retrieve
  *PaymentCustomerApi* | [**payment_customer_create**](docs/PaymentCustomerApi.md#payment_customer_create) | **POST** /payments/customers | Create
  *PaymentCustomerApi* | [**payment_customer_delete**](docs/PaymentCustomerApi.md#payment_customer_delete) | **DELETE** /payments/customers/{id} | Delete
  *PaymentCustomerApi* | [**payment_customer_retrieve**](docs/PaymentCustomerApi.md#payment_customer_retrieve) | **GET** /payments/customers/{id} | Retrieve
  *PaymentCustomerApi* | [**payment_customer_update**](docs/PaymentCustomerApi.md#payment_customer_update) | **PATCH** /payments/customers/{id} | Update
  *PaymentCustomerApi* | [**payment_customers_list**](docs/PaymentCustomerApi.md#payment_customers_list) | **GET** /payments/customers | List
  *PaymentIntentApi* | [**payment_intent_create**](docs/PaymentIntentApi.md#payment_intent_create) | **POST** /payments/intents | Create
  *PaymentIntentApi* | [**payment_intent_retrieve**](docs/PaymentIntentApi.md#payment_intent_retrieve) | **GET** /payments/intents/{id} | Retrieve
  *PaymentIntentApi* | [**payment_intents_list**](docs/PaymentIntentApi.md#payment_intents_list) | **GET** /payments/intents | List
  *PaymentRecipientApi* | [**payment_recipient_create**](docs/PaymentRecipientApi.md#payment_recipient_create) | **POST** /payments/recipients | Create
  *PaymentRecipientApi* | [**payment_recipient_delete**](docs/PaymentRecipientApi.md#payment_recipient_delete) | **DELETE** /payments/recipients/{id} | Delete
  *PaymentRecipientApi* | [**payment_recipient_institutions_retrieve**](docs/PaymentRecipientApi.md#payment_recipient_institutions_retrieve) | **GET** /payments/recipients/institutions/{id} | Retrieve Institution
  *PaymentRecipientApi* | [**payment_recipient_retrieve**](docs/PaymentRecipientApi.md#payment_recipient_retrieve) | **GET** /payments/recipients/{id} | Retrieve
  *PaymentRecipientApi* | [**payment_recipient_update**](docs/PaymentRecipientApi.md#payment_recipient_update) | **PATCH** /payments/recipients/{id} | Update
  *PaymentRecipientApi* | [**payment_recipients_institution_list**](docs/PaymentRecipientApi.md#payment_recipients_institution_list) | **GET** /payments/recipients/institutions | List Institutions
  *PaymentRecipientApi* | [**payment_recipients_list**](docs/PaymentRecipientApi.md#payment_recipients_list) | **GET** /payments/recipients | List
  *PaymentRequestApi* | [**payment_request_create**](docs/PaymentRequestApi.md#payment_request_create) | **POST** /payments/requests | Create
  *PaymentRequestApi* | [**payment_request_create_boleto**](docs/PaymentRequestApi.md#payment_request_create_boleto) | **POST** /payments/requests/boleto | Create boleto payment request
  *PaymentRequestApi* | [**payment_request_create_pix_qr**](docs/PaymentRequestApi.md#payment_request_create_pix_qr) | **POST** /payments/requests/pix-qr | Create PIX QR payment request
  *PaymentRequestApi* | [**payment_request_delete**](docs/PaymentRequestApi.md#payment_request_delete) | **DELETE** /payments/requests/{id} | Delete
  *PaymentRequestApi* | [**payment_request_receipt_create**](docs/PaymentRequestApi.md#payment_request_receipt_create) | **POST** /payments/requests/{id}/receipts | Create Payment Receipt
  *PaymentRequestApi* | [**payment_request_receipt_list**](docs/PaymentRequestApi.md#payment_request_receipt_list) | **GET** /payments/requests/{id}/receipts | List Payment Receipts
  *PaymentRequestApi* | [**payment_request_receipt_retrieve**](docs/PaymentRequestApi.md#payment_request_receipt_retrieve) | **GET** /payments/requests/{payment-request-id}/receipts/{payment-receipt-id} | Retrieve Payment Receipt
  *PaymentRequestApi* | [**payment_request_retrieve**](docs/PaymentRequestApi.md#payment_request_retrieve) | **GET** /payments/requests/{id} | Retrieve
  *PaymentRequestApi* | [**payment_request_update**](docs/PaymentRequestApi.md#payment_request_update) | **PATCH** /payments/requests/{id} | Update
  *PaymentRequestApi* | [**payment_requests_list**](docs/PaymentRequestApi.md#payment_requests_list) | **GET** /payments/requests | List
  *PaymentScheduleApi* | [**payment_schedules_cancel**](docs/PaymentScheduleApi.md#payment_schedules_cancel) | **POST** /payments/requests/{id}/schedules/cancel | Cancel Payment Schedule Authorization
  *PaymentScheduleApi* | [**payment_schedules_cancel_specific**](docs/PaymentScheduleApi.md#payment_schedules_cancel_specific) | **POST** /payments/requests/{id}/schedules/{scheduleId}/cancel | Cancel Payment Schedule Authorization
  *PaymentScheduleApi* | [**payment_schedules_list**](docs/PaymentScheduleApi.md#payment_schedules_list) | **GET** /payments/requests/{id}/schedules | List Schedules
  *SmartAccountApi* | [**smart_account_balance_retrieve**](docs/SmartAccountApi.md#smart_account_balance_retrieve) | **GET** /payments/smart-accounts/{id}/balance | Retrieve Balance
  *SmartAccountApi* | [**smart_account_create**](docs/SmartAccountApi.md#smart_account_create) | **POST** /payments/smart-accounts | Create
  *SmartAccountApi* | [**smart_account_retrieve**](docs/SmartAccountApi.md#smart_account_retrieve) | **GET** /payments/smart-accounts/{id} | Retrieve
  *SmartAccountApi* | [**smart_account_transfer**](docs/SmartAccountApi.md#smart_account_transfer) | **GET** /payments/smart-accounts/{id}/transfers/{transfer_id} | Retrieve Transfer
  *SmartAccountApi* | [**smart_account_transfer_create**](docs/SmartAccountApi.md#smart_account_transfer_create) | **POST** /payments/smart-accounts/{id}/transfers | Create Transfer
  *SmartAccountApi* | [**smart_accounts_list**](docs/SmartAccountApi.md#smart_accounts_list) | **GET** /payments/smart-accounts | List
  *SmartTransferApi* | [**smart_tranfers_preauthorizations_list**](docs/SmartTransferApi.md#smart_tranfers_preauthorizations_list) | **GET** /smart-transfers/preauthorizations | List preauthorizations
  *SmartTransferApi* | [**smart_transfer_payment_create**](docs/SmartTransferApi.md#smart_transfer_payment_create) | **POST** /smart-transfers/payments | Create payment
  *SmartTransferApi* | [**smart_transfer_paymentretrieve**](docs/SmartTransferApi.md#smart_transfer_paymentretrieve) | **GET** /smart-transfers/payments/{id} | Retrieve payment
  *SmartTransferApi* | [**smart_transfer_preauthorization_create**](docs/SmartTransferApi.md#smart_transfer_preauthorization_create) | **POST** /smart-transfers/preauthorizations | Create preauthorization
  *SmartTransferApi* | [**smart_transfer_preauthorization_retrieve**](docs/SmartTransferApi.md#smart_transfer_preauthorization_retrieve) | **GET** /smart-transfers/preauthorizations/{id} | Retrieve preauthorization
  *TransactionApi* | [**transactions_list**](docs/TransactionApi.md#transactions_list) | **GET** /transactions | List
  *TransactionApi* | [**transactions_retrieve**](docs/TransactionApi.md#transactions_retrieve) | **GET** /transactions/{id} | Retrieve
  *TransactionApi* | [**transactions_update**](docs/TransactionApi.md#transactions_update) | **PATCH** /transactions/{id} | Update
  *WebhookApi* | [**webhooks_create**](docs/WebhookApi.md#webhooks_create) | **POST** /webhooks | Create
  *WebhookApi* | [**webhooks_delete**](docs/WebhookApi.md#webhooks_delete) | **DELETE** /webhooks/{id} | Delete
  *WebhookApi* | [**webhooks_list**](docs/WebhookApi.md#webhooks_list) | **GET** /webhooks | List
  *WebhookApi* | [**webhooks_retrieve**](docs/WebhookApi.md#webhooks_retrieve) | **GET** /webhooks/{id} | Retrieve
  *WebhookApi* | [**webhooks_update**](docs/WebhookApi.md#webhooks_update) | **PATCH** /webhooks/{id} | Update

   - [Account](docs/Account.md)
   - [AccountsList200Response](docs/AccountsList200Response.md)
   - [Address](docs/Address.md)
   - [AuthRequest](docs/AuthRequest.md)
   - [AuthResponse](docs/AuthResponse.md)
   - [BankData](docs/BankData.md)
   - [BenefitLoan](docs/BenefitLoan.md)
   - [BenefitLoanClient](docs/BenefitLoanClient.md)
   - [BenefitResponse](docs/BenefitResponse.md)
   - [BenefitResponsePayingInstitution](docs/BenefitResponsePayingInstitution.md)
   - [BenefitsList200Response](docs/BenefitsList200Response.md)
   - [Bill](docs/Bill.md)
   - [BillFinanceCharge](docs/BillFinanceCharge.md)
   - [BillsList200Response](docs/BillsList200Response.md)
   - [Boleto](docs/Boleto.md)
   - [BoletoPayer](docs/BoletoPayer.md)
   - [BoletoRecipient](docs/BoletoRecipient.md)
   - [BulkPayment](docs/BulkPayment.md)
   - [BulkPaymentsList200Response](docs/BulkPaymentsList200Response.md)
   - [CUSTOM](docs/CUSTOM.md)
   - [Category](docs/Category.md)
   - [ClientCategoryRule](docs/ClientCategoryRule.md)
   - [Company](docs/Company.md)
   - [ConnectTokenRequest](docs/ConnectTokenRequest.md)
   - [ConnectTokenResponse](docs/ConnectTokenResponse.md)
   - [Connector](docs/Connector.md)
   - [ConnectorCredential](docs/ConnectorCredential.md)
   - [ConnectorHealth](docs/ConnectorHealth.md)
   - [ConnectorHealthDetails](docs/ConnectorHealthDetails.md)
   - [ConnectorListResponse](docs/ConnectorListResponse.md)
   - [ConnectorUserAction](docs/ConnectorUserAction.md)
   - [Consent](docs/Consent.md)
   - [CreateBoletoPaymentRequest](docs/CreateBoletoPaymentRequest.md)
   - [CreateBulkPayment](docs/CreateBulkPayment.md)
   - [CreateClientCategoryRule](docs/CreateClientCategoryRule.md)
   - [CreateItem](docs/CreateItem.md)
   - [CreateItemParameters](docs/CreateItemParameters.md)
   - [CreateOrUpdatePaymentCustomer](docs/CreateOrUpdatePaymentCustomer.md)
   - [CreatePaymentCustomerRequestBody](docs/CreatePaymentCustomerRequestBody.md)
   - [CreatePaymentIntent](docs/CreatePaymentIntent.md)
   - [CreatePaymentRecipient](docs/CreatePaymentRecipient.md)
   - [CreatePaymentRequest](docs/CreatePaymentRequest.md)
   - [CreatePaymentRequestSchedule](docs/CreatePaymentRequestSchedule.md)
   - [CreatePixQrPaymentRequest](docs/CreatePixQrPaymentRequest.md)
   - [CreateSmartAccountRequest](docs/CreateSmartAccountRequest.md)
   - [CreateSmartAccountTransferRequest](docs/CreateSmartAccountTransferRequest.md)
   - [CreateSmartTransferPayment](docs/CreateSmartTransferPayment.md)
   - [CreateSmartTransferPreauthorization](docs/CreateSmartTransferPreauthorization.md)
   - [CreateWebhook](docs/CreateWebhook.md)
   - [CredentialSelectOption](docs/CredentialSelectOption.md)
   - [CreditCardMetadata](docs/CreditCardMetadata.md)
   - [CreditData](docs/CreditData.md)
   - [DAILY](docs/DAILY.md)
   - [Document](docs/Document.md)
   - [Email](docs/Email.md)
   - [GlobalErrorResponse](docs/GlobalErrorResponse.md)
   - [ICountResponse](docs/ICountResponse.md)
   - [IdentityRelation](docs/IdentityRelation.md)
   - [IdentityResponse](docs/IdentityResponse.md)
   - [IdentityResponseFinancialRelationships](docs/IdentityResponseFinancialRelationships.md)
   - [IdentityResponseFinancialRelationshipsAccountsInner](docs/IdentityResponseFinancialRelationshipsAccountsInner.md)
   - [IdentityResponseFinancialRelationshipsProcuratorsInner](docs/IdentityResponseFinancialRelationshipsProcuratorsInner.md)
   - [IdentityResponseQualifications](docs/IdentityResponseQualifications.md)
   - [IdentityResponseQualificationsInformedIncome](docs/IdentityResponseQualificationsInformedIncome.md)
   - [IdentityResponseQualificationsInformedPatrimony](docs/IdentityResponseQualificationsInformedPatrimony.md)
   - [Investment](docs/Investment.md)
   - [InvestmentExpenses](docs/InvestmentExpenses.md)
   - [InvestmentMetadata](docs/InvestmentMetadata.md)
   - [InvestmentTransaction](docs/InvestmentTransaction.md)
   - [InvestmentsList200Response](docs/InvestmentsList200Response.md)
   - [Item](docs/Item.md)
   - [ItemCreationErrorResponse](docs/ItemCreationErrorResponse.md)
   - [ItemError](docs/ItemError.md)
   - [ItemOptions](docs/ItemOptions.md)
   - [Loan](docs/Loan.md)
   - [LoanContractedFee](docs/LoanContractedFee.md)
   - [LoanContractedFinanceCharge](docs/LoanContractedFinanceCharge.md)
   - [LoanInstallmentBalloonPayment](docs/LoanInstallmentBalloonPayment.md)
   - [LoanInstallmentBalloonPaymentAmount](docs/LoanInstallmentBalloonPaymentAmount.md)
   - [LoanInstallments](docs/LoanInstallments.md)
   - [LoanInterestRate](docs/LoanInterestRate.md)
   - [LoanPaymentRelease](docs/LoanPaymentRelease.md)
   - [LoanPaymentReleaseOverParcel](docs/LoanPaymentReleaseOverParcel.md)
   - [LoanPaymentReleaseOverParcelCharge](docs/LoanPaymentReleaseOverParcelCharge.md)
   - [LoanPaymentReleaseOverParcelFee](docs/LoanPaymentReleaseOverParcelFee.md)
   - [LoanPayments](docs/LoanPayments.md)
   - [LoanWarranty](docs/LoanWarranty.md)
   - [LoansList200Response](docs/LoansList200Response.md)
   - [MONTHLY](docs/MONTHLY.md)
   - [Merchant](docs/Merchant.md)
   - [NotAuthenticatedResponse](docs/NotAuthenticatedResponse.md)
   - [PageResponseCategoryRules](docs/PageResponseCategoryRules.md)
   - [PageResponseConsents](docs/PageResponseConsents.md)
   - [PageResponseInvestmentTransactions](docs/PageResponseInvestmentTransactions.md)
   - [PageResponseTransactions](docs/PageResponseTransactions.md)
   - [ParameterValidationError](docs/ParameterValidationError.md)
   - [ParameterValidationResponse](docs/ParameterValidationResponse.md)
   - [PaymentCustomer](docs/PaymentCustomer.md)
   - [PaymentCustomersList200Response](docs/PaymentCustomersList200Response.md)
   - [PaymentData](docs/PaymentData.md)
   - [PaymentDataBoletoMetadata](docs/PaymentDataBoletoMetadata.md)
   - [PaymentDataParticipant](docs/PaymentDataParticipant.md)
   - [PaymentInstitution](docs/PaymentInstitution.md)
   - [PaymentIntent](docs/PaymentIntent.md)
   - [PaymentIntentParameter](docs/PaymentIntentParameter.md)
   - [PaymentIntentsList200Response](docs/PaymentIntentsList200Response.md)
   - [PaymentReceipt](docs/PaymentReceipt.md)
   - [PaymentReceiptBankAccount](docs/PaymentReceiptBankAccount.md)
   - [PaymentReceiptPerson](docs/PaymentReceiptPerson.md)
   - [PaymentRecipient](docs/PaymentRecipient.md)
   - [PaymentRecipientAccount](docs/PaymentRecipientAccount.md)
   - [PaymentRecipientsInstitutionList200Response](docs/PaymentRecipientsInstitutionList200Response.md)
   - [PaymentRecipientsList200Response](docs/PaymentRecipientsList200Response.md)
   - [PaymentRequest](docs/PaymentRequest.md)
   - [PaymentRequestCallbackUrls](docs/PaymentRequestCallbackUrls.md)
   - [PaymentRequestReceiptList200Response](docs/PaymentRequestReceiptList200Response.md)
   - [PaymentRequestSchedule](docs/PaymentRequestSchedule.md)
   - [PaymentRequestsList200Response](docs/PaymentRequestsList200Response.md)
   - [PaymentSchedulesList200Response](docs/PaymentSchedulesList200Response.md)
   - [PhoneNumber](docs/PhoneNumber.md)
   - [PixData](docs/PixData.md)
   - [SINGLE](docs/SINGLE.md)
   - [SchedulePayment](docs/SchedulePayment.md)
   - [SmartAccount](docs/SmartAccount.md)
   - [SmartAccountAddress](docs/SmartAccountAddress.md)
   - [SmartAccountBalance](docs/SmartAccountBalance.md)
   - [SmartAccountTransfer](docs/SmartAccountTransfer.md)
   - [SmartAccountsList200Response](docs/SmartAccountsList200Response.md)
   - [SmartTranfersPreauthorizationsList200Response](docs/SmartTranfersPreauthorizationsList200Response.md)
   - [SmartTransferCallbackUrls](docs/SmartTransferCallbackUrls.md)
   - [SmartTransferPayment](docs/SmartTransferPayment.md)
   - [SmartTransferPreauthorization](docs/SmartTransferPreauthorization.md)
   - [SmartTransferPreauthorizationParameter](docs/SmartTransferPreauthorizationParameter.md)
   - [StatusDetail](docs/StatusDetail.md)
   - [StatusDetailProduct](docs/StatusDetailProduct.md)
   - [StatusDetailProductWarning](docs/StatusDetailProductWarning.md)
   - [Transaction](docs/Transaction.md)
   - [UpdateItem](docs/UpdateItem.md)
   - [UpdateItemParameters](docs/UpdateItemParameters.md)
   - [UpdatePaymentRecipient](docs/UpdatePaymentRecipient.md)
   - [UpdatePaymentRequest](docs/UpdatePaymentRequest.md)
   - [UpdateTransaction](docs/UpdateTransaction.md)
   - [WEEKLY](docs/WEEKLY.md)
   - [Webhook](docs/Webhook.md)
   - [WebhookCreationErrorResponse](docs/WebhookCreationErrorResponse.md)
   - [WebhooksList200Response](docs/WebhooksList200Response.md)
  <a id="documentation-for-authorization"></a>

  Authentication schemes defined for the API:
  <a id="default"></a>

  - **Type**: API key
  - **API key parameter name**: X-API-KEY
  - **Location**: HTTP header

  hello@pluggy.ai


pkgId: edf5870c822febf463425f89425083e9064174c2f4555df4a40139bbcc0d15c6
name: python-plz2nuts-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for plz2nuts
url: https://pypi.org/project/plz2nuts/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-plz2nuts-0.1.8-1.src.rpm
location_href: Packages/python-plz2nuts-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  This is a tool to convert a German Postleitzahl (zip code) to the coresponding NUTS IDs.
  It takes 1-5 digits of the zip code as an input.


  To install the tool, use the following command:
  ```
  pip install plz2nuts
  ```


  To use the tool, follow these steps:
  1. **Command Line Interface (CLI):** You can use the tool from the command line by running:
     ```sh
     plz2nuts --help
     ```
     This will display the available options and how to use them.

  2. **Basic Usage:** To convert a Postleitzahl to a NUTS ID, use:
     ```sh
     plz2nuts <postleitzahl>
     ```
     Replace `<postleitzahl>` with the actual Postleitzahl you want to convert.

  3. **Import in Python:** You can also import the tool in your Python code to get a NUTS ID for a plz:
     ```python
     from plz_to_nuts import convert_plz_to_nuts
     convert_plz_to_nuts('10')
     ```



  This project is licensed under the AGPL-3.0-or-later license. See LICENSES/AGPL-3.0-or-later.txt for details.

rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>  Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU Affero General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.  You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <http://www.gnu.org/licenses/>.


pkgId: de6d5c88399a7be8cded92832cb6a3626a845f71467c5e6dcfd567c137bdf6d4
name: python-pod5Viewer-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for pod5Viewer
url: https://github.com/dietvin/pod5Viewer
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pod5Viewer-1.1.2-1.src.rpm
location_href: Packages/python-pod5Viewer-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Alternatively, the pod5Viewer can be installed from source:
  ```bash
  git clone https://github.com/dietvin/pod5Viewer.git
  cd pod5Viewer
  pip install .
  ```

  The pod5Viewer is built in Python (v3.10.0) and relies on the following packages:
  - numpy (v1.26.4)
  - pod5 (v0.3.10)
  - pyside6 (v6.5.2)
  - matplotlib (v3.9.2)
  The compliation for Windows was performed using the pyinstaller (v6.8.0) and the Windows installer was created using the Inno Setup Compiler (v6.3.1).

  ![overview](./images/pod5Viewer_overview.png)

  In the pod5Viewer open files from the menu bar in the top via `File > Open file(s)...` (individual file(s)) or `File > Open directory` (all files in a directory). All opened files are shown in the left panel. Expanding an entry shows all reads in a given file by their read ID. Opened files and reads can be sorted alphabetically in ascending or descending order using the respective buttons above the panel. Specific read IDs can be searched using the search bar. Typing a search query updates the panel to show fitting reads in real-time. The button next to the search bar clears a given search query.
  A single click on a read ID opens the entry as a preview (i.e. it gets overwritten once another entry is selected). A double click opens it permanently, so multiple reads can be opened at the same time. Tabs can be closed via the `X` symbol. A tab shows all attributes stored in a pod5 file as key-value pairs. Nested information can be expanded. Values can be selected via double-click and copied to the clipboard.
  Opened files and reads can be cleared from the window through `File > Clear`. To exit the app use  `File > Exit`.
  ![file navigation](./images/pod5viewer_file_navigator.gif)

  To enable the user to focus on a specific subset of reads in given POD5 files, reads can be filtered to a subset. To activate this feature navigate to `File > Filter reads...`. This opens a new window containing a text browser, in which read IDs can be inserted. Here one read ID must be given per line. Alternatively, read IDs can be loaded from a text file, again containing one read ID per line. Press the `Load IDs from file...` button to select a file for filtering. After loading, the contents of the file are shown in the text browser. Press `Done` to submit given read IDs for filtering. Afterwards, only reads that are found in the given set are shown.
  To clear the subset, reopen the window, press `Clear` and `Done`. Afterwards all read IDs are shown again.
  ![read filter](./images/pod5Viewer_read_filter.gif)

  Individual current measurement can be inspected via `View > View signal`. This shows the current values in chunks. Use the scroll bar to scroll through chunks.
  ![read filter](./images/pod5Viewer_view_data.png)

  To plot the current measurements select `View > Plot signal...`, `View > Plot pA signal...`. Signals can be plotted for a single read (`Focussed read...`) or all opened reads (`All open reads...`). When selecting a option, a new window open showing the selected data as a line plot. The window contains the figure itself in the upper-left section, the legend containing each shown read ID in the upper-right section and a navigation section in the lower part of the window.
  The navigation section shows a rough map of the whole figure and allows for selection of specific intervals. The user can select an interval by pressing on the start coordinate in the navigation map and dragging the cursor to the wanted end coordinate. When releasing the mouse button, the figure gets updated to show the new interval. For more fine-tuned zooming, two input fields are given below the map. In these the user can type a start and end value and press `Zoom` to focus on the provided interval specifically. Zooming can be resetted via the `Reset zoom` button. This restores the plot to the initial state.
  When multiple signals are shown, individual ones can be hidden/shown by unchecking/checking the corresponding checkbox in the legend.
  To switch to plotting the normalized signals select `Data > Show normalized data` in the menu. To revert back to the non-normalized signals, press `Data > Show data`.
  The current view can be exported to a vector graphic (SVG) by pressing `Export > Export current view...`. This opens a file browser where an export path can be selected.
  For faster performance and responsiveness of the window, long signals are subset to a maximum of 10000 measurements per signal at any given point. When subsetting, the data is split into 10000 bins, for each of which the median value is calculated. The label above the navigation section indicates whether subsetting is performed in the section that is currently shown, and if so how many measurements are contained in one bin. This way, the resolution of the shown data increases dynamically with higher zoom levels, providing the best performance with the least amount of information loss.
  ![file navigation](./images/pod5viewer_plot_data.gif)

  Either all opened reads (`All opened reads...`) or only the currently focused one (`Current read...`) can be exported to JSON format using `File > Export all info`. When exporting, the user selects an output file or directory in the file browser, where a JSON file is created for each exported read with the read-id as the file name.
  The measurements of a read can be exported isolated from the remaining data of a given read through the `Export signal` menu. The values can be exported to a `.npy` Numpy file for further processing in a `Numpy` environment. Alternatively, they can be written to a text file, where each line contains one measurement.

  Various keyboard shortcuts are available, allowing for all actions to be performed without a mouse. The following shortcuts are implemented:
  - Ctrl+O: Open file(s)
  - Ctrl+D: Open directory
  - Ctrl+S: Export current read
  - Ctrl+A: Export all opened reads
  - Ctrl+Backspace: Clear viewer
  - Ctrl+Q: Exit application
  Navigation:
  - Tab: Switch between file navigator and data viewer
  - Ctrl+Tab: Cycle through tabs in the data viewer
  - Ctrl+W: Close the current tab in the data viewer
  Menu navigation:
  - Alt & F: Open the file menu
  - Alt & V: Open the view menu
  - Alt & H: Open the help menu
  View signal window:
  - Pagedown: Scroll down (large steps)
  - Pageup: Scroll up (large steps)
  - Arrow down: Scroll down
  - Arrow up: Scroll up

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

  DOI: [https://doi.org/10.1093/bioinformatics/btae665](https://doi.org/10.1093/bioinformatics/btae665)
  If you use this tool in your work, we would be really happy if you cite us:
  ```
  @article{10.1093/bioinformatics/btae665,
      author = {Dietrich, Vincent and Alagna, Nicolò and Helm, Mark and Gerber, Susanne and Butto, Tamer},
      title = {Pod5Viewer: a GUI for inspecting raw nanopore sequencing data},
      journal = {Bioinformatics},
      pages = {btae665},
      year = {2024},
      month = {12},
      issn = {1367-4811},
      doi = {10.1093/bioinformatics/btae665},
      url = {https://doi.org/10.1093/bioinformatics/btae665},
      eprint = {https://academic.oup.com/bioinformatics/article/40/12/btae665/7915477},
  }
  ```


pkgId: 96af078117b00a7ced49f6776c27f4e76adb66234272d6df7495b5bd61ba3cd0
name: python-podonos-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for podonos
url: https://www.podonos.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-podonos-0.4.0-1.src.rpm
location_href: Packages/python-podonos-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  Visit [https://www.podonos.com](https://www.podonos.com), log in or sign up, and get an API key.
  For more details, see [Docs](https://www.podonos.com/docs/apikey)


  First of all, make sure you have installed Python 3.8 or newer

  ```bash
  python --version
  ```

  Once you confirm your Python version, install the package:

  ```bash
  pip install podonos
  ```


  ```python
  import podonos
  from podonos import *

  client = podonos.init(api_key="<YOUR_API_KEY_HERE>")
  etor = client.create_evaluator()
  for i in script_list:
    gen_audio = my_model.generate_and_save(i, script_list[i], f'/a/b/{i}.wav')
    etor.add_file(file=File(path=f'/a/b/{i}.wav', model_tag="my_new_model",
                            tags=["syn1", "male", "American"]))
  etor.close()
  ```
  Once we evaluate the audio files, we will email you the evaluation report within 12 hours.



  Run this at the base directory:
  ```bash
  pytest
  ```



  For a deeper dive on all capabilities and details, please refer to [Documentation](https://www.podonos.com/docs).


  [MIT License](https://github.com/podonos/podonos-pysdk/blob/main/LICENSE)

rpm_license:
  MIT License  Copyright (c) 2024 Podonos  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: e613629c029779c1d7b3878845840d742f31c73ce426826c64439c8b124ee7bf
name: python-poemai-utils-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for poemai-utils
url: https://github.com/poemAI-ch/poemai-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poemai-utils-1.6.0-1.src.rpm
location_href: Packages/python-poemai-utils-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  This package is a collection of utilities for AI projects.

  See [`FILES.md`](./FILES.md) for a description of the files in this project.


pkgId: b3f45c97f09fe19b46259e10d805f2f3155656f3b154cfe337b8d9f3138eaf49
name: python-poetry-monoranger-plugin-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for poetry-monoranger-plugin
url: https://github.com/ag14774/poetry-monoranger-plugin
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poetry-monoranger-plugin-0.2.0-1.src.rpm
location_href: Packages/python-poetry-monoranger-plugin-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/poetry-monoranger-plugin)
  ![GitHub License](https://img.shields.io/github/license/ag14774/poetry-monoranger-plugin)
  [![Tests](https://github.com/ag14774/poetry-monoranger-plugin/actions/workflows/main.yml/badge.svg)](https://github.com/ag14774/poetry-monoranger-plugin/actions/workflows/main.yml)

  **Monoranger** is a plugin for [Poetry](https://python-poetry.org/) that helps you manage your monorepo.

  **Main Features**:
  - Shared `poetry.lock` file across multiple projects in a monorepo
  - Shared virtual environment across multiple projects in a monorepo
  - Rewrite path dependencies during `poetry build`



  ```bash
  poetry self add poetry-monoranger-plugin
  ```




  The plugin is generally flexible when it comes to the structure of the repository. However, it is expected that each project will have its own `pyproject.toml` file and that the root of the repository will also have a central `pyproject.toml` file including all projects as a path dependency.
  ```
  monorepo/
  ├── library-one/
  │   ├── pyproject.toml
  │   └── library_one/
  ├── library-two/
  │   ├── pyproject.toml
  │   └── library_two/
  ├── poetry.lock
  └── pyproject.toml
  ```

  The root `pyproject.toml` file should include all projects as a path dependency:
  ```toml

  [tool.poetry.dependencies]
  python = "^3.9"
  library-one = { path = "library-one", develop = true }
  library-two = { path = "library-two", develop = true }

  ```

  Each project's `pyproject.toml` file should include the dependencies it needs (including path dependencies to other projects) as well as enabling the plugin:
  ```toml

  [tool.poetry.dependencies]
  python = "^3.9"
  numpy = "^1.21.0"
  library-two = { path = "../library-two", develop = true }

  [tool.poetry-monoranger-plugin]
  enabled = true
  monorepo-root = "../"
  version-rewrite-rule = '=='  # Choose between "==", "~", "^", ">=,<"

  ```
  The plugin by default is disabled in order to avoid having undesired consequences on other projects (as plugins are installed globally). To enable it, set `enabled = true` in each project's `pyproject.toml` file.


  The plugin modifies the following commands:

  - `poetry lock`:

  Ensures that the shared lock file (located at the root) is up-to-date irrespective of the directory from which the command is run. This is convenient since it avoids accidentally creating a per-project lock file when running from within a project directory. It also eliminated the need to switch to the root directory to update the lock file.

  - `poetry install`:

  Installs dependencies for all projects in the monorepo, ensuring that the shared virtual environment is used. As before, this command can be run from any directory within the monorepo without needing to switch to the root directory.

  - `poetry update`:

  Updates the provided dependency (or all dependencies of **current** project if none provided). This will update the shared lock file as well as installing the updated dependencies in the shared virtual environment.

  - `poetry add`:

  Adds a new dependency to the `pyproject.toml` of the **current** project, updates the shared lock file, and installs the new dependency in the shared virtual environment. This is equivalent to manually modifying a project's `pyproject.toml` file, followed by running `poetry lock` and `poetry install` from the root directory.

  - `poetry remove`:

  Removes a dependency from the specified project, updates the shared lockfile, and removes the dependency from the shared virtual environment if it is no longer required by any other project.

  - `poetry build`:

  Builds the **current** project, replacing editable path dependencies with the current version of the package. This is useful when building a project that depends on another project in the monorepo, as it ensures that the built package can be installed (e.g. as a wheel file) without expecting the other project to be present in a specific location.



  The plugin can be configured in the `pyproject.toml` file of each project. The following options are available:

  - `enabled` (bool): Whether the plugin is enabled for the current project. Default: `false`
  - `monorepo-root` (str): The path to the root of the monorepo. Default: `../`
  - `version-rewrite-rule` (str): The version rewrite rule to apply when building the project. Default: `==`


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


pkgId: e37f97ec92bcaaa57c21facd0bf7e68d0a7293960f9552110626153f284baf99
name: python-poetry-plugin-freeze-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for poetry-plugin-freeze
url: https://github.com/cloud-custodian/poetry-plugin-freeze
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poetry-plugin-freeze-1.1.0-1.src.rpm
location_href: Packages/python-poetry-plugin-freeze-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Poetry plugin for creating frozen wheels using lockfiles.



  A common issue when publishing a Python application's release into PyPI, is whether or not the dependencies specified will continue to work over time. This tends to happen due to a confluence of reasons, poor dependency specification, bad observance of semantic versioning, or poor release management by the dependency. That translates to a reality where installing an older release of the application is unlikely to work, due to changes in the underlying dependency graph.

  The dependency ecosystem is both complex and fragile. The emergence of lock files to ensure repeatability is testimony both to the problem and one solution. Yet when we go to publish in the packaging ecosystem we do so with non frozen dependencies specifications not with lockfiles. That means the testing pipelines that goes to produce and validate a release is against a lockfile but the release artifact is divorced of the lockfile contents, and starts to diverge from the moment of publication.

  The various language package distribution channels (npm, pypi, rubygems, etc) are used for two different primary distribution purposes, for both libraries and applications. Generally speaking the extant behavior is reasonable for a library. Libraries should be relatively liberal on their own dependencies baring perhaps major versions to minimize conflicts for applications depending on them and ideally consist of minimal dependencies graphs. But for applications distribution, repeatable and verifyable installs are fundamental goals with potentially large dependency graphs. Using a frozen dependency graph versus version specifications is the only way to ensure repeatiblity of installation over time. Fundamentally the two different distribution purposes have different audiences, ie.  libraries have developers and applications as consumers, applications have users as consumers.



  A post build / pre publish command to allow for creating wheels with frozen dependencies. Basically we update wheel metadata for Requires-Dist to replace the pyproject.toml based version specification to a frozen (ie. ==version) one based on the version from the poetry lock information.


  Note we can't use poetry to publish because the frozen wheel because it uses metadata from pyproject.toml instead
  of frozen wheel metadata.



  Frozen wheel metadata will contain [Provides-Extra](https://packaging.python.org/en/latest/specifications/core-metadata/#provides-extra-multiple-use) entries for any [extra / optional dependencies](https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#dependencies-optional-dependencies). Frozen [Requires-Dist](https://packaging.python.org/en/latest/specifications/core-metadata/#core-metadata-requires-dist) lines will specify `extra` names _for packages that appear only in the optional/extra dependency graph.

  If a package appears as both a nested "main" dependency and also as an "extra" dependency, its `Requires-Dist` entry in the frozen wheel _will not_ specify an extra name.

  To define this behavior in relation to poetry's [export plugin](https://github.com/python-poetry/poetry-plugin-export/), these two flows should result in the same installed package set:

  ```console

  poetry export -f requirements.txt > requirements.txt && pip install -r requirements.txt


  poetry build && poetry freeze-wheel && pip install my_frozen_wheel
  ```

  And introducing extras:

  ```console

  poetry export --extras gcp -f requirements.txt && pip install -r requirements.txt


  poetry build && poetry freeze-wheel && pip install my_frozen_wheel[gcp]
  ```

  The difference is in when to choose which extras to install - `export` does that at freeze time. `freeze-wheel` embeds the extra _context_ at freeze time, but defers the actual extra selection until install time.



  ```shell

  poetry self add poetry-plugin-freeze


  poetry build


  poetry freeze-wheel


  poetry freeze-wheel --exclude boto3 -e attrs





  twine upload dist/*.whl
  ```



  To support mono repos consisting of multiple libraries/applications, when creating a frozen wheel, main group dependencies specified by path can be optionally substituted out for references to their release artifact versions.

  This assumes automation to run build and publish across the various subpackages, ie typically via make or just.


pkgId: 90f758d5d4f75dec31b13d495197a03b341ffa22432f66e5287835ddac665213
name: python-poincare-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for poincare
url: https://github.com/maurosilber/poincare
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poincare-0.6.1-1.src.rpm
location_href: Packages/python-poincare-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  ![PyVersion](https://img.shields.io/pypi/pyversions/poincare?label=python)
  ![Package](https://img.shields.io/pypi/v/poincare?label=PyPI)
  ![Conda Version](https://img.shields.io/conda/vn/conda-forge/poincare)
  ![License](https://img.shields.io/pypi/l/poincare?label=license)
  [![CI](https://github.com/maurosilber/poincare/actions/workflows/ci.yml/badge.svg)](https://github.com/maurosilber/poincare/actions/workflows/ci.yml)
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/maurosilber/poincare/main.svg)](https://results.pre-commit.ci/latest/github/maurosilber/poincare/main)



  Poincaré allows to define and simulate dynamical systems in Python.



  To define the system

  $$ \\frac{dx}{dt} = -x \\quad \\text{with} \\quad x(0) = 1 $$

  we can write:

  ```python
  >>> from poincare import Variable, System, initial
  >>> class Model(System):
  ...   # Define a variable with name `x` with an initial value (t=0) of `1``.
  ...   x: Variable = initial(default=1)
  ...   # The rate of change of `x` (i.e. velocity) is assigned (<<) to `-x`.
  ...   # This relation is assigned to a Python variable (`eq`)
  ...   eq = x.derive() << -x
  ...
  ```



  To simulate that system:

  ```python
  >>> from poincare import Simulator
  >>> sim = Simulator(Model)
  >>> sim.solve(save_at=range(3))
               x
  time
  0     1.000000
  1     0.368139
  2     0.135501
  ```

  The output is a `pandas.DataFrame`,
  which can be plotted with `.plot()`.



  To change the initial condition,
  we can pass a dictionary to the `solve` method:

  ```python
  >>> sim.solve(values={Model.x: 2}, save_at=range(3))
               x
  time
  0     2.000000
  1     0.736278
  2     0.271002
  ```



  We can compute transformations of the output
  by passing a dictionary of expressions:

  ```python
  >>> Simulator(Model, transform={"x": Model.x, "2x": 2 * Model.x}).solve(save_at=range(3))
               x        2x
  time
  0     1.000000  2.000000
  1     0.368139  0.736278
  2     0.135501  0.271002
  ```



  To define a higher-order system,
  we have to assign an initial condition to the derivative of a variable:

  ```python
  >>> from poincare import Derivative
  >>> class Oscillator(System):
  ...   x: Variable = initial(default=1)
  ...   v: Derivative = x.derive(initial=0)
  ...   eq = v.derive() << -x
  ...
  >>> Simulator(Oscillator).solve(save_at=range(3))
               x         v
  time
  0     1.000000  0.000000
  1     0.540366 -0.841561
  2    -0.416308 -0.909791
  ```



  To use the independent variable,
  we create an instance of `Independent`:

  ```python
  >>> from poincare import Independent
  >>> class NonAutonomous(System):
  ...   time = Independent()
  ...   x: Variable = initial(default=0)
  ...   eq = x.derive() << 2 * time
  ...
  >>> Simulator(NonAutonomous).solve(save_at=range(3))
               x
  time
  0     0.000000
  1     1.000001
  2     4.000001
  ```



  Besides variables,
  we can define parameters and constants,
  and use functions from [symbolite](https://github.com/hgrecco/symbolite).



  Constants allow to define common initial conditions for Variables and Derivatives:

  ```python
  >>> from poincare import assign, Constant
  >>> class Model(System):
  ...     c: Constant = assign(default=1, constant=True)
  ...     x: Variable = initial(default=c)
  ...     y: Variable = initial(default=2 * c)
  ...     eq_x = x.derive() << -x
  ...     eq_y = y.derive() << -y
  ...
  >>> Simulator(Model).solve(save_at=range(3))
               x         y
  time
  0     1.000000  2.000000
  1     0.368139  0.736278
  2     0.135501  0.271002
  ```

  Now, we can vary their initial conditions jointly:

  ```python
  >>> Simulator(Model).solve(values={Model.c: 2}, save_at=range(3))
               x         y
  time
  0     2.000000  4.000000
  1     0.736278  1.472556
  2     0.271001  0.542003
  ```

  But we can break that connection by passing `y`'s initial value directly:

  ```python
  >>> Simulator(Model).solve(values={Model.c: 2, Model.y: 2}, save_at=range(3))
               x         y
  time
  0     2.000000  2.000000
  1     0.736278  0.736278
  2     0.271002  0.271002
  ```



  Parameters are like Variables,
  but their time evolution is given directly as a function of time,
  Variables, Constants and other Parameters:

  ```python
  >>> from poincare import Parameter
  >>> class Model(System):
  ...     p: Parameter = assign(default=1)
  ...     x: Variable = initial(default=1)
  ...     eq = x.derive() << -p * x
  ...
  >>> Simulator(Model).solve(save_at=range(3))
               x
  time
  0     1.000000
  1     0.368139
  2     0.135501
  ```



  Symbolite functions are accessible from the `symbolite.scalar` module:

  ```python
  >>> from symbolite import scalar
  >>> class Model(System):
  ...     x: Variable = initial(default=1)
  ...     eq = x.derive() << scalar.sin(x)
  ...
  >>> Simulator(Model).solve(save_at=range(3))
               x
  time
  0     1.000000
  1     1.951464
  2     2.654572
  ```



  poincaré also supports functions through
  [`pint`](https://github.com/hgrecco/pint)
  and [`pint-pandas`](https://github.com/hgrecco/pint-pandas).

  ```python
  >>> import pint
  >>> unit = pint.get_application_registry()
  >>> class Model(System):
  ...     x: Variable = initial(default=1 * unit.m)
  ...     v: Derivative = x.derive(initial=0 * unit.m/unit.s)
  ...     w: Parameter = assign(default=1 * unit.Hz)
  ...     eq = v.derive() << -w**2 * x
  ...
  >>> result = Simulator(Model).solve(save_at=range(3))
  ```

  The columns have units of `m` and `m/s`, respectively.
  `pint` raises a `DimensionalityError` if we try to add them:

  ```python
  >>> result["x"] + result["v"]
  Traceback (most recent call last):
  ...
  pint.errors.DimensionalityError: Cannot convert from 'meter' ([length]) to 'meter / second' ([length] / [time])
  ```

  We can remove the units and set them as string metadata with:

  ```python
  >>> result.pint.dequantify()
               x              v
  unit     meter meter / second
  time
  0          1.0            0.0
  1     0.540366      -0.841561
  2    -0.416308      -0.909791
  ```

  which allows to plot the DataFrame with `.plot()`.



  It can be installed from PyPI:

  ```
  pip install -U poincare
  ```

  or conda-forge:

  ```
  conda install -c conda-forge poincare
  ```



  This project is managed by [pixi](https://pixi.sh).
  You can install it for development using:

  ```sh
  git clone https://github.com/{{ github_username }}/{{ project_name }}
  cd {{ project_name }}
  pixi run pre-commit-install
  ```

  Pre-commit hooks are used to lint and format the project.



  Run tests using:

  ```sh
  pixi run test
  ```


pkgId: 39cf589fc3812e22785d580e4a00fc3c1c5682a05322d9f1e6c6d6bc7e54c0d8
name: python-pointblank-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for pointblank
url: https://pypi.org/project/pointblank/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pointblank-0.2.0-1.src.rpm
location_href: Packages/python-pointblank-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="images/pointblank_logo.svg" alt="Pointblank logo" width="350px"/>

  _Find out if your data is what you think it is._

  [![Python Versions](https://img.shields.io/pypi/pyversions/pointblank.svg)](https://pypi.python.org/pypi/pointblank)
  [![PyPI](https://img.shields.io/pypi/v/pointblank)](https://pypi.org/project/pointblank/#history)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/pointblank)](https://pypistats.org/packages/pointblank)
  [![License](https://img.shields.io/github/license/rich-iannone/pointblank)](https://img.shields.io/github/license/rich-iannone/pointblank)

  [![CI Build](https://github.com/rich-iannone/pointblank/actions/workflows/ci-tests.yaml/badge.svg)](https://github.com/rich-iannone/pointblank/actions/workflows/ci-tests.yaml)
  [![Codecov branch](https://img.shields.io/codecov/c/github/rich-iannone/pointblank/main.svg)](https://codecov.io/gh/rich-iannone/pointblank)
  [![Repo Status](https://www.repostatus.org/badges/latest/active.svg)](https://www.repostatus.org/#active)
  [![Documentation](https://img.shields.io/badge/docs-project_website-blue.svg)](https://rich-iannone.github.io/pointblank/)

  [![Contributors](https://img.shields.io/github/contributors/rich-iannone/pointblank)](https://github.com/rich-iannone/pointblank/graphs/contributors)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.1%20adopted-ff69b4.svg)](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html)

  </div>

  Pointblank is a table validation and testing library for Python. It helps you ensure that your tabular data meets certain expectations and constraints and it presents the results in a beautiful (and useful!) validation table.



  Let's take a Polars DataFrame and validate it against a set of constraints. We do that by using the `pb.Validate` class and then adding validation steps:

  ```python
  import pointblank as pb

  validation = (
      pb.Validate(data=pb.load_dataset(dataset="small_table")) # Use pb.Validate to start
      .col_vals_gt(columns="d", value=100)       # STEP 1 |
      .col_vals_le(columns="c", value=5)         # STEP 2 | <-- Build up a validation plan
      .col_exists(columns=["date", "date_time"]) # STEP 3 |
      .interrogate() # This will execute all validation steps and collect intel
  )

  validation
  ```

  <img src="images/pointblank-tabular-report.png" alt="Validation Report">

  The rows in the reporting table correspond to each of the validation steps. One of the key concepts is that validation steps can be broken down into atomic test units and each of these is given either of pass/fail status based on the validation constraints. You'll see these tallied up in the reporting table (in the `"UNITS"`, `"PASS"`, and `"FAIL"` columns).

  The reporting through a display table is just one way to see the results. You can get fine-grained results of the interrogation in other ways. You can also utilize the validation results by filtering the input table based on row-level pass/fail status (via the `get_sundered_data()` method).

  On the input side, we can use the following table sources:

  - Polars DataFrame
  - Pandas DataFrame
  - DuckDB table
  - MySQL table
  - PostgreSQL table
  - SQLite table
  - Parquet

  We use [Narwhals](https://github.com/narwhals-dev/narwhals) to internally handle Polars and Pandas DataFrames. We integrate with [Ibis](https://github.com/ibis-project/ibis) to enable the use of DuckDB, MySQL, PostgreSQL, SQLite, and Parquet. In doing all of this, we can provide an ergonomic and consistent API for validating tabular data from a variety of tabular data sources.



  Here's a short list of what we think makes pointblank a great tool for data validation:

  - **Declarative Syntax**: Define your data validation rules simply, using a declarative syntax
  - **Flexible**: We support tables from Polars, Pandas, Duckdb, MySQL, PostgreSQL, SQLite, and Parquet
  - **Beautiful Reports**: Generate beautiful HTML table reports on how the data validation went down
  - **Functional Output**: Extract the specific data validation outputs you need for further processing
  - **Data Testing**: Write tests for your data and use them in your notebooks or testing framework
  - **Easy to Use**: Get started quickly with a simple API and super clear documentation
  - **Powerful**: You can develop complex data validation rules with flexible options for customization



  You can install pointblank using pip:

  ```bash
  pip install pointblank
  ```

  If you encounter a bug, have usage questions, or want to share ideas to make this package better, please feel free to file an [issue](https://github.com/rich-iannone/pointblank/issues).



  Please note that the pointblank project is released with a [contributor code of conduct](https://www.contributor-covenant.org/version/2/1/code_of_conduct/).<br>By participating in this project you agree to abide by its terms.



  There are many ways to contribute to the ongoing development of pointblank. Some contributions can be simple (like fixing typos, improving documentation, filing issues for feature requests or problems, etc.) and others might take more time and care (like answering questions and submitting PRs with code changes). Just know that anything you can do to help would be very much appreciated!

  Please read over the [contributing guidelines](https://github.com/rich-iannone/pointblank/blob/main/CONTRIBUTING.md) for information on how to get started.



  Pointblank is licensed under the MIT license.



  This project is primarily maintained by [Rich Iannone](https://twitter.com/riannone).
  Other authors may occasionally assist with some of these duties.

rpm_license:
  MIT License  Copyright (c) 2024 Richard Iannone  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: a51570480566425e6013fc0b3c69479b60199fd7691572e3ad2934da826ba7cb
name: python-pointtorch-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for pointtorch
url: https://github.com/ai4trees/pointtorch
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pointtorch-0.1.0-1.src.rpm
location_href: Packages/python-pointtorch-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://github.com/ai4trees/pointtorch/blob/main/docs/assets/pointtorch-logo-color.png?raw=true" alt="pointtorch" width="328" height="93">



  ![pypi-image](https://badge.fury.io/py/pointtorch.svg)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![CI](https://github.com/ai4trees/pointtorch/actions/workflows/code-quality-main.yml/badge.svg)](https://github.com/ai4trees/pointtorch/actions/workflows/code-quality-main.yml)
  [![coverage](https://codecov.io/gh/ai4trees/pointtorch/branch/main/graph/badge.svg)](https://codecov.io/github/ai4trees/pointtorch?branch=main)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pointtorch)



  The documentation of our package is available [here](https://ai4trees.github.io/pointtorch/stable).



  The setup of our package is described in the [documentation](https://ai4trees.github.io/pointtorch/stable#get-started).

rpm_license:
  MIT License  Copyright (c) 2024 ai4trees  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: 9d300133a09dd5885f475f289601f86a42bbd666fa7ce01f2add80af52b7a856
name: python-poke-env-help
arch: noarch
version: 0.8.3
epoch: 0
release: 1
summary: Development documents and examples for poke-env
url: https://pypi.org/project/poke-env/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poke-env-0.8.3-1.src.rpm
location_href: Packages/python-poke-env-help-0.8.3-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version fury.io](https://badge.fury.io/py/poke-env.svg)](https://pypi.python.org/pypi/poke-env/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/poke-env.svg)](https://pypi.python.org/pypi/poke-env/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Documentation Status](https://readthedocs.org/projects/poke-env/badge/?version=stable)](https://poke-env.readthedocs.io/en/stable/?badge=stable)
  [![codecov](https://codecov.io/gh/hsahovic/poke-env/branch/master/graph/badge.svg)](https://codecov.io/gh/hsahovic/poke-env)

  A Python interface to create battling pokemon agents. `poke-env` offers an easy-to-use interface for creating rule-based or training Reinforcement Learning bots to battle on [pokemon showdown](https://pokemonshowdown.com/).

  ![A simple agent in action](rl-gif.gif)



  Agents are instance of python classes inheriting from `Player`. Here is what your first agent could look like:

  ```python
  class YourFirstAgent(Player):
      def choose_move(self, battle):
          for move in battle.available_moves:
              if move.base_power > 90:
                  
                  return self.create_order(move)

          
          for switch in battle.available_switches:
              if switch.current_hp_fraction > battle.active_pokemon.current_hp_fraction:
                  
                  return self.create_order(switch)

          
          return self.choose_random_move(battle)
  ```

  To get started, take a look at [our documentation](https://poke-env.readthedocs.io/en/stable/)!




  Documentation, detailed examples and starting code can be found [on readthedocs](https://poke-env.readthedocs.io/en/stable/).




  This project requires python >= 3.9 and a [Pokemon Showdown](https://github.com/Zarel/Pokemon-Showdown) server.

  ```
  pip install poke-env
  ```

  You can use [smogon's server](https://play.pokemonshowdown.com/) to try out your agents against humans, but having a development server is strongly recommended. In particular, it is recommended to use the `--no-security` flag to run a local server with most rate limiting and throttling turned off. Please refer to [the docs](https://poke-env.readthedocs.io/en/stable/getting_started.html#configuring-a-showdown-server) for detailed setup instructions.


  ```
  git clone https://github.com/smogon/pokemon-showdown.git
  cd pokemon-showdown
  npm install
  cp config/config-example.js config/config.js
  node pokemon-showdown start --no-security
  ```



  You can also clone the latest master version with:

  ```
  git clone https://github.com/hsahovic/poke-env.git
  ```

  Dependencies and development dependencies can then be installed with:

  ```
  pip install -r requirements.txt
  pip install -r requirements-dev.txt
  ```



  This project is a follow-up of a group project from an artifical intelligence class at [Ecole Polytechnique](https://www.polytechnique.edu/).

  You can find the original repository [here](https://github.com/hsahovic/inf581-project). It is partially inspired by the [showdown-battle-bot project](https://github.com/Synedh/showdown-battle-bot). Of course, none of these would have been possible without [Pokemon Showdown](https://github.com/Zarel/Pokemon-Showdown).

  Team data comes from [Smogon forums' RMT section](https://www.smogon.com/).



  Data files are adapted version of the `js` data files of [Pokemon Showdown](https://github.com/Zarel/Pokemon-Showdown).


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



  ```bibtex
  @misc{poke_env,
      author       = {Haris Sahovic},
      title        = {Poke-env: pokemon AI in python},
      url          = {https://github.com/hsahovic/poke-env}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2019 hsahovic  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: 03aba10b4b04e71b2b10b056f5a4b813b05c49390b0823f28f3f59cf4d52d5df
name: python-poktroll-clients-help
arch: noarch
version: 0.1.0a1.dev4
epoch: 0
release: 1
summary: Development documents and examples for poktroll-clients
url: https://github.com/pokt-network/poktroll-clients-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poktroll-clients-0.1.0a1.dev4-1.src.rpm
location_href: Packages/python-poktroll-clients-help-0.1.0a1.dev4-1.noarch.rpm
checksum_type: sha256
description:
  An [`asyncio`](https://docs.python.org/3/library/asyncio.html) based, cross-platform Python API which wraps the [`poktroll` client packages](https://pkg.go.dev/github.com/pokt-network/poktroll@v0.0.10/pkg/client) (via [`libpoktroll_clients`](https://github.com/bryanchriswhite/libpoktroll-clients)).



  - [Installation](#installation)
    - [PyPI (pip)](#pypi-pip)
    - [Source](#source)
  - [Getting started](#getting-started)
    - [Start poktroll Localnet](#start-poktroll-localnet)
    - [Usage Examples](#build-and-install-libpoktroll_clients-shared-library--headers)
    - [Local Development Environment Setup](#local-development-environment-setup)





  **NOTE:** Until some import optimizations are done, the shared libraries are too large to distribute via PyPI. 😢
  In the meantime, the shared libraries can be installed separately by following the [libpoktroll-clients README](https://github.com/bryanchriswhite/libpoktroll-clients/blob/main/README.md).

  ```bash
  pip install poktroll_clients
  ```



  Download and install from source via **any one** of the following (e.g., for version `0.1.0a1`):
  1. Clone the repository and check out the desired release version tag.
      ```bash
      git clone https://github.com/bryanchriswhite/poktroll-clients-py
      git checkout v0.1.0a1
      ```
  2. Download and install a release wheel from the [releases page](https://github.com/bryanchriswhite/poktroll-clients-py/releases).
      ```bash
      wget https://github.com/bryanchriswhite/poktroll-clients-py/releases/download/poktrollv0.1.0a1/poktroll_clients-0.1.0a1-py3-none-any.whl
      pip install ./poktroll_clients-0.1.0a1-py3-none-any.whl
      
      pipenv install ./poktroll_clients-0.1.0a1-py3-none-any.whl
      ```
  3. Download and unpack a release tarball from the [releases page](https://github.com/bryanchriswhite/poktroll-clients-py/releases).
      ```bash
      wget https://github.com/bryanchriswhite/poktroll-clients-py/releases/download/v0.1.0a1/poktroll_clients-0.1.0a1.tar.gz
      pip install ./poktroll_clients-0.1.0a1.tar.gz
      
      pipenv install ./poktroll_clients-0.1.0a1.tar.gz
      ```




  ```bash
  git clone https://github.com/pokt-network/poktroll
  cd poktroll


  make localnet_up



  make acc_initialize_pubkeys
  ```



  <details>
  <summary><b>Imports</b></summary>

  ```python
  import asyncio
  from poktroll_clients.proto.poktroll.gateway.tx_pb2 import *
  from poktroll_clients.proto.poktroll.application.tx_pb2 import *
  from poktroll_clients.proto.poktroll.shared.service_pb2 import *
  from poktroll_clients.proto.cosmos.base.v1beta1.coin_pb2 import *
  from poktroll_clients.proto.cosmos.bank.v1beta1.tx_pb2 import *
  from poktroll_clients import (
      SupplyMany,
      EventsQueryClient,
      BlockQueryClient,
      BlockClient,
      TxContext,
      TxClient
  )
  ```

  </details>

  <details>
  <summary><b>Dependency Construction</b></summary>

  ```python


  """
  Signing key name should match the name of a key in the local poktrolld keyring
  which is authorized to sign for any transactions the tx client will broadcast.
  See `poktrolld keys -h` for more information.
  """
  signing_key_name = "key-name"

  """
  Query node RPC URL is the HTTP URL for the poktroll RPC endpoint to which the block
  client will send query requests.
  """
  query_node_rpc_url = "http://127.0.0.1:26657"

  """
  Query node RPC websocket URL is the websocket URL for the poktroll RPC endpoint to
  which the events query client will connect and subscribe. It is typically the same
  as query_node_rpc_url, but with the ws:// scheme and /websocket path.
  """
  query_node_rpc_websocket_url = "ws://127.0.0.1:26657/websocket"

  """
  Tx node RPC URL is the gRPC gateway URL for the poktroll RPC endpoint to which the
  tx client will connect and broadcast signed transactions. It MUST use the tcp:// scheme.
  """
  tx_node_rpc_url = "tcp://127.0.0.1:26657"

  events_query_client = EventsQueryClient(query_node_rpc_websocket_url)
  block_query_client = BlockQueryClient(query_node_rpc_url)

  block_client_deps_ref = SupplyMany(events_query_client, block_query_client)
  block_client = BlockClient(block_client_deps_ref)
  tx_ctx = TxContext(tx_node_rpc_url)

  tx_client_deps_ref = SupplyMany(events_query_client, block_client, tx_ctx)
  example_tx_client = TxClient(tx_client_deps_ref, signing_key_name)
  ```

  </details>


  **Tx Client Usage**

  ```python


  app3_addr = "pokt1lqyu4v88vp8tzc86eaqr4lq8rwhssyn6rfwzex"
  gateway1_addr = "pokt15vzxjqklzjtlz7lahe8z2dfe9nm5vxwwmscne4"
  gateway2_addr = "pokt15w3fhfyc0lttv7r585e2ncpf6t2kl9uh8rsnyz"


  async def main():
      

      
      gw_tx_client = TxClient("gateway2", tx_client_deps_ref)

      
      app_tx_client = TxClient("app3", tx_client_deps_ref)

      
      await gw_tx_client.sign_and_broadcast(
          MsgStakeGateway(
              address=gateway2_addr,
              stake=Coin(denom="upokt", amount="100000000"),
          )
      )

      
      await asyncio.sleep(2)

      
      await app_tx_client.sign_and_broadcast(
          MsgStakeApplication(
              address="pokt1lqyu4v88vp8tzc86eaqr4lq8rwhssyn6rfwzex",
              stake=Coin(denom="upokt", amount="100000000"),
              services=[ApplicationServiceConfig(service_id="anvil")]
          ),
          *[MsgDelegateToGateway(
              app_address=app3_addr,
              gateway_address=gateway_addr,
          ) for gateway_addr in [gateway1_addr, gateway2_addr]],
      )

      
      await app_tx_client.sign_and_broadcast(
          MsgUnstakeApplication(address=app3_addr),
      )

      
      await gw_tx_client.sign_and_broadcast(
          MsgUnstakeGateway(address=gateway2_addr)
      )


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


  ```bash
  git clone https://github.com/bryanchriswhite/poktroll-clients-py
  cd poktroll-clients-py


  pip install pipenv
  pipenv install
  pipenv shell


  buf export buf.build/pokt-network/poktroll


  buf generate && python ./scripts/fix_proto_imports.py


  pip install -e .


  pytest
  ```

  This step is optional, but necessary if you intend on developing, and locally integrating, modified versions of the `libpoktroll_clients` shared library.
  Otherwise, the steps in the [installation](#installation) section are sufficient to use and develop on the `poktroll_clients` python package (i.e., you can skip this step).

  ```bash
  git clone https://github.com/byanchriswhite/libpoktroll_clients
  cd libpoktroll_clients


  mkdir build
  cd build
  cmake ..
  make
  sudo make install


  ```


pkgId: b4cafcf7dfe29d56b240bff7a845bf1dcdf8c38b9cb99e5a7a77d9472ec74ce4
name: python-polars-bloomberg-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for polars-bloomberg
url: https://github.com/MarekOzana/polars-bloomberg
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-polars-bloomberg-0.3.1-1.src.rpm
location_href: Packages/python-polars-bloomberg-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  1. [Introduction](#introduction)
  2. [Prerequisites](#prerequisites)
  3. [Installation](#installation)
  4. [Quick Start](#quick-start)
  5. [Core Methods](#core-methods)
      - [BDP (Bloomberg Data Point)](#bdp)
      - [BDH (Bloomberg Data History)](#bdh)
      - [BQL (Bloomberg Query Language)](#bql) <details><summary>BQL Examples</summary>
          - [Single Data Item and Single Security](#simple-bql-example)
          - [Single Item and Multiple Securities](#single-item-with-multiple-securities)
          - [Multiple Items](#multiple-data-items-in-get)
          - [SRCH](#zspread-vs-duration-on-seb-and-shbass-coco-bonds-from-srch)
          - [Aggregation (AVG)](#average-pe-per-sector)
          - [Axes](#axes)
          - [Segments](#segments)
          - [Average Spread per Bucket](#average-issuer-oas-spread-per-maturity-bucket)
          - [Technical Analysis Screening](#technical-analysis-stocks-with-20d-ema--200d-ema-and-rsi--55)
          - [Bonds Universe from Equity](#bond-universe-from-equity-ticker)
          - [Bonds Total Return](#bonds-total-returns)
          </details>
  6. [Additional Documentation and Resources](#additional-documentation--resources)

  Working with Bloomberg data in Python often feels more complicated than using their well-known Excel interface.
  Great projects like [blp](https://github.com/matthewgilbert/blp), [xbbg](https://github.com/alpha-xone/xbbg), and [pdblp](https://github.com/matthewgilbert/pdblp) have made this easier by pulling data directly into pandas.
  With polars-bloomberg, you can enjoy the speed and simplicity of [Polars](https://www.pola.rs/) DataFrames—accessing both familiar Excel-style calls (`bdp`, `bdh`) and advanced `bql` queries—without extra pandas conversions.
  I hope you enjoy using it as much as I had fun building it!

  - **Bloomberg Access:** A valid Bloomberg terminal license.
  - **Bloomberg Python API:** The `blpapi` library must be installed. See the [Bloomberg API Library](https://www.bloomberg.com/professional/support/api-library/) for guidance.
  - **Python Version:** Python 3.8+ recommended.

  ```bash
  pip install polars-bloomberg
  ```

  "Hello World" Example (under 1 minute):
  ```python
  from polars_bloomberg import BQuery

  with BQuery() as bq:
      df = bq.bdp(["AAPL US Equity"], ["PX_LAST"])
      print(df)
  ┌────────────────┬─────────┐
  │ security       ┆ PX_LAST │
  │ ---            ┆ ---     │
  │ str            ┆ f64     │
  ╞════════════════╪═════════╡
  │ AAPL US Equity ┆ 248.13  │
  └────────────────┴─────────┘
  ```
  What this does:
  - Establishes a Bloomberg connection using the context manager.
  - Retrieves the last price of Apple shares.
  - Returns the result as a Polars DataFrame.
  If you see a price in `df`, your setup is working 🤩!!!

  `BQuery` is your main interface. Using a context manager ensures the connection opens and closes cleanly. Within this session, you can use:
  - `bq.bdp()` for Bloomberg Data Points (single-value fields).
  - `bq.bdh()` for Historical Data (time series).
  - `bq.bql()` for complex Bloomberg Query Language requests.

  Use Case: Fetch the latest single-value data points (like last price, currency, or descriptive fields).

  ```python
  with BQuery() as bq:
      df = bq.bdp(["AAPL US Equity", "SEBA SS Equity"], ["PX_LAST", "CRNCY"])
      print(df)
  ┌────────────────┬─────────┬───────┐
  │ security       ┆ PX_LAST ┆ CRNCY │
  │ ---            ┆ ---     ┆ ---   │
  │ str            ┆ f64     ┆ str   │
  ╞════════════════╪═════════╪═══════╡
  │ AAPL US Equity ┆ 248.13  ┆ USD   │
  │ SEBA SS Equity ┆ 155.2   ┆ SEK   │
  └────────────────┴─────────┴───────┘
  ```
  <details><summary>Expand for more BDP Examples</summary>

  `polars-bloomberg` correctly infers column type as shown in this example:
  ```python
  with BQuery() as bq:
      df = bq.bdp(["XS2930103580 Corp", "USX60003AC87 Corp"],
                  ["SECURITY_DES", "YAS_ZSPREAD", "CRNCY", "NXT_CALL_DT"])
  ┌───────────────────┬────────────────┬─────────────┬───────┬─────────────┐
  │ security          ┆ SECURITY_DES   ┆ YAS_ZSPREAD ┆ CRNCY ┆ NXT_CALL_DT │
  │ ---               ┆ ---            ┆ ---         ┆ ---   ┆ ---         │
  │ str               ┆ str            ┆ f64         ┆ str   ┆ date        │
  ╞═══════════════════╪════════════════╪═════════════╪═══════╪═════════════╡
  │ XS2930103580 Corp ┆ SEB 6 3/4 PERP ┆ 304.676112  ┆ USD   ┆ 2031-11-04  │
  │ USX60003AC87 Corp ┆ NDAFH 6.3 PERP ┆ 292.477506  ┆ USD   ┆ 2031-09-25  │
  └───────────────────┴────────────────┴─────────────┴───────┴─────────────┘
  ```

  User can submit list of tuples with overrides
  ```python
  with BQuery() as bq:
      df = bq.bdp(
          ["IBM US Equity"],
          ["PX_LAST", "CRNCY_ADJ_PX_LAST"],
          overrides=[("EQY_FUND_CRNCY", "SEK")],
      )
  ┌───────────────┬─────────┬───────────────────┐
  │ security      ┆ PX_LAST ┆ CRNCY_ADJ_PX_LAST │
  │ ---           ┆ ---     ┆ ---               │
  │ str           ┆ f64     ┆ f64               │
  ╞═══════════════╪═════════╪═══════════════════╡
  │ IBM US Equity ┆ 230.82  ┆ 2535.174          │
  └───────────────┴─────────┴───────────────────┘
  ```

  Overrides for dates has to be in format YYYYMMDD
  ```python
  with BQuery() as bq:
      df = bq.bdp(["USX60003AC87 Corp"], ["SETTLE_DT"],
                  overrides=[("USER_LOCAL_TRADE_DATE", "20241014")])
  ┌───────────────────┬────────────┐
  │ security          ┆ SETTLE_DT  │
  │ ---               ┆ ---        │
  │ str               ┆ date       │
  ╞═══════════════════╪════════════╡
  │ USX60003AC87 Corp ┆ 2024-10-15 │
  └───────────────────┴────────────┘
  ```
  ```python
  with BQuery() as bq:
      df = bq.bdp(['USDSEK Curncy', 'SEKCZK Curncy'],
                  ['SETTLE_DT', 'PX_LAST'],
                  overrides=[('REFERENCE_DATE', '20200715')]
                 )
  ┌───────────────┬────────────┬─────────┐
  │ security      ┆ SETTLE_DT  ┆ PX_LAST │
  │ ---           ┆ ---        ┆ ---     │
  │ str           ┆ date       ┆ f64     │
  ╞═══════════════╪════════════╪═════════╡
  │ USDSEK Curncy ┆ 2020-07-17 ┆ 10.9778 │
  │ SEKCZK Curncy ┆ 2020-07-17 ┆ 2.1698  │
  └───────────────┴────────────┴─────────┘
  ```
  </details>

  Use Case: Retrieve historical data over a date range, such as daily closing prices or volumes.
  ```python
  with BQuery() as bq:
      df = bq.bdh(
          ["TLT US Equity"],
          ["PX_LAST"],
          start_date=date(2019, 1, 1),
          end_date=date(2019, 1, 7),
      )
      print(df)
  ┌───────────────┬────────────┬─────────┐
  │ security      ┆ date       ┆ PX_LAST │
  │ ---           ┆ ---        ┆ ---     │
  │ str           ┆ date       ┆ f64     │
  ╞═══════════════╪════════════╪═════════╡
  │ TLT US Equity ┆ 2019-01-02 ┆ 122.15  │
  │ TLT US Equity ┆ 2019-01-03 ┆ 123.54  │
  │ TLT US Equity ┆ 2019-01-04 ┆ 122.11  │
  │ TLT US Equity ┆ 2019-01-07 ┆ 121.75  │
  └───────────────┴────────────┴─────────┘
  ```
  <details><summary>Expand for more BDH examples</summary>

  ```python
  with BQuery() as bq:
      df = bq.bdh(
          securities=["SPY US Equity", "TLT US Equity"],
          fields=["PX_LAST", "VOLUME"],
          start_date=date(2019, 1, 1),
          end_date=date(2019, 1, 10),
          options={"adjustmentSplit": True},
      )
      print(df)
  shape: (14, 4)
  ┌───────────────┬────────────┬─────────┬──────────────┐
  │ security      ┆ date       ┆ PX_LAST ┆ VOLUME       │
  │ ---           ┆ ---        ┆ ---     ┆ ---          │
  │ str           ┆ date       ┆ f64     ┆ f64          │
  ╞═══════════════╪════════════╪═════════╪══════════════╡
  │ SPY US Equity ┆ 2019-01-02 ┆ 250.18  ┆ 1.26925199e8 │
  │ SPY US Equity ┆ 2019-01-03 ┆ 244.21  ┆ 1.44140692e8 │
  │ SPY US Equity ┆ 2019-01-04 ┆ 252.39  ┆ 1.42628834e8 │
  │ SPY US Equity ┆ 2019-01-07 ┆ 254.38  ┆ 1.031391e8   │
  │ SPY US Equity ┆ 2019-01-08 ┆ 256.77  ┆ 1.02512587e8 │
  │ …             ┆ …          ┆ …       ┆ …            │
  │ TLT US Equity ┆ 2019-01-04 ┆ 122.11  ┆ 1.2970226e7  │
  │ TLT US Equity ┆ 2019-01-07 ┆ 121.75  ┆ 8.498104e6   │
  │ TLT US Equity ┆ 2019-01-08 ┆ 121.43  ┆ 7.737103e6   │
  │ TLT US Equity ┆ 2019-01-09 ┆ 121.24  ┆ 9.349245e6   │
  │ TLT US Equity ┆ 2019-01-10 ┆ 120.46  ┆ 8.22286e6    │
  └───────────────┴────────────┴─────────┴──────────────┘
  ```

  ```python
  with BQuery() as bq:
      df = bq.bdh(['AAPL US Equity'],
                  ['PX_LAST'],
                  start_date=date(2019, 1, 1),
                  end_date=date(2019, 3, 29),
                  options={"periodicitySelection": "MONTHLY"})
  ┌────────────────┬────────────┬─────────┐
  │ security       ┆ date       ┆ PX_LAST │
  │ ---            ┆ ---        ┆ ---     │
  │ str            ┆ date       ┆ f64     │
  ╞════════════════╪════════════╪═════════╡
  │ AAPL US Equity ┆ 2019-01-31 ┆ 41.61   │
  │ AAPL US Equity ┆ 2019-02-28 ┆ 43.288  │
  │ AAPL US Equity ┆ 2019-03-29 ┆ 47.488  │
  └────────────────┴────────────┴─────────┘
  ```
  </details>

  *Use Case*: Run more advanced queries to screen securities, calculate analytics (like moving averages), or pull fundamental data with complex conditions.
  *Returns*: list of polars dataframes, one per each data-item in `get()`statement.

  ```python

  with BQuery() as bq:
      df_lst = bq.bql("get(px_last) for(['IBM US Equity'])")
      print(df_lst[0])
  ┌───────────────┬─────────┬────────────┬──────────┐
  │ ID            ┆ px_last ┆ DATE       ┆ CURRENCY │
  │ ---           ┆ ---     ┆ ---        ┆ ---      │
  │ str           ┆ f64     ┆ date       ┆ str      │
  ╞═══════════════╪═════════╪════════════╪══════════╡
  │ IBM US Equity ┆ 230.82  ┆ 2024-12-14 ┆ USD      │
  └───────────────┴─────────┴────────────┴──────────┘
  ```

  Another example with single data item but two securities. Still only one pl.DataFrame in
  resulting list (only one data item in `get()`)
  ```python
  with BQuery() as bq:
      df_lst = bq.bql("get(px_last) for(['IBM US Equity', 'SEBA SS Equity'])")
  > print(f"n={len(df_lst)}")
  n=1
  > print(df_lst[0])
  ┌────────────────┬─────────┬────────────┬──────────┐
  │ ID             ┆ px_last ┆ DATE       ┆ CURRENCY │
  │ ---            ┆ ---     ┆ ---        ┆ ---      │
  │ str            ┆ f64     ┆ date       ┆ str      │
  ╞════════════════╪═════════╪════════════╪══════════╡
  │ IBM US Equity  ┆ 230.82  ┆ 2024-12-14 ┆ USD      │
  │ SEBA SS Equity ┆ 155.2   ┆ 2024-12-14 ┆ SEK      │
  └────────────────┴─────────┴────────────┴──────────┘
  ```

  Lets consider example with two data-items in get statement. Note that the resulting list has two pl.DataFrames.
  ```python
  with BQuery() as bq:
      df_lst = bq.bql("get(name, px_last) for(['IBM US Equity'])")
  > print(f"n={len(df_lst)}")
  n=2
  > print(df_lst[0])
  ┌───────────────┬────────────────────────────────┐
  │ ID            ┆ name                           │
  │ ---           ┆ ---                            │
  │ str           ┆ str                            │
  ╞═══════════════╪════════════════════════════════╡
  │ IBM US Equity ┆ International Business Machine │
  └───────────────┴────────────────────────────────┘
  > print(df_lst[1])
  shape: (1, 4)
  ┌───────────────┬─────────┬────────────┬──────────┐
  │ ID            ┆ px_last ┆ DATE       ┆ CURRENCY │
  │ ---           ┆ ---     ┆ ---        ┆ ---      │
  │ str           ┆ f64     ┆ date       ┆ str      │
  ╞═══════════════╪═════════╪════════════╪══════════╡
  │ IBM US Equity ┆ 230.82  ┆ 2024-12-14 ┆ USD      │
  └───────────────┴─────────┴────────────┴──────────┘
  ```
  Since both DataFrames have teh same index `ID` one can join the results into single table.
  ```python
  >>> print(df_lst[0].join(df_lst[1], on='ID'))
  ┌───────────────┬────────────────────────────────┬─────────┬────────────┬──────────┐
  │ ID            ┆ name                           ┆ px_last ┆ DATE       ┆ CURRENCY │
  │ ---           ┆ ---                            ┆ ---     ┆ ---        ┆ ---      │
  │ str           ┆ str                            ┆ f64     ┆ date       ┆ str      │
  ╞═══════════════╪════════════════════════════════╪═════════╪════════════╪══════════╡
  │ IBM US Equity ┆ International Business Machine ┆ 230.82  ┆ 2024-12-14 ┆ USD      │
  └───────────────┴────────────────────────────────┴─────────┴────────────┴──────────┘
  ```

  In this example we have three data-items in `get`statement. The universe is from Bloomberg SRCH function
  filtered only on tickers 'SEB' and 'SHBASS'.
  ```python
  query="""
      let(#dur=duration(duration_type=MODIFIED);
          
      get(name(), #dur, #zsprd)
      for(filter(screenresults(type=SRCH, screen_name='@COCO'),
              ticker in ['SEB', 'SHBASS']))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      df = df_lst[0].join(df_lst[1], on='ID').join(df_lst[2], on=['ID', 'DATE'])
      print(df)
  ┌───────────────┬─────────────────┬──────────┬────────────┬────────────┐
  │ ID            ┆ name()          ┆ #dur     ┆ DATE       ┆ #zsprd     │
  │ ---           ┆ ---             ┆ ---      ┆ ---        ┆ ---        │
  │ str           ┆ str             ┆ f64      ┆ date       ┆ f64        │
  ╞═══════════════╪═════════════════╪══════════╪════════════╪════════════╡
  │ ZQ349286 Corp ┆ SEB 5 ⅛ PERP    ┆ 0.395636 ┆ 2024-12-14 ┆ 185.980438 │
  │ YV402592 Corp ┆ SEB Float PERP  ┆ 0.212973 ┆ 2024-12-14 ┆ 232.71     │
  │ YU819930 Corp ┆ SEB 6 ¾ PERP    ┆ 5.37363  ┆ 2024-12-14 ┆ 308.810572 │
  │ ZO703956 Corp ┆ SHBASS 4 ¾ PERP ┆ 4.946231 ┆ 2024-12-14 ┆ 255.85428  │
  │ ZO703315 Corp ┆ SHBASS 4 ⅜ PERP ┆ 1.956536 ┆ 2024-12-14 ┆ 213.358921 │
  │ BW924993 Corp ┆ SEB 6 ⅞ PERP    ┆ 2.231859 ┆ 2024-12-14 ┆ 211.55125  │
  └───────────────┴─────────────────┴──────────┴────────────┴────────────┘
  ```

  This example shows aggregation (average) per group (sector) for members of an index.
  The reulting list has only one element since there is only one data-item in `get`
  ```python
  query = """
      let(#avg_pe=avg(group(pe_ratio(), gics_sector_name()));)
      get(#avg_pe)
      for(members('OMX Index'))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      print(df_lst[0].head(5))
  ┌──────────────┬───────────┬──────────────┬────────────┬──────────────┬──────────────┬─────────────┐
  │ ID           ┆ #avg_pe   ┆ REVISION_DAT ┆ AS_OF_DATE ┆ PERIOD_END_D ┆ ORIG_IDS     ┆ GICS_SECTOR │
  │ ---          ┆ ---       ┆ E            ┆ ---        ┆ ATE          ┆ ---          ┆ _NAME()     │
  │ str          ┆ f64       ┆ ---          ┆ date       ┆ ---          ┆ str          ┆ ---         │
  │              ┆           ┆ date         ┆            ┆ date         ┆              ┆ str         │
  ╞══════════════╪═══════════╪══════════════╪════════════╪══════════════╪══════════════╪═════════════╡
  │ Communicatio ┆ 19.561754 ┆ 2024-10-24   ┆ 2024-12-14 ┆ 2024-09-30   ┆ null         ┆ Communicati │
  │ n Services   ┆           ┆              ┆            ┆              ┆              ┆ on Services │
  │ Consumer Dis ┆ 19.117295 ┆ 2024-10-24   ┆ 2024-12-14 ┆ 2024-09-30   ┆ null         ┆ Consumer    │
  │ cretionary   ┆           ┆              ┆            ┆              ┆              ┆ Discretiona │
  │              ┆           ┆              ┆            ┆              ┆              ┆ ry          │
  │ Consumer     ┆ 15.984743 ┆ 2024-10-24   ┆ 2024-12-14 ┆ 2024-09-30   ┆ ESSITYB SS   ┆ Consumer    │
  │ Staples      ┆           ┆              ┆            ┆              ┆ Equity       ┆ Staples     │
  │ Financials   ┆ 6.815895  ┆ 2024-10-24   ┆ 2024-12-14 ┆ 2024-09-30   ┆ null         ┆ Financials  │
  │ Health Care  ┆ 22.00628  ┆ 2024-11-12   ┆ 2024-12-14 ┆ 2024-09-30   ┆ null         ┆ Health Care │
  └──────────────┴───────────┴──────────────┴────────────┴──────────────┴──────────────┴─────────────┘
  ```

  Get current axes of all Swedish USD AT1 bonds
  ```python

  query="""
      let(#ax=axes();)
      get(security_des, #ax)
      for(filter(bondsuniv(ACTIVE),
          crncy()=='USD' and
          basel_iii_designation() == 'Additional Tier 1' and
          country_iso() == 'SE'))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      print(df_lst[0].join(df_lst[1], on='ID'))
  ┌───────────────┬─────────────────┬─────┬───────────┬───────────┬────────────────┬────────────────┐
  │ ID            ┆ security_des    ┆ #ax ┆ ASK_DEPTH ┆ BID_DEPTH ┆ ASK_TOTAL_SIZE ┆ BID_TOTAL_SIZE │
  │ ---           ┆ ---             ┆ --- ┆ ---       ┆ ---       ┆ ---            ┆ ---            │
  │ str           ┆ str             ┆ str ┆ i64       ┆ i64       ┆ f64            ┆ f64            │
  ╞═══════════════╪═════════════════╪═════╪═══════════╪═══════════╪════════════════╪════════════════╡
  │ YU819930 Corp ┆ SEB 6 ¾ PERP    ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ ZO703315 Corp ┆ SHBASS 4 ⅜ PERP ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ BR069680 Corp ┆ SWEDA 4 PERP    ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ ZL122341 Corp ┆ SWEDA 7 ⅝ PERP  ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ ZQ349286 Corp ┆ SEB 5 ⅛ PERP    ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ ZF859199 Corp ┆ SWEDA 7 ¾ PERP  ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ ZO703956 Corp ┆ SHBASS 4 ¾ PERP ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  │ BW924993 Corp ┆ SEB 6 ⅞ PERP    ┆ N   ┆ null      ┆ null      ┆ null           ┆ null           │
  └───────────────┴─────────────────┴─────┴───────────┴───────────┴────────────────┴────────────────┘
  ```

  The following example shows handling of two data-items with different length. Teh first dataframe
  describes the segments (and has length 5 in this case), while the second dataframe contains time series.
  One can join teh dataframes on common columns and pivot the segments into columns as shown below:
  ```python

  query = """
      let(#segment=segment_name();
          
          )
      get(#segment, #revenue)
      for(segments('GTN US Equity',type=reported,hierarchy=PRODUCT, level=1))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      df = (
          df_lst[0]
          .join(df_lst[1], on=["ID", "ID_DATE", "AS_OF_DATE"])
          .pivot(index="PERIOD_END_DATE", on="#segment", values="#revenue")
      )
      print(df)
  ┌─────────────────┬──────────────┬──────────────────────┬────────┬────────────┐
  │ PERIOD_END_DATE ┆ Broadcasting ┆ Production Companies ┆ Other  ┆ Adjustment │
  │ ---             ┆ ---          ┆ ---                  ┆ ---    ┆ ---        │
  │ date            ┆ f64          ┆ f64                  ┆ f64    ┆ f64        │
  ╞═════════════════╪══════════════╪══════════════════════╪════════╪════════════╡
  │ 2023-09-30      ┆ 7.83e8       ┆ 2e7                  ┆ 1.6e7  ┆ null       │
  │ 2023-12-31      ┆ 8.13e8       ┆ 3.2e7                ┆ 1.9e7  ┆ null       │
  │ 2024-03-31      ┆ 7.8e8        ┆ 2.4e7                ┆ 1.9e7  ┆ null       │
  │ 2024-06-30      ┆ 8.08e8       ┆ 1.8e7                ┆ 0.0    ┆ null       │
  │ 2024-09-30      ┆ 9.24e8       ┆ 2.6e7                ┆ 1.7e7  ┆ null       │
  └─────────────────┴──────────────┴──────────────────────┴────────┴────────────┘
  ```

  ```python
  with BQuery() as bq:
      df_lst = bq.bql("""
          let(#eps=is_eps(fa_period_type='A',
                          fa_period_offset=range(-4,2));)
          get(#eps)
          for(['IBM US Equity'])
      """)
      print(df_lst[0])
  ┌───────────────┬───────┬───────────────┬────────────┬─────────────────┬──────────┐
  │ ID            ┆ #eps  ┆ REVISION_DATE ┆ AS_OF_DATE ┆ PERIOD_END_DATE ┆ CURRENCY │
  │ ---           ┆ ---   ┆ ---           ┆ ---        ┆ ---             ┆ ---      │
  │ str           ┆ f64   ┆ date          ┆ date       ┆ date            ┆ str      │
  ╞═══════════════╪═══════╪═══════════════╪════════════╪═════════════════╪══════════╡
  │ IBM US Equity ┆ 10.63 ┆ 2022-02-22    ┆ 2024-12-14 ┆ 2019-12-31      ┆ USD      │
  │ IBM US Equity ┆ 6.28  ┆ 2023-02-28    ┆ 2024-12-14 ┆ 2020-12-31      ┆ USD      │
  │ IBM US Equity ┆ 6.41  ┆ 2023-02-28    ┆ 2024-12-14 ┆ 2021-12-31      ┆ USD      │
  │ IBM US Equity ┆ 1.82  ┆ 2024-03-18    ┆ 2024-12-14 ┆ 2022-12-31      ┆ USD      │
  │ IBM US Equity ┆ 8.23  ┆ 2024-03-18    ┆ 2024-12-14 ┆ 2023-12-31      ┆ USD      │
  │ IBM US Equity ┆ 7.891 ┆ 2024-12-13    ┆ 2024-12-14 ┆ 2024-12-31      ┆ USD      │
  │ IBM US Equity ┆ 9.236 ┆ 2024-12-13    ┆ 2024-12-14 ┆ 2025-12-31      ┆ USD      │
  └───────────────┴───────┴───────────────┴────────────┴─────────────────┴──────────┘
  ```

  ```python

  query = """
  let(
      
                   [3,9,18,30],
                   ['(1) 0-3','(2) 3-9','(3) 9-18','(4) 18-30','(5) 30+']);
      
  )
  get(#average_spread)
  for(filter(bonds('NVDA US Equity', issuedby = 'ENTITY'),
             maturity_years != NA))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      print(df_lst[0])
  ┌───────────┬─────────────────┬────────────┬───────────────┬───────────┐
  │ ID        ┆ #average_spread ┆ DATE       ┆ ORIG_IDS      ┆ #BINS     │
  │ ---       ┆ ---             ┆ ---        ┆ ---           ┆ ---       │
  │ str       ┆ f64             ┆ date       ┆ str           ┆ str       │
  ╞═══════════╪═════════════════╪════════════╪═══════════════╪═══════════╡
  │ (1) 0-3   ┆ 31.195689       ┆ 2024-12-14 ┆ QZ552396 Corp ┆ (1) 0-3   │
  │ (2) 3-9   ┆ 59.580383       ┆ 2024-12-14 ┆ null          ┆ (2) 3-9   │
  │ (3) 9-18  ┆ 110.614416      ┆ 2024-12-14 ┆ BH393780 Corp ┆ (3) 9-18  │
  │ (4) 18-30 ┆ 135.160279      ┆ 2024-12-14 ┆ BH393781 Corp ┆ (4) 18-30 │
  │ (5) 30+   ┆ 150.713405      ┆ 2024-12-14 ┆ BH393782 Corp ┆ (5) 30+   │
  └───────────┴─────────────────┴────────────┴───────────────┴───────────┘
  ```

  ```python
  with BQuery() as bq:
      df_lst = bq.bql(
          """
          let(#ema20=emavg(period=20);
              
              
          get(name(), #ema20, #ema200, #rsi)
          for(filter(members('OMX Index'),
                      and(#ema20 > #ema200, #rsi > 55)))
          with(fill=PREV)
          """
      )
      df = (
          df_lst[0]
          .join(df_lst[1], on="ID")
          .join(df_lst[2], on=["ID", "DATE", "CURRENCY"])
          .join(df_lst[3], on=["ID", "DATE"])
      )
      print(df)
  ┌─────────────────┬──────────────────┬────────────┬────────────┬──────────┬────────────┬───────────┐
  │ ID              ┆ name()           ┆ #ema20     ┆ DATE       ┆ CURRENCY ┆ #ema200    ┆ #rsi      │
  │ ---             ┆ ---              ┆ ---        ┆ ---        ┆ ---      ┆ ---        ┆ ---       │
  │ str             ┆ str              ┆ f64        ┆ date       ┆ str      ┆ f64        ┆ f64       │
  ╞═════════════════╪══════════════════╪════════════╪════════════╪══════════╪════════════╪═══════════╡
  │ ERICB SS Equity ┆ Telefonaktiebola ┆ 90.094984  ┆ 2024-12-14 ┆ SEK      ┆ 74.917219  ┆ 57.454412 │
  │                 ┆ get LM Ericsso   ┆            ┆            ┆          ┆            ┆           │
  │ SKFB SS Equity  ┆ SKF AB           ┆ 214.383743 ┆ 2024-12-14 ┆ SEK      ┆ 205.174139 ┆ 58.403269 │
  │ SEBA SS Equity  ┆ Skandinaviska    ┆ 153.680261 ┆ 2024-12-14 ┆ SEK      ┆ 150.720922 ┆ 57.692703 │
  │                 ┆ Enskilda Banken  ┆            ┆            ┆          ┆            ┆           │
  │ ASSAB SS Equity ┆ Assa Abloy AB    ┆ 338.829971 ┆ 2024-12-14 ┆ SEK      ┆ 316.8212   ┆ 55.467329 │
  │ SWEDA SS Equity ┆ Swedbank AB      ┆ 217.380431 ┆ 2024-12-14 ┆ SEK      ┆ 213.776784 ┆ 56.303481 │
  └─────────────────┴──────────────────┴────────────┴────────────┴──────────┴────────────┴───────────┘
  ```

  ```python
  query = """
  let(#rank=normalized_payment_rank();
      
      
      )
  get(name(), #rank, #nxt_call, #oas)
  for(filter(bonds('GTN US Equity'), series() == '144A'))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      df = (
          df_lst[0]
          .join(df_lst[1], on="ID")
          .join(df_lst[2], on="ID")
          .join(df_lst[3], on="ID")
      )
      print(df)
  ┌───────────────┬───────────────────┬──────────────────┬────────────┬─────────────┬────────────┐
  │ ID            ┆ name()            ┆ #rank            ┆ #nxt_call  ┆ #oas        ┆ DATE       │
  │ ---           ┆ ---               ┆ ---              ┆ ---        ┆ ---         ┆ ---        │
  │ str           ┆ str               ┆ str              ┆ date       ┆ f64         ┆ date       │
  ╞═══════════════╪═══════════════════╪══════════════════╪════════════╪═════════════╪════════════╡
  │ YX231113 Corp ┆ GTN 10 ½ 07/15/29 ┆ 1st Lien Secured ┆ 2026-07-15 ┆ 597.329513  ┆ 2024-12-14 │
  │ BS116983 Corp ┆ GTN 5 ⅜ 11/15/31  ┆ Sr Unsecured     ┆ 2026-11-15 ┆ 1192.83614  ┆ 2024-12-14 │
  │ AV438089 Corp ┆ GTN 7 05/15/27    ┆ Sr Unsecured     ┆ 2024-12-23 ┆ 391.133436  ┆ 2024-12-14 │
  │ ZO860846 Corp ┆ GTN 4 ¾ 10/15/30  ┆ Sr Unsecured     ┆ 2025-10-15 ┆ 1232.554695 ┆ 2024-12-14 │
  │ LW375188 Corp ┆ GTN 5 ⅞ 07/15/26  ┆ Sr Unsecured     ┆ 2025-01-12 ┆ 171.708702  ┆ 2024-12-14 │
  └───────────────┴───────────────────┴──────────────────┴────────────┴─────────────┴────────────┘
  ```

  This is example of a single-item query returning total return for all GTN bonds in a long dataframe.
  We can easily pivot it into wide format, as in the example below
  ```python

  query="""
  let(#rng = range(-1M, 0D);
      
  get(#rets)
  for(filter(bonds('GTN US Equity'), series() == '144A'))
  """
  with BQuery() as bq:
      df_lst = bq.bql(query)
      df = df_lst[0].pivot(on='ID', index='DATE', values='#rets')
      print(df)
  ┌────────────┬───────────────┬───────────────┬───────────────┬───────────────┬───────────────┐
  │ DATE       ┆ YX231113 Corp ┆ BS116983 Corp ┆ AV438089 Corp ┆ ZO860846 Corp ┆ LW375188 Corp │
  │ ---        ┆ ---           ┆ ---           ┆ ---           ┆ ---           ┆ ---           │
  │ date       ┆ f64           ┆ f64           ┆ f64           ┆ f64           ┆ f64           │
  ╞════════════╪═══════════════╪═══════════════╪═══════════════╪═══════════════╪═══════════════╡
  │ 2024-11-14 ┆ null          ┆ null          ┆ null          ┆ null          ┆ null          │
  │ 2024-11-21 ┆ -0.002378     ┆ 0.016565      ┆ 0.022831      ┆ 0.000987      ┆ -0.002815     │
  │ 2024-11-28 ┆ 0.002345      ┆ -0.005489     ┆ -0.004105     ┆ 0.011748      ┆ 0.00037       │
  │ 2024-12-05 ┆ 0.001403      ┆ 0.016999      ┆ 0.002058      ┆ 0.013095      ┆ 0.001003      │
  │ 2024-12-12 ┆ -0.000485     ┆ -0.040228     ┆ -0.000872     ┆ -0.038048     ┆ 0.001122      │
  │ 2024-12-14 ┆ 0.000988      ┆ -0.003833     ┆ 0.000247      ┆ -0.004818     ┆ 0.00136       │
  └────────────┴───────────────┴───────────────┴───────────────┴───────────────┴───────────────┘
  ```

  - *API Documentation*: Detailed documentation and function references are available in the [API documentation](examples/API-docs.md) file within the `examples/` directory.
  - *Additional Examples*: Check out (examples/Examples.ipynb) for hands-on notebooks demonstrating a variety of use cases.
  - *Bloomberg Developer Resources*: For more details on the Bloomberg API itself, visit the [Bloomberg Developer's page](https://developer.bloomberg.com/).


