# packages

pkgId: 54b46e364ecedf14f6a606211138929618b0dbdf50b00f79817a4a1fd6e19636
name: python-types-boto3-ssm-sap-help
arch: noarch
version: 1.35.85
epoch: 0
release: 1
summary: Development documents and examples for types-boto3-ssm-sap
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-boto3-ssm-sap-1.35.85-1.src.rpm
location_href: Packages/python-types-boto3-ssm-sap-help-1.35.85-1.noarch.rpm
checksum_type: sha256
description:
  <a id="types-boto3-ssm-sap"></a>



  [![PyPI - types-boto3-ssm-sap](https://img.shields.io/pypi/v/types-boto3-ssm-sap.svg?color=blue)](https://pypi.org/project/types-boto3-ssm-sap/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/types-boto3-ssm-sap.svg?color=blue)](https://pypi.org/project/types-boto3-ssm-sap/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/types_boto3_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/types-boto3-ssm-sap)](https://pypistats.org/packages/types-boto3-ssm-sap)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 SsmSap 1.35.85](https://pypi.org/project/boto3/)
  compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.6.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [types-boto3](https://pypi.org/project/types-boto3/) page and in
  [types-boto3-ssm-sap docs](https://youtype.github.io/types_boto3_docs/types_boto3_ssm_sap/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [types-boto3-ssm-sap](#types-boto3-ssm-sap)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.85' mypy_boto3_builder`
  2. Select `boto3` AWS SDK.
  3. Add `SsmSap` service.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `SsmSap`.

  <a id="from-pypi-with-pip"></a>



  Install `types-boto3` for `SsmSap` service.

  ```bash

  python -m pip install 'types-boto3[ssm-sap]'



  python -m pip install 'types-boto3-lite[ssm-sap]'


  python -m pip install types-boto3-ssm-sap
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y types-boto3-ssm-sap
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `types-boto3[ssm-sap]` in your environment:

  ```bash
  python -m pip install 'types-boto3[ssm-sap]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [types-boto3-lite](https://pypi.org/project/types-boto3-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `types-boto3` with
  > [types-boto3-lite](https://pypi.org/project/types-boto3-lite/):

  ```bash
  pip uninstall types-boto3
  pip install types-boto3-lite
  ```

  Install `types-boto3[ssm-sap]` in your environment:

  ```bash
  python -m pip install 'types-boto3[ssm-sap]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `types-boto3` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[ssm-sap]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `types-boto3`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `types-boto3[ssm-sap]` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[ssm-sap]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `types-boto3[ssm-sap]` in your environment:

  ```bash
  python -m pip install 'types-boto3[ssm-sap]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `types-boto3[ssm-sap]` in your environment:

  ```bash
  python -m pip install 'types-boto3[ssm-sap]'
  ```

  Optionally, you can install `types-boto3` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid
  `types-boto3-ssm-sap` dependency in production. However, there is an issue in
  `pylint` that it complains about undefined variables. To fix it, set all types
  to `object` in non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from types_boto3_ec2 import EC2Client, EC2ServiceResource
      from types_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from types_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `SsmSapClient` provides annotations for `boto3.client("ssm-sap")`.

  ```python
  from boto3.session import Session

  from types_boto3_ssm_sap import SsmSapClient

  client: SsmSapClient = Session().client("ssm-sap")


  ```

  <a id="paginators-annotations"></a>



  `types_boto3_ssm_sap.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from types_boto3_ssm_sap import SsmSapClient
  from types_boto3_ssm_sap.paginator import (
      ListApplicationsPaginator,
      ListComponentsPaginator,
      ListDatabasesPaginator,
      ListOperationEventsPaginator,
      ListOperationsPaginator,
  )

  client: SsmSapClient = Session().client("ssm-sap")



  list_applications_paginator: ListApplicationsPaginator = client.get_paginator("list_applications")
  list_components_paginator: ListComponentsPaginator = client.get_paginator("list_components")
  list_databases_paginator: ListDatabasesPaginator = client.get_paginator("list_databases")
  list_operation_events_paginator: ListOperationEventsPaginator = client.get_paginator(
      "list_operation_events"
  )
  list_operations_paginator: ListOperationsPaginator = client.get_paginator("list_operations")
  ```

  <a id="literals"></a>



  `types_boto3_ssm_sap.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `SsmSap` Literals can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_ssm_sap/literals/).

  ```python
  from types_boto3_ssm_sap.literals import AllocationTypeType


  def check_value(value: AllocationTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `types_boto3_ssm_sap.type_defs` module contains structures and shapes assembled
  to typed dictionaries and unions for additional type checking.

  Full list of `SsmSap` TypeDefs can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_ssm_sap/type_defs/).

  ```python
  from types_boto3_ssm_sap.type_defs import ApplicationCredentialTypeDef


  def get_value() -> ApplicationCredentialTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `types-boto3-ssm-sap` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/types_boto3_docs/types_boto3_ssm_sap/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: 5a84ce79d7e551a3300a98f49cf3b9e64113abd500ce58855ee9fe20bc7d99b6
name: python-types-boto3-synthetics-help
arch: noarch
version: 1.35.83
epoch: 0
release: 1
summary: Development documents and examples for types-boto3-synthetics
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-boto3-synthetics-1.35.83-1.src.rpm
location_href: Packages/python-types-boto3-synthetics-help-1.35.83-1.noarch.rpm
checksum_type: sha256
description:
  <a id="types-boto3-synthetics"></a>



  [![PyPI - types-boto3-synthetics](https://img.shields.io/pypi/v/types-boto3-synthetics.svg?color=blue)](https://pypi.org/project/types-boto3-synthetics/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/types-boto3-synthetics.svg?color=blue)](https://pypi.org/project/types-boto3-synthetics/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/types_boto3_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/types-boto3-synthetics)](https://pypistats.org/packages/types-boto3-synthetics)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 Synthetics 1.35.83](https://pypi.org/project/boto3/) compatible with
  [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.6.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [types-boto3](https://pypi.org/project/types-boto3/) page and in
  [types-boto3-synthetics docs](https://youtype.github.io/types_boto3_docs/types_boto3_synthetics/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [types-boto3-synthetics](#types-boto3-synthetics)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.83' mypy_boto3_builder`
  2. Select `boto3` AWS SDK.
  3. Add `Synthetics` service.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `Synthetics`.

  <a id="from-pypi-with-pip"></a>



  Install `types-boto3` for `Synthetics` service.

  ```bash

  python -m pip install 'types-boto3[synthetics]'



  python -m pip install 'types-boto3-lite[synthetics]'


  python -m pip install types-boto3-synthetics
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y types-boto3-synthetics
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `types-boto3[synthetics]` in your environment:

  ```bash
  python -m pip install 'types-boto3[synthetics]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [types-boto3-lite](https://pypi.org/project/types-boto3-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `types-boto3` with
  > [types-boto3-lite](https://pypi.org/project/types-boto3-lite/):

  ```bash
  pip uninstall types-boto3
  pip install types-boto3-lite
  ```

  Install `types-boto3[synthetics]` in your environment:

  ```bash
  python -m pip install 'types-boto3[synthetics]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `types-boto3` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[synthetics]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `types-boto3`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `types-boto3[synthetics]` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[synthetics]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `types-boto3[synthetics]` in your environment:

  ```bash
  python -m pip install 'types-boto3[synthetics]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `types-boto3[synthetics]` in your environment:

  ```bash
  python -m pip install 'types-boto3[synthetics]'
  ```

  Optionally, you can install `types-boto3` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid
  `types-boto3-synthetics` dependency in production. However, there is an issue
  in `pylint` that it complains about undefined variables. To fix it, set all
  types to `object` in non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from types_boto3_ec2 import EC2Client, EC2ServiceResource
      from types_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from types_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `SyntheticsClient` provides annotations for `boto3.client("synthetics")`.

  ```python
  from boto3.session import Session

  from types_boto3_synthetics import SyntheticsClient

  client: SyntheticsClient = Session().client("synthetics")


  ```

  <a id="literals"></a>



  `types_boto3_synthetics.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  Full list of `Synthetics` Literals can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_synthetics/literals/).

  ```python
  from types_boto3_synthetics.literals import CanaryRunStateReasonCodeType


  def check_value(value: CanaryRunStateReasonCodeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `types_boto3_synthetics.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `Synthetics` TypeDefs can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_synthetics/type_defs/).

  ```python
  from types_boto3_synthetics.type_defs import S3EncryptionConfigTypeDef


  def get_value() -> S3EncryptionConfigTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `types-boto3-synthetics` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/types_boto3_docs/types_boto3_synthetics/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: 050e2c4aba4a6c90ea19128d9663fb482236529d27686a6595ef56302162659f
name: python-types-boto3-transfer-help
arch: noarch
version: 1.35.84
epoch: 0
release: 1
summary: Development documents and examples for types-boto3-transfer
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-boto3-transfer-1.35.84-1.src.rpm
location_href: Packages/python-types-boto3-transfer-help-1.35.84-1.noarch.rpm
checksum_type: sha256
description:
  <a id="types-boto3-transfer"></a>



  [![PyPI - types-boto3-transfer](https://img.shields.io/pypi/v/types-boto3-transfer.svg?color=blue)](https://pypi.org/project/types-boto3-transfer/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/types-boto3-transfer.svg?color=blue)](https://pypi.org/project/types-boto3-transfer/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/types_boto3_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/types-boto3-transfer)](https://pypistats.org/packages/types-boto3-transfer)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for [boto3 Transfer 1.35.84](https://pypi.org/project/boto3/)
  compatible with [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.6.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [types-boto3](https://pypi.org/project/types-boto3/) page and in
  [types-boto3-transfer docs](https://youtype.github.io/types_boto3_docs/types_boto3_transfer/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [types-boto3-transfer](#types-boto3-transfer)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Waiters annotations](#waiters-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.84' mypy_boto3_builder`
  2. Select `boto3` AWS SDK.
  3. Add `Transfer` service.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `Transfer`.

  <a id="from-pypi-with-pip"></a>



  Install `types-boto3` for `Transfer` service.

  ```bash

  python -m pip install 'types-boto3[transfer]'



  python -m pip install 'types-boto3-lite[transfer]'


  python -m pip install types-boto3-transfer
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y types-boto3-transfer
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `types-boto3[transfer]` in your environment:

  ```bash
  python -m pip install 'types-boto3[transfer]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [types-boto3-lite](https://pypi.org/project/types-boto3-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `types-boto3` with
  > [types-boto3-lite](https://pypi.org/project/types-boto3-lite/):

  ```bash
  pip uninstall types-boto3
  pip install types-boto3-lite
  ```

  Install `types-boto3[transfer]` in your environment:

  ```bash
  python -m pip install 'types-boto3[transfer]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `types-boto3` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[transfer]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `types-boto3`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `types-boto3[transfer]` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[transfer]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `types-boto3[transfer]` in your environment:

  ```bash
  python -m pip install 'types-boto3[transfer]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `types-boto3[transfer]` in your environment:

  ```bash
  python -m pip install 'types-boto3[transfer]'
  ```

  Optionally, you can install `types-boto3` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid
  `types-boto3-transfer` dependency in production. However, there is an issue in
  `pylint` that it complains about undefined variables. To fix it, set all types
  to `object` in non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from types_boto3_ec2 import EC2Client, EC2ServiceResource
      from types_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from types_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `TransferClient` provides annotations for `boto3.client("transfer")`.

  ```python
  from boto3.session import Session

  from types_boto3_transfer import TransferClient

  client: TransferClient = Session().client("transfer")


  ```

  <a id="paginators-annotations"></a>



  `types_boto3_transfer.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from types_boto3_transfer import TransferClient
  from types_boto3_transfer.paginator import (
      ListAccessesPaginator,
      ListAgreementsPaginator,
      ListCertificatesPaginator,
      ListConnectorsPaginator,
      ListExecutionsPaginator,
      ListFileTransferResultsPaginator,
      ListProfilesPaginator,
      ListSecurityPoliciesPaginator,
      ListServersPaginator,
      ListTagsForResourcePaginator,
      ListUsersPaginator,
      ListWebAppsPaginator,
      ListWorkflowsPaginator,
  )

  client: TransferClient = Session().client("transfer")



  list_accesses_paginator: ListAccessesPaginator = client.get_paginator("list_accesses")
  list_agreements_paginator: ListAgreementsPaginator = client.get_paginator("list_agreements")
  list_certificates_paginator: ListCertificatesPaginator = client.get_paginator("list_certificates")
  list_connectors_paginator: ListConnectorsPaginator = client.get_paginator("list_connectors")
  list_executions_paginator: ListExecutionsPaginator = client.get_paginator("list_executions")
  list_file_transfer_results_paginator: ListFileTransferResultsPaginator = client.get_paginator(
      "list_file_transfer_results"
  )
  list_profiles_paginator: ListProfilesPaginator = client.get_paginator("list_profiles")
  list_security_policies_paginator: ListSecurityPoliciesPaginator = client.get_paginator(
      "list_security_policies"
  )
  list_servers_paginator: ListServersPaginator = client.get_paginator("list_servers")
  list_tags_for_resource_paginator: ListTagsForResourcePaginator = client.get_paginator(
      "list_tags_for_resource"
  )
  list_users_paginator: ListUsersPaginator = client.get_paginator("list_users")
  list_web_apps_paginator: ListWebAppsPaginator = client.get_paginator("list_web_apps")
  list_workflows_paginator: ListWorkflowsPaginator = client.get_paginator("list_workflows")
  ```

  <a id="waiters-annotations"></a>



  `types_boto3_transfer.waiter` module contains type annotations for all waiters.

  ```python
  from boto3.session import Session

  from types_boto3_transfer import TransferClient
  from types_boto3_transfer.waiter import ServerOfflineWaiter, ServerOnlineWaiter

  client: TransferClient = Session().client("transfer")



  server_offline_waiter: ServerOfflineWaiter = client.get_waiter("server_offline")
  server_online_waiter: ServerOnlineWaiter = client.get_waiter("server_online")
  ```

  <a id="literals"></a>



  `types_boto3_transfer.literals` module contains literals extracted from shapes
  that can be used in user code for type checking.

  Full list of `Transfer` Literals can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_transfer/literals/).

  ```python
  from types_boto3_transfer.literals import AgreementStatusTypeType


  def check_value(value: AgreementStatusTypeType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `types_boto3_transfer.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `Transfer` TypeDefs can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_transfer/type_defs/).

  ```python
  from types_boto3_transfer.type_defs import As2ConnectorConfigTypeDef


  def get_value() -> As2ConnectorConfigTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `types-boto3-transfer` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/types_boto3_docs/types_boto3_transfer/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: 9e2d28483ec89f99e44075f9b78a74e1b03bd88b46ff9f67064b92551936c838
name: python-types-boto3-workspaces-help
arch: noarch
version: 1.35.85
epoch: 0
release: 1
summary: Development documents and examples for types-boto3-workspaces
url: https://github.com/youtype/mypy_boto3_builder
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-boto3-workspaces-1.35.85-1.src.rpm
location_href: Packages/python-types-boto3-workspaces-help-1.35.85-1.noarch.rpm
checksum_type: sha256
description:
  <a id="types-boto3-workspaces"></a>



  [![PyPI - types-boto3-workspaces](https://img.shields.io/pypi/v/types-boto3-workspaces.svg?color=blue)](https://pypi.org/project/types-boto3-workspaces/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/types-boto3-workspaces.svg?color=blue)](https://pypi.org/project/types-boto3-workspaces/)
  [![Docs](https://img.shields.io/readthedocs/boto3-stubs.svg?color=blue)](https://youtype.github.io/types_boto3_docs/)
  [![PyPI - Downloads](https://static.pepy.tech/badge/types-boto3-workspaces)](https://pypistats.org/packages/types-boto3-workspaces)

  ![boto3.typed](https://github.com/youtype/mypy_boto3_builder/raw/main/logo.png)

  Type annotations for
  [boto3 WorkSpaces 1.35.85](https://pypi.org/project/boto3/) compatible with
  [VSCode](https://code.visualstudio.com/),
  [PyCharm](https://www.jetbrains.com/pycharm/),
  [Emacs](https://www.gnu.org/software/emacs/),
  [Sublime Text](https://www.sublimetext.com/),
  [mypy](https://github.com/python/mypy),
  [pyright](https://github.com/microsoft/pyright) and other tools.

  Generated with
  [mypy-boto3-builder 8.6.4](https://github.com/youtype/mypy_boto3_builder).

  More information can be found on
  [types-boto3](https://pypi.org/project/types-boto3/) page and in
  [types-boto3-workspaces docs](https://youtype.github.io/types_boto3_docs/types_boto3_workspaces/).

  See how it helps you find and fix potential bugs:

  ![types-boto3 demo](https://github.com/youtype/mypy_boto3_builder/raw/main/demo.gif)

  - [types-boto3-workspaces](#types-boto3-workspaces)
    - [How to install](#how-to-install)
      - [Generate locally (recommended)](<#generate-locally-(recommended)>)
      - [VSCode extension](#vscode-extension)
      - [From PyPI with pip](#from-pypi-with-pip)
    - [How to uninstall](#how-to-uninstall)
    - [Usage](#usage)
      - [VSCode](#vscode)
      - [PyCharm](#pycharm)
      - [Emacs](#emacs)
      - [Sublime Text](#sublime-text)
      - [Other IDEs](#other-ides)
      - [mypy](#mypy)
      - [pyright](#pyright)
      - [Pylint compatibility](#pylint-compatibility)
    - [Explicit type annotations](#explicit-type-annotations)
      - [Client annotations](#client-annotations)
      - [Paginators annotations](#paginators-annotations)
      - [Literals](#literals)
      - [Type definitions](#type-definitions)
    - [How it works](#how-it-works)
    - [What's new](#what's-new)
      - [Implemented features](#implemented-features)
      - [Latest changes](#latest-changes)
    - [Versioning](#versioning)
    - [Thank you](#thank-you)
    - [Documentation](#documentation)
    - [Support and contributing](#support-and-contributing)

  <a id="how-to-install"></a>



  <a id="generate-locally-(recommended)"></a>



  You can generate type annotations for `boto3` package locally with
  `mypy_boto3_builder`. Use
  [uv](https://docs.astral.sh/uv/getting-started/installation/) for build
  isolation.

  1. Run mypy-boto3-builder in your package root directory:
     `uvx --with 'boto3==1.35.85' mypy_boto3_builder`
  2. Select `boto3` AWS SDK.
  3. Add `WorkSpaces` service.
  4. Use provided commands to install generated packages.

  <a id="vscode-extension"></a>



  Add
  [AWS Boto3](https://marketplace.visualstudio.com/items?itemName=Boto3typed.boto3-ide)
  extension to your VSCode and run `AWS boto3: Quick Start` command.

  Click `Modify` and select `boto3 common` and `WorkSpaces`.

  <a id="from-pypi-with-pip"></a>



  Install `types-boto3` for `WorkSpaces` service.

  ```bash

  python -m pip install 'types-boto3[workspaces]'



  python -m pip install 'types-boto3-lite[workspaces]'


  python -m pip install types-boto3-workspaces
  ```

  <a id="how-to-uninstall"></a>



  ```bash
  python -m pip uninstall -y types-boto3-workspaces
  ```

  <a id="usage"></a>



  <a id="vscode"></a>



  - Install
    [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python)
  - Install
    [Pylance extension](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
  - Set `Pylance` as your Python Language Server
  - Install `types-boto3[workspaces]` in your environment:

  ```bash
  python -m pip install 'types-boto3[workspaces]'
  ```

  Both type checking and code completion should now work. No explicit type
  annotations required, write your `boto3` code as usual.

  <a id="pycharm"></a>



  > ⚠️ Due to slow PyCharm performance on `Literal` overloads (issue
  > [PY-40997](https://youtrack.jetbrains.com/issue/PY-40997)), it is recommended
  > to use [types-boto3-lite](https://pypi.org/project/types-boto3-lite/) until
  > the issue is resolved.

  > ⚠️ If you experience slow performance and high CPU usage, try to disable
  > `PyCharm` type checker and use [mypy](https://github.com/python/mypy) or
  > [pyright](https://github.com/microsoft/pyright) instead.

  > ⚠️ To continue using `PyCharm` type checker, you can try to replace
  > `types-boto3` with
  > [types-boto3-lite](https://pypi.org/project/types-boto3-lite/):

  ```bash
  pip uninstall types-boto3
  pip install types-boto3-lite
  ```

  Install `types-boto3[workspaces]` in your environment:

  ```bash
  python -m pip install 'types-boto3[workspaces]'
  ```

  Both type checking and code completion should now work.

  <a id="emacs"></a>



  - Install `types-boto3` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[workspaces]'
  ```

  - Install [use-package](https://github.com/jwiegley/use-package),
    [lsp](https://github.com/emacs-lsp/lsp-mode/),
    [company](https://github.com/company-mode/company-mode) and
    [flycheck](https://github.com/flycheck/flycheck) packages
  - Install [lsp-pyright](https://github.com/emacs-lsp/lsp-pyright) package

  ```elisp
  (use-package lsp-pyright
    :ensure t
    :hook (python-mode . (lambda ()
                            (require 'lsp-pyright)
                            (lsp)))  ; or lsp-deferred
    :init (when (executable-find "python3")
            (setq lsp-pyright-python-executable-cmd "python3"))
    )
  ```

  - Make sure emacs uses the environment where you have installed `types-boto3`

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="sublime-text"></a>



  - Install `types-boto3[workspaces]` with services you use in your environment:

  ```bash
  python -m pip install 'types-boto3[workspaces]'
  ```

  - Install [LSP-pyright](https://github.com/sublimelsp/LSP-pyright) package

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="other-ides"></a>



  Not tested, but as long as your IDE supports `mypy` or `pyright`, everything
  should work.

  <a id="mypy"></a>



  - Install `mypy`: `python -m pip install mypy`
  - Install `types-boto3[workspaces]` in your environment:

  ```bash
  python -m pip install 'types-boto3[workspaces]'
  ```

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pyright"></a>



  - Install `pyright`: `npm i -g pyright`
  - Install `types-boto3[workspaces]` in your environment:

  ```bash
  python -m pip install 'types-boto3[workspaces]'
  ```

  Optionally, you can install `types-boto3` to `typings` directory.

  Type checking should now work. No explicit type annotations required, write
  your `boto3` code as usual.

  <a id="pylint-compatibility"></a>



  It is totally safe to use `TYPE_CHECKING` flag in order to avoid
  `types-boto3-workspaces` dependency in production. However, there is an issue
  in `pylint` that it complains about undefined variables. To fix it, set all
  types to `object` in non-`TYPE_CHECKING` mode.

  ```python
  from typing import TYPE_CHECKING

  if TYPE_CHECKING:
      from types_boto3_ec2 import EC2Client, EC2ServiceResource
      from types_boto3_ec2.waiters import BundleTaskCompleteWaiter
      from types_boto3_ec2.paginators import DescribeVolumesPaginator
  else:
      EC2Client = object
      EC2ServiceResource = object
      BundleTaskCompleteWaiter = object
      DescribeVolumesPaginator = object

  ...
  ```

  <a id="explicit-type-annotations"></a>



  <a id="client-annotations"></a>



  `WorkSpacesClient` provides annotations for `boto3.client("workspaces")`.

  ```python
  from boto3.session import Session

  from types_boto3_workspaces import WorkSpacesClient

  client: WorkSpacesClient = Session().client("workspaces")


  ```

  <a id="paginators-annotations"></a>



  `types_boto3_workspaces.paginator` module contains type annotations for all
  paginators.

  ```python
  from boto3.session import Session

  from types_boto3_workspaces import WorkSpacesClient
  from types_boto3_workspaces.paginator import (
      DescribeAccountModificationsPaginator,
      DescribeIpGroupsPaginator,
      DescribeWorkspaceBundlesPaginator,
      DescribeWorkspaceDirectoriesPaginator,
      DescribeWorkspaceImagesPaginator,
      DescribeWorkspacesConnectionStatusPaginator,
      DescribeWorkspacesPaginator,
      ListAccountLinksPaginator,
      ListAvailableManagementCidrRangesPaginator,
  )

  client: WorkSpacesClient = Session().client("workspaces")



  describe_account_modifications_paginator: DescribeAccountModificationsPaginator = (
      client.get_paginator("describe_account_modifications")
  )
  describe_ip_groups_paginator: DescribeIpGroupsPaginator = client.get_paginator("describe_ip_groups")
  describe_workspace_bundles_paginator: DescribeWorkspaceBundlesPaginator = client.get_paginator(
      "describe_workspace_bundles"
  )
  describe_workspace_directories_paginator: DescribeWorkspaceDirectoriesPaginator = (
      client.get_paginator("describe_workspace_directories")
  )
  describe_workspace_images_paginator: DescribeWorkspaceImagesPaginator = client.get_paginator(
      "describe_workspace_images"
  )
  describe_workspaces_connection_status_paginator: DescribeWorkspacesConnectionStatusPaginator = (
      client.get_paginator("describe_workspaces_connection_status")
  )
  describe_workspaces_paginator: DescribeWorkspacesPaginator = client.get_paginator(
      "describe_workspaces"
  )
  list_account_links_paginator: ListAccountLinksPaginator = client.get_paginator("list_account_links")
  list_available_management_cidr_ranges_paginator: ListAvailableManagementCidrRangesPaginator = (
      client.get_paginator("list_available_management_cidr_ranges")
  )
  ```

  <a id="literals"></a>



  `types_boto3_workspaces.literals` module contains literals extracted from
  shapes that can be used in user code for type checking.

  Full list of `WorkSpaces` Literals can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_workspaces/literals/).

  ```python
  from types_boto3_workspaces.literals import AGAModeForDirectoryEnumType


  def check_value(value: AGAModeForDirectoryEnumType) -> bool: ...
  ```

  <a id="type-definitions"></a>



  `types_boto3_workspaces.type_defs` module contains structures and shapes
  assembled to typed dictionaries and unions for additional type checking.

  Full list of `WorkSpaces` TypeDefs can be found in
  [docs](https://youtype.github.io/types_boto3_docs/types_boto3_workspaces/type_defs/).

  ```python
  from types_boto3_workspaces.type_defs import AcceptAccountLinkInvitationRequestRequestTypeDef


  def get_value() -> AcceptAccountLinkInvitationRequestRequestTypeDef:
      return {...}
  ```

  <a id="how-it-works"></a>



  Fully automated
  [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder) carefully
  generates type annotations for each service, patiently waiting for `boto3`
  updates. It delivers drop-in type annotations for you and makes sure that:

  - All available `boto3` services are covered.
  - Each public class and method of every `boto3` service gets valid type
    annotations extracted from `botocore` schemas.
  - Type annotations include up-to-date documentation.
  - Link to documentation is provided for every method.
  - Code is processed by [ruff](https://docs.astral.sh/ruff/) for readability.

  <a id="what's-new"></a>



  <a id="implemented-features"></a>



  - Fully type annotated `boto3`, `botocore`, `aiobotocore` and `aioboto3`
    libraries
  - `mypy`, `pyright`, `VSCode`, `PyCharm`, `Sublime Text` and `Emacs`
    compatibility
  - `Client`, `ServiceResource`, `Resource`, `Waiter` `Paginator` type
    annotations for each service
  - Generated `TypeDefs` for each service
  - Generated `Literals` for each service
  - Auto discovery of types for `boto3.client` and `boto3.resource` calls
  - Auto discovery of types for `session.client` and `session.resource` calls
  - Auto discovery of types for `client.get_waiter` and `client.get_paginator`
    calls
  - Auto discovery of types for `ServiceResource` and `Resource` collections
  - Auto discovery of types for `aiobotocore.Session.create_client` calls

  <a id="latest-changes"></a>



  Builder changelog can be found in
  [Releases](https://github.com/youtype/mypy_boto3_builder/releases).

  <a id="versioning"></a>



  `types-boto3-workspaces` version is the same as related `boto3` version and
  follows [PEP 440](https://www.python.org/dev/peps/pep-0440/) format.

  <a id="thank-you"></a>



  - [Allie Fitter](https://github.com/alliefitter) for
    [boto3-type-annotations](https://pypi.org/project/boto3-type-annotations/),
    this package is based on top of his work
  - [black](https://github.com/psf/black) developers for an awesome formatting
    tool
  - [Timothy Edmund Crosley](https://github.com/timothycrosley) for
    [isort](https://github.com/PyCQA/isort) and how flexible it is
  - [mypy](https://github.com/python/mypy) developers for doing all dirty work
    for us
  - [pyright](https://github.com/microsoft/pyright) team for the new era of typed
    Python

  <a id="documentation"></a>



  All services type annotations can be found in
  [boto3 docs](https://youtype.github.io/types_boto3_docs/types_boto3_workspaces/)

  <a id="support-and-contributing"></a>



  This package is auto-generated. Please reports any bugs or request new features
  in [mypy-boto3-builder](https://github.com/youtype/mypy_boto3_builder/issues/)
  repository.


pkgId: 93f8c3f9252fd517040b08bd019bb9a8d1db31937c2269bf492db141a00671c9
name: python-types-flake8-bugbear-help
arch: noarch
version: 24.12.12.20241214
epoch: 0
release: 1
summary: Development documents and examples for types-flake8-bugbear
url: https://github.com/python/typeshed
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-flake8-bugbear-24.12.12.20241214-1.src.rpm
location_href: Packages/python-types-flake8-bugbear-help-24.12.12.20241214-1.noarch.rpm
checksum_type: sha256
description:
  This is a [PEP 561](https://peps.python.org/pep-0561/)
  type stub package for the [`flake8-bugbear`](https://github.com/PyCQA/flake8-bugbear) package.
  It can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  [Pyre](https://pyre-check.org/),
  PyCharm, etc. to check code that uses `flake8-bugbear`. This version of
  `types-flake8-bugbear` aims to provide accurate annotations for
  `flake8-bugbear==24.12.12`.

  This stub package is marked as [partial](https://peps.python.org/pep-0561/#partial-stub-packages).
  If you find that annotations are missing, feel free to contribute and help complete them.


  This package is part of the [typeshed project](https://github.com/python/typeshed).
  All fixes for types and metadata should be contributed there.
  See [the README](https://github.com/python/typeshed/blob/main/README.md)
  for more details. The source for this package can be found in the
  [`stubs/flake8-bugbear`](https://github.com/python/typeshed/tree/main/stubs/flake8-bugbear)
  directory.

  This package was tested with
  mypy 1.13.0,
  pyright 1.1.389,
  and pytype 2024.10.11.
  It was generated from typeshed commit
  [`364fd7d18fe3dc7ae5a19801d15acdee0da10123`](https://github.com/python/typeshed/commit/364fd7d18fe3dc7ae5a19801d15acdee0da10123).


pkgId: 7b7a2fb373b2a60e2a55d5f6af48e85b1a801b2dc8ae918a0789a76cfb037676
name: python-types-ibm-db-help
arch: noarch
version: 3.2.4.20241216
epoch: 0
release: 1
summary: Development documents and examples for types-ibm-db
url: https://github.com/python/typeshed
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-ibm-db-3.2.4.20241216-1.src.rpm
location_href: Packages/python-types-ibm-db-help-3.2.4.20241216-1.noarch.rpm
checksum_type: sha256
description:
  This is a [PEP 561](https://peps.python.org/pep-0561/)
  type stub package for the [`ibm-db`](https://github.com/ibmdb/python-ibmdb) package.
  It can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  [Pyre](https://pyre-check.org/),
  PyCharm, etc. to check code that uses `ibm-db`. This version of
  `types-ibm-db` aims to provide accurate annotations for
  `ibm-db==3.2.4`.

  This package is part of the [typeshed project](https://github.com/python/typeshed).
  All fixes for types and metadata should be contributed there.
  See [the README](https://github.com/python/typeshed/blob/main/README.md)
  for more details. The source for this package can be found in the
  [`stubs/ibm-db`](https://github.com/python/typeshed/tree/main/stubs/ibm-db)
  directory.

  This package was tested with
  mypy 1.13.0,
  pyright 1.1.389,
  and pytype 2024.10.11.
  It was generated from typeshed commit
  [`7cae61f61a042a772010274dd1d8f1ee4454e5a4`](https://github.com/python/typeshed/commit/7cae61f61a042a772010274dd1d8f1ee4454e5a4).


pkgId: 41625415031d790745d850d5159c95ace5d4fdc40d7f0e6f4ec2d00ca6662c99
name: python-types-pycurl-help
arch: noarch
version: 7.45.4.20241216
epoch: 0
release: 1
summary: Development documents and examples for types-pycurl
url: https://github.com/python/typeshed
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-pycurl-7.45.4.20241216-1.src.rpm
location_href: Packages/python-types-pycurl-help-7.45.4.20241216-1.noarch.rpm
checksum_type: sha256
description:
  This is a [PEP 561](https://peps.python.org/pep-0561/)
  type stub package for the [`pycurl`](https://github.com/pycurl/pycurl) package.
  It can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  [Pyre](https://pyre-check.org/),
  PyCharm, etc. to check code that uses `pycurl`. This version of
  `types-pycurl` aims to provide accurate annotations for
  `pycurl==7.45.4`.

  This package is part of the [typeshed project](https://github.com/python/typeshed).
  All fixes for types and metadata should be contributed there.
  See [the README](https://github.com/python/typeshed/blob/main/README.md)
  for more details. The source for this package can be found in the
  [`stubs/pycurl`](https://github.com/python/typeshed/tree/main/stubs/pycurl)
  directory.

  This package was tested with
  mypy 1.13.0,
  pyright 1.1.389,
  and pytype 2024.10.11.
  It was generated from typeshed commit
  [`7cae61f61a042a772010274dd1d8f1ee4454e5a4`](https://github.com/python/typeshed/commit/7cae61f61a042a772010274dd1d8f1ee4454e5a4).


pkgId: c16dce45d344d166c79d46e68395994fc1e2987a67bad42cbb44a1b0377ff524
name: python-types-tqdm-help
arch: noarch
version: 4.67.0.20241220
epoch: 0
release: 1
summary: Development documents and examples for types-tqdm
url: https://github.com/python/typeshed
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-tqdm-4.67.0.20241220-1.src.rpm
location_href: Packages/python-types-tqdm-help-4.67.0.20241220-1.noarch.rpm
checksum_type: sha256
description:
  This is a [PEP 561](https://peps.python.org/pep-0561/)
  type stub package for the [`tqdm`](https://github.com/tqdm/tqdm) package.
  It can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  [Pyre](https://pyre-check.org/),
  PyCharm, etc. to check code that uses `tqdm`. This version of
  `types-tqdm` aims to provide accurate annotations for
  `tqdm==4.67.*`.

  This package is part of the [typeshed project](https://github.com/python/typeshed).
  All fixes for types and metadata should be contributed there.
  See [the README](https://github.com/python/typeshed/blob/main/README.md)
  for more details. The source for this package can be found in the
  [`stubs/tqdm`](https://github.com/python/typeshed/tree/main/stubs/tqdm)
  directory.

  This package was tested with
  mypy 1.13.0,
  pyright 1.1.389,
  and pytype 2024.10.11.
  It was generated from typeshed commit
  [`8e31597fa58e62df3064bf42600433df4f03a537`](https://github.com/python/typeshed/commit/8e31597fa58e62df3064bf42600433df4f03a537).


pkgId: 2fa514bdf9ce788e563b259709b8405f620c7394c800948105ea827af84c5ef7
name: python-types-vobject-help
arch: noarch
version: 0.9.9.20241219
epoch: 0
release: 1
summary: Development documents and examples for types-vobject
url: https://github.com/python/typeshed
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-types-vobject-0.9.9.20241219-1.src.rpm
location_href: Packages/python-types-vobject-help-0.9.9.20241219-1.noarch.rpm
checksum_type: sha256
description:
  This is a [PEP 561](https://peps.python.org/pep-0561/)
  type stub package for the [`vobject`](https://github.com/py-vobject/vobject) package.
  It can be used by type-checking tools like
  [mypy](https://github.com/python/mypy/),
  [pyright](https://github.com/microsoft/pyright),
  [pytype](https://github.com/google/pytype/),
  [Pyre](https://pyre-check.org/),
  PyCharm, etc. to check code that uses `vobject`. This version of
  `types-vobject` aims to provide accurate annotations for
  `vobject~=0.9.9`.

  This package is part of the [typeshed project](https://github.com/python/typeshed).
  All fixes for types and metadata should be contributed there.
  See [the README](https://github.com/python/typeshed/blob/main/README.md)
  for more details. The source for this package can be found in the
  [`stubs/vobject`](https://github.com/python/typeshed/tree/main/stubs/vobject)
  directory.

  This package was tested with
  mypy 1.13.0,
  pyright 1.1.389,
  and pytype 2024.10.11.
  It was generated from typeshed commit
  [`1964076a8e39119f6cf5f7f19be3e5c24e3743e6`](https://github.com/python/typeshed/commit/1964076a8e39119f6cf5f7f19be3e5c24e3743e6).


pkgId: b1aec8a86fec5ed5ed3b41842babbd988bb4fa9b58b18981eb1e3590b83ca86a
name: python-typeshed_stats-help
arch: noarch
version: 24.12.15
epoch: 0
release: 1
summary: Development documents and examples for typeshed_stats
url: https://github.com/AlexWaygood/typeshed-stats
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-typeshed_stats-24.12.15-1.src.rpm
location_href: Packages/python-typeshed_stats-help-24.12.15-1.noarch.rpm
checksum_type: sha256
description:
  <br>
  [![website](https://img.shields.io/website?down_color=red&down_message=Offline&style=for-the-badge&up_color=green&up_message=Running&url=https%3A%2F%2Falexwaygood.github.io%2Ftypeshed-stats%2F)](https://alexwaygood.github.io/typeshed-stats/)[![build status](https://img.shields.io/github/actions/workflow/status/AlexWaygood/typeshed-stats/test.yml?branch=main&label=Tests&style=for-the-badge)](https://github.com/AlexWaygood/typeshed-stats/actions/workflows/test.yml)
  <br>
  [![Checked with mypy](https://img.shields.io/badge/mypy-checked-blue?style=for-the-badge)](http://mypy-lang.org/)[![Code style: Ruff](https://img.shields.io/badge/Code_style-Ruff-D7FF64?style=for-the-badge&logo=ruff)](https://github.com/astral-sh/ruff)[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge)](https://pre-commit.ci)
  <br>


pkgId: 83d014a108886a3e5cb98f4b95c47f0e660b734b5a07778904141d238ca50fb6
name: python-uagents-ai-engine-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for uagents-ai-engine
url: https://pypi.org/project/uagents-ai-engine/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uagents-ai-engine-0.7.0-1.src.rpm
location_href: Packages/python-uagents-ai-engine-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  This package provides the necessary types for integrating AI-Engine with UAgents, enabling structured responses and request handling within the UAgents framework. It includes models for handling various response types, key-value pairs, and booking requests.



  To install the package, use the following command:

  ```bash
  pip install uagents-ai-engine
  ```





  To use the models provided by this package, import them as follows:

  ```python
  from ai_engine.chitchat import ChitChatDialogue
  from ai_engine.messages import DialogueMessage
  from ai_engine.dialogue import EdgeMetadata, EdgeDescription
  ```

  The `chitchat`, `messages`, and `dialogue` modules provide essential classes, types, and functions to facilitate structured and dynamic interactions with the agent. These modules support an open-ended communication model, allowing users to engage in an ongoing dialogue with the agent. After each user message, the agent responds, enabling a continuous and interactive conversation that can proceed as long as needed.

  ```python
  from ai_engine.types import UAgentResponseType, KeyValue, UAgentResponse, BookingRequest
  ```

  The `types` module offers a comprehensive set of models for handling responses, key-value pairs, and booking requests. This module is designed for scenarios where a single exchange is sufficient. The user sends a message, receives a well-structured response from the agent, and the interaction concludes efficiently. This approach is ideal for straightforward queries and tasks.





  The following classes are used for non-dialogue agent communication.



  An enumeration defining the types of responses that an agent can provide:

  ```python
  class UAgentResponseType(Enum):
      FINAL = "final"
      ERROR = "error"
      VALIDATION_ERROR = "validation_error"
      SELECT_FROM_OPTIONS = "select_from_options"
      FINAL_OPTIONS = "final_options"
  ```



  A model representing a key-value pair. It is usually used by the AI-Engine as a way to provide multiple choice options to the user:

  ```python
  class KeyValue(Model):
      key: str
      value: str
  ```



  A model for structuring the response from an agent:

  ```python
  class UAgentResponse(Model):
      version: Literal["v1"] = "v1"
      type: UAgentResponseType
      request_id: Optional[str]
      agent_address: Optional[str]
      message: Optional[str]
      options: Optional[List[KeyValue]]
      verbose_message: Optional[str]
      verbose_options: Optional[List[KeyValue]]
  ```

  **Attributes:**

  - `version`: The version of the response model (default is "v1").
  - `type`: The type of the response, based on `UAgentResponseType`.
  - `request_id`: An optional identifier for the request.
  - `agent_address`: An optional address of the agent.
  - `message`: An optional message from the agent.
  - `options`: An optional list of key-value options.
  - `verbose_message`: An optional verbose message from the agent.
  - `verbose_options`: An optional list of verbose key-value options.



  A model for handling booking requests:

  ```python
  class BookingRequest(Model):
      request_id: str
      user_response: str
      user_email: str
      user_full_name: str
  ```

  **Attributes:**

  - `request_id`: The unique identifier for the booking request.
  - `user_response`: The response from the user.
  - `user_email`: The email address of the user.
  - `user_full_name`: The full name of the user.





  A specific dialogue class for AI-Engine enabled chit-chat:

  ```python
  class ChitChatDialogue(Dialogue):
      def on_initiate_session(self, model: Type[Model]):
          

      def on_reject_session(self, model: Type[Model]):
          

      def on_start_dialogue(self, model: Type[Model]):
          

      def on_continue_dialogue(self, model: Type[Model]):
          

      def on_end_session(self, model: Type[Model]):
          
  ```

  How to initialize a `ChitChatDialogue` instance:

  ```python

  agent = Agent()


  chitchat_dialogue = ChitChatDialogue(
      version="0.1",
      storage=agent.storage,
  )
  ```

  For a more in depth example, see the [ChitChatDialogue](https://github.com/fetchai/uAgents/blob/main/integrations/fetch-ai-engine/examples/simple_agent.py) example.





  Metadata for the edges to specify targets and observability:

  - `system` implies AI Engine processing
  - `user` is direct message to the user
  - `ai` is a message to the AI Engine
  - `agent` is a message to the agent.

  ```python
  class EdgeMetadata(BaseModel):
      target: Literal["user", "ai", "system", "agent"]
      observable: bool
  ```



  A structured description for the edge:

  ```python
  class EdgeDescription(BaseModel):
      description: str
      metadata: EdgeMetadata
  ```



  Function to create an edge with metadata:

  ```python
  init_session = create_edge(
      name="Initiate session",
      description="Every dialogue starts with this transition.",
      target="user",
      observable=True,
      parent=default_state,
      child=init_state,
  )
  ```



  The following classes are used for dialogue agent communication.



  A base model for all messages:

  ```python
  class BaseMessage(Model):
      message_id: UUID
      timestamp: datetime
  ```



  A model for generic dialogue messages:

  ```python
  class DialogueMessage(BaseMessage):
      type: Literal["agent_message", "agent_json", "user_message"]
      agent_message: Optional[str]
      agent_json: Optional[AgentJSON]
      user_message: Optional[str]
  ```

  Can be initialized as follows, we'll call this class `ChitChatDialogueMessage`:

  ```python
  class ChitChatDialogueMessage(DialogueMessage):
      """ChitChat dialogue message"""

      pass
  ```

  And then use it as follows:

  ```python
  @chitchat_dialogue.on_continue_dialogue(ChitChatDialogueMessage)
  ```

  Where `chitchat_dialogue` is defined above in the `ChitChatDialogue` section and `on_continue_dialogue` is a method of the `ChitChatDialogue` class that can be extended.



  This integration adds the required types for AI-Engine to interact with UAgents effectively. The `UAgentResponse` model serves as the primary structure for agent responses, while `BookingRequest` handles user booking requests.



  `UAgentResponse` digest:

  ```
  model:cf0d1367c5f9ed8a269de559b2fbca4b653693bb8315d47eda146946a168200e
  ```


pkgId: 7f38b82304a7c6db71d2269672b595d7e72ce781c615af014fbe15dd0e53fb29
name: python-uagents-help
arch: noarch
version: 0.18.0
epoch: 0
release: 1
summary: Development documents and examples for uagents
url: https://pypi.org/project/uagents/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uagents-0.18.0-1.src.rpm
location_href: Packages/python-uagents-help-0.18.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Official Website](https://img.shields.io/badge/Official%20Website-fetch.ai-blue?style=flat&logo=world&logoColor=white)](https://fetch.ai) [![Unit Tests](https://img.shields.io/github/actions/workflow/status/Fetchai/uAgents/ci-tests.yml?label=unit%20tests)](https://github.com/Fetchai/uAgents/actions/workflows/ci-tests.yml) [![GitHub Repo stars](https://img.shields.io/github/stars/Fetchai/uAgents?style=social)](https://github.com/Fetchai/uAgents/stargazers) [![Twitter Follow](https://img.shields.io/twitter/follow/fetch_ai?style=social)](https://twitter.com/fetch_ai)

  uAgents is a library developed by Fetch.ai that allows for creating autonomous AI agents in Python. With simple and expressive decorators, you can have an agent that performs various tasks on a schedule or takes action on various events.



  - 🤖 **Easy creation and management**: Create any type of agent you can think of and implement it in code.
  - 🔗 **Connected**: On startup, each agent automatically joins the fast growing network of uAgents by registering on the Almanac, a smart contract deployed on the Fetch.ai blockchain.
  - 🔒 **Secure**: uAgent messages and wallets are cryptographically secured, so their identities and assets are protected.





  Get started with uAgents by installing it for Python 3.9 to 3.12:

      pip install uagents





  Build your first uAgent using the following script:

  ```python3
  from uagents import Agent, Context
  alice = Agent(name="alice", seed="alice recovery phrase")
  ```

  Include a seed parameter when creating an agent to set fixed addresses, or leave it out to generate a new random address each time.



  Give it a simple task, such as a greeting:

  ```python3
  @alice.on_interval(period=2.0)
  async def say_hello(ctx: Context):
      ctx.logger.info(f'hello, my name is {ctx.agent.name}')

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



  So far, your code should look like this:

  ```python3
  from uagents import Agent, Context

  alice = Agent(name="alice", seed="alice recovery phrase")

  @alice.on_interval(period=2.0)
  async def say_hello(ctx: Context):
      ctx.logger.info(f'hello, my name is {ctx.agent.name}')

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

  Run it using:

  ```bash
  python agent.py
  ```

  You should see the results in your terminal.



  Please see the [official documentation](https://fetch.ai/docs) for full setup instructions and advanced features.

  - [👋 Introduction](https://fetch.ai/docs/concepts/agents/agents)
  - [💻 Installation](https://fetch.ai/docs/guides/agents/installing-uagent)
  - Tutorials
    - [🤖 Create an agent](https://fetch.ai/docs/guides/agents/create-a-uagent)
    - [🛣️ Agent Communication](https://fetch.ai/docs/guides/agents/communicating-with-other-agents)
    - [🍽️ Restaurant Booking Demo](https://fetch.ai/docs/guides/agents/booking-demo)
  - Key Concepts:
    - [📍Addresses](https://fetch.ai/docs/guides/agents/getting-uagent-address)
    - [💾 Storage](https://fetch.ai/docs/guides/agents/storage-function)
    - [📝 Interval Tasks](https://fetch.ai/docs/guides/agents/interval-task)
    - [🌐 Agent Broadcast](https://fetch.ai/docs/guides/agents/broadcast)
    - [⚙️ Almanac Contracts](https://fetch.ai/docs/guides/agents/register-in-almanac)



  The [`examples`](https://github.com/fetchai/uAgents/tree/main/python/examples) folder contains several examples of how to create and run various types of agents.



  The [`integrations`](https://github.com/fetchai/uAgents/tree/main/integrations) folder contains examples that provide a more in depth use of the uAgents library.



  Go to the [`python`](https://github.com/fetchai/uAgents/tree/main/python) folder for details on the Python uAgents library.



  All contributions are welcome! Remember, contribution includes not only code, but any help with docs or issues raised by other developers. See our [contribution guidelines](https://github.com/fetchai/uAgents/blob/main/CONTRIBUTING.md) for more details.



  Read our [development guidelines](https://github.com/fetchai/uAgents/blob/main/DEVELOPING.md) to learn some useful tips related to development.



  We use [GitHub Issues](https://github.com/fetchai/uAgents/issues) for tracking requests and bugs, and [GitHub Discussions](https://github.com/fetchai/uAgents/discussions) for general questions and discussion.



  This project, uAgents, is provided "as-is" without any warranty, express or implied. By using this software, you agree to assume all risks associated with its use, including but not limited to unexpected behavior, data loss, or any other issues that may arise. The developers and contributors of this project do not accept any responsibility or liability for any losses, damages, or other consequences that may occur as a result of using this software.



  The uAgents project is licensed under [Apache License 2.0](https://github.com/fetchai/uAgents/blob/main/LICENSE).


pkgId: c6e7651847d9a2e8a4b5275df62d5d9f2d20cc3e1e473e0ac75acc1ff261cded
name: python-udata-hydra-help
arch: noarch
version: 2.0.5
epoch: 0
release: 1
summary: Development documents and examples for udata-hydra
url: https://pypi.org/project/udata-hydra/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-udata-hydra-2.0.5-1.src.rpm
location_href: Packages/python-udata-hydra-help-2.0.5-1.noarch.rpm
checksum_type: sha256
description:
  `udata-hydra` is an async metadata crawler for [data.gouv.fr](https://www.data.gouv.fr).

  URLs are crawled via _aiohttp_, catalog and crawled metadata are stored in a _PostgreSQL_ database.

  Since it's called _hydra_, it also has mythical powers embedded:
  - analyse remote resource metadata over time to detect changes in the smartest way possible
  - if the remote resource is a CSV, convert it to a PostgreSQL table, ready for APIfication
  - send crawl and analysis info to a udata instance



  The architecture for the full workflow is the following:

  ![Full workflow architecture](docs/archi-idd-IDD.drawio.png)


  The hydra crawler is one of the components of the architecture. It will check if resource is available, analyse the type of file if the resource has been modified, and analyse the CSV content. It will also convert CSV resources to database tables and send the data to a udata instance.

  ![Crawler architecture](docs/hydra.drawio.png)



  This project uses `libmagic`, which needs to be installed on your system, eg:

  `brew install libmagic` on MacOS, or `sudo apt-get install libmagic-dev` on linux.





  Install udata-hydra dependencies and cli.
  `poetry install`

  `poetry run udata-hydra migrate`



  `poetry run udata-hydra load-catalog`



  `poetry run udata-hydra-crawl`

  It will crawl (forever) the catalog according to the config set in `config.toml`, with a default config in `udata_hydra/config_default.toml`.

  `BATCH_SIZE` URLs are queued at each loop run.

  The crawler will start with URLs never checked and then proceed with URLs crawled before `SINCE` interval. It will then wait until something changes (catalog or time).

  There's a by-domain backoff mecanism. The crawler will wait when, for a given domain in a given batch, `BACKOFF_NB_REQ` is exceeded in a period of `BACKOFF_PERIOD` seconds. It will retry until the backoff is lifted.

  If an URL matches one of the `EXCLUDED_PATTERNS`, it will never be checked.



  A job queuing system is used to process long-running tasks. Launch the worker with the following command:

  `poetry run rq worker -c udata_hydra.worker`

  Monitor worker status:

  `poetry run rq info -c udata_hydra.worker --interval 1`



  Converted CSV tables will be stored in the database specified via `config.DATABASE_URL_CSV`. For tests it's same database as for the catalog. Locally, `docker compose` will launch two distinct database containers.



  To run the tests, you need to launch the database, the test database, and the Redis broker with `docker compose -f docker-compose.yml -f docker-compose.test.yml -f docker-compose.broker.yml up -d`.

  Then you can run the tests with `poetry run pytest`.

  To run a specific test file, you can pass the path to the file to pytest, like this: `poetry run pytest tests/test_app.py`.

  To run a specific test function, you can pass the path to the file and the name of the function to pytest, like this: `poetry run pytest tests/test_app.py::test_get_latest_check`.

  If you would like to see print statements as they are executed, you can pass the -s flag to pytest (`poetry run pytest -s`). However, note that this can sometimes be difficult to parse.



  Pytest automatically uses the `coverage` package to generate a coverage report, which is displayed at the end of the test run in the terminal.
  The coverage is configured in the `pypoject.toml` file, in the `[tool.pytest.ini_options]` section.
  You can also override the coverage report configuration when running the tests by passing some flags like `--cov-report` to pytest. See [the pytest-cov documentation](https://pytest-cov.readthedocs.io/en/latest/config.html) for more information.



  The API will need a Bearer token for each request on protected endpoints (any endpoint that isn't a `GET`).
  The token is configured in the `config.toml` file as `API_KEY`, and has a default value set in the `udata_hydra/config_default.toml` file.

  If you're using hydra as an external service to receive resource events from [udata](https://github.com/opendatateam/udata), then udata needs to also configure this
  API key in its `udata.cfg` file:

  ```python

  PUBLISH_ON_RESOURCE_EVENTS = True

  RESOURCES_ANALYSER_URI = "http://localhost:8000"

  RESOURCES_ANALYSER_API_KEY = "api_key_to_change"
  ```



  ```bash
  poetry install
  poetry run adev runserver udata_hydra/app.py
  ```



  The API serves the following endpoints:

  *Related to checks:*
  - `GET` on `/api/checks/latest?url={url}&resource_id={resource_id}` to get the latest check for a given URL and/or `resource_id`
  - `GET` on `/api/checks/all?url={url}&resource_id={resource_id}` to get all checks for a given URL and/or `resource_id`
  - `GET` on `/api/checks/aggregate?group_by={column}&created_at={date}` to get checks occurences grouped by a `column` for a specific `date`

  *Related to resources:*
  - `GET` on `/api/resource/{resource_id}` to get a resource in the DB "catalog" table from its `resource_id`
  - `POST` on `/api/resources` to receive a resource creation event from a source. It will create a new resource in the DB "catalog" table and mark it as priority for next crawling
  - `PUT` on `/api/resources/{resource_id}` to update a resource in the DB "catalog" table
  - `DELETE` on `/api/resources/{resource_id}` to delete a resource in the DB "catalog" table

  > :warning: **Warning: the following routes are deprecated and need be removed in the future:**
  > - `POST` on `/api/resource/created` -> use `POST` on `/api/resources/` instead
  > - `POST` on `/api/resource/updated` -> use `PUT` on `/api/resources/` instead
  > - `POST` on `/api/resource/deleted` -> use `DELET`E on `/api/resources/` instead

  *Related to resources exceptions:*
  - `GET` on `/api/resources-exceptions` to get the list all resources exceptions
  - `POST` on `/api/resources-exceptions` to create a new resource exception in the DB
  - `PUT` on `/api/resources-exceptions/{resource_id}` to update a resource exception in the DB
  - `DELETE` on `/api/resources-exceptions/{resource_id}` to delete a resource exception from the DB

  *Related to some status and health check:*
  - `GET` on `/api/status/crawler` to get the crawling status
  - `GET` on `/api/status/worker` to get the worker status
  - `GET` on `/api/stats` to get the crawling stats
  - `GET` on `/api/health` to get the API version number and environment

  More details about some enpoints are provided below with examples, but not for all of them:



  Works with `?url={url}` and `?resource_id={resource_id}`.

  ```bash
  $ curl -s "http://localhost:8000/api/checks/latest?url=http://opendata-sig.saintdenis.re/datasets/661e19974bcc48849bbff7c9637c5c28_1.csv" | json_pp
  {
     "status" : 200,
     "catalog_id" : 64148,
     "deleted" : false,
     "error" : null,
     "created_at" : "2021-02-06T12:19:08.203055",
     "response_time" : 0.830198049545288,
     "url" : "http://opendata-sig.saintdenis.re/datasets/661e19974bcc48849bbff7c9637c5c28_1.csv",
     "domain" : "opendata-sig.saintdenis.re",
     "timeout" : false,
     "id" : 114750,
     "dataset_id" : "5c34944606e3e73d4a551889",
     "resource_id" : "b3678c59-5b35-43ad-9379-fce29e5b56fe",
     "headers" : {
        "content-disposition" : "attachment; filename=\"xn--Dlimitation_des_cantons-bcc.csv\"",
        "server" : "openresty",
        "x-amz-meta-cachetime" : "191",
        "last-modified" : "Wed, 29 Apr 2020 02:19:04 GMT",
        "content-encoding" : "gzip",
        "content-type" : "text/csv",
        "cache-control" : "must-revalidate",
        "etag" : "\"20415964703d9ccc4815d7126aa3a6d8\"",
        "content-length" : "207",
        "date" : "Sat, 06 Feb 2021 12:19:08 GMT",
        "x-amz-meta-contentlastmodified" : "2018-11-19T09:38:28.490Z",
        "connection" : "keep-alive",
        "vary" : "Accept-Encoding"
     }
  }
  ```



  Works with `?url={url}` and `?resource_id={resource_id}`.

  ```bash
  $ curl -s "http://localhost:8000/api/checks/all?url=http://www.drees.sante.gouv.fr/IMG/xls/er864.xls" | json_pp
  [
     {
        "domain" : "www.drees.sante.gouv.fr",
        "dataset_id" : "53d6eadba3a72954d9dd62f5",
        "timeout" : false,
        "deleted" : false,
        "response_time" : null,
        "error" : "Cannot connect to host www.drees.sante.gouv.fr:443 ssl:True [SSLCertVerificationError: (1, \"[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: Hostname mismatch, certificate is not valid for 'www.drees.sante.gouv.fr'. (_ssl.c:1122)\")]",
        "catalog_id" : 232112,
        "url" : "http://www.drees.sante.gouv.fr/IMG/xls/er864.xls",
        "headers" : {},
        "id" : 165107,
        "created_at" : "2021-02-06T14:32:47.675854",
        "resource_id" : "93dfd449-9d26-4bb0-a6a9-ee49b1b8a4d7",
        "status" : null
     },
     {
        "timeout" : false,
        "deleted" : false,
        "response_time" : null,
        "error" : "Cannot connect to host www.drees.sante.gouv.fr:443 ssl:True [SSLCertVerificationError: (1, \"[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: Hostname mismatch, certificate is not valid for 'www.drees.sante.gouv.fr'. (_ssl.c:1122)\")]",
        "domain" : "www.drees.sante.gouv.fr",
        "dataset_id" : "53d6eadba3a72954d9dd62f5",
        "created_at" : "2020-12-24T17:06:58.158125",
        "resource_id" : "93dfd449-9d26-4bb0-a6a9-ee49b1b8a4d7",
        "status" : null,
        "catalog_id" : 232112,
        "url" : "http://www.drees.sante.gouv.fr/IMG/xls/er864.xls",
        "headers" : {},
        "id" : 65092
     }
  ]
  ```



  Works with `?group_by={column}` and `?created_at={date}`.
  `date` should be a date in format `YYYY-MM-DD` or the default keyword `today`.

  ```bash
  $ curl -s "http://localhost:8000/api/checks/aggregate?group_by=domain&created_at=today" | json_pp
  [
    {
      "value": "www.geo2france.fr",
      "count": 4
    },
    {
      "value": "static.data.gouv.fr",
      "count": 4
    },
    {
      "value": "grandestprod.data4citizen.com",
      "count": 3
    },
    {
      "value": "www.datasud.fr",
      "count": 2
    },
    {
      "value": "koumoul.com",
      "count": 2
    },
    {
      "value": "opendata.aude.fr",
      "count": 2
    },
    {
      "value": "departement-ain.opendata.arcgis.com",
      "count": 2
    },
    {
      "value": "opendata.agglo-larochelle.fr",
      "count": 1
    }
  ]
  ```



  ```bash
  $ curl   -X POST http://localhost:8000/api/resources-exceptions \
           -H 'Authorization: Bearer <myAPIkey>' \
           -d '{
              "resource_id": "123e4567-e89b-12d3-a456-426614174000",
              "table_indexes": {
                    "siren": "index"
              },
              "comment": "This is a comment for the resource exception."
           }'
  ```

  ...or, if you don't want to add table indexes and a comment:
  ```bash
  $ curl  -X POST localhost:8000/api/resources-exceptions \
          -H 'Authorization: Bearer <myAPIkey>" \
          -d '{"resource_id": "f868cca6-8da1-4369-a78d-47463f19a9a3"}'
  ```



  ```bash
  $ curl   -X PUT http://localhost:8000/api/resources-exceptions/f868cca6-8da1-4369-a78d-47463f19a9a3 \
           -H "Authorization: Bearer <myAPIkey>" \
           -d '{
              "table_indexes": {
                    "siren": "index",
                    "code_postal": "index"
              },
              "comment": "Updated comment for the resource exception."
           }'
  ```



  ```bash
  $ curl  -X DELETE http://localhost:8000/api/resources-exceptions/f868cca6-8da1-4369-a78d-47463f19a9a3 \
          -H "Authorization: Bearer <myAPIkey>"
  ```



  ```bash
  $ curl -s "http://localhost:8000/api/status/crawler" | json_pp
  {
     "fresh_checks_percentage" : 0.4,
     "pending_checks" : 142153,
     "total" : 142687,
     "fresh_checks" : 534,
     "checks_percentage" : 0.4,
     "resources_statuses_count": {
        "null": 195339,
        "BACKOFF": 0,
        "CRAWLING_URL": 0,
        "TO_ANALYSE_RESOURCE": 1,
        "ANALYSING_RESOURCE": 0,
        "TO_ANALYSE_CSV": 0,
        "ANALYSING_CSV": 0,
        "INSERTING_IN_DB": 0,
        "CONVERTING_TO_PARQUET": 0
    }
  }
  ```



  ```bash
  $ curl -s "http://localhost:8000/api/status/worker" | json_pp
  {
     "queued" : {
        "default" : 0,
        "high" : 825,
        "low" : 655
     }
  }
  ```



  ```bash
  $ curl -s "http://localhost:8000/api/stats" | json_pp
  {
     "status" : [
        {
           "count" : 525,
           "percentage" : 98.3,
           "label" : "ok"
        },
        {
           "label" : "error",
           "percentage" : 1.3,
           "count" : 7
        },
        {
           "label" : "timeout",
           "percentage" : 0.4,
           "count" : 2
        }
     ],
     "status_codes" : [
        {
           "code" : 200,
           "count" : 413,
           "percentage" : 78.7
        },
        {
           "code" : 501,
           "percentage" : 12.4,
           "count" : 65
        },
        {
           "percentage" : 6.1,
           "count" : 32,
           "code" : 404
        },
        {
           "code" : 500,
           "percentage" : 2.7,
           "count" : 14
        },
        {
           "code" : 502,
           "count" : 1,
           "percentage" : 0.2
        }
     ]
  }
  ```



  ** Set the config values**

  Create a `config.toml` where your service and commands are launched, or specify a path to a TOML file via the `HYDRA_SETTINGS` environment variable. `config.toml` or equivalent will override values from `udata_hydra/config_default.toml`, lookup there for values that can/need to be defined.

  ```toml
  UDATA_URI = "https://dev.local:7000/api/2"
  UDATA_URI_API_KEY = "example.api.key"
  SENTRY_DSN = "https://{my-sentry-dsn}"
  ```

  The webhook integration sends HTTP messages to `udata` when resources are analysed or checked to fill resources extras.

  Regarding analysis, there is a phase called "change detection". It will try to guess if a resource has been modified based on different criterions:
  - harvest modified date in catalog
  - content-length and last-modified headers
  - checksum comparison over time

  The payload should look something like:

  ```json
  {
     "analysis:content-length": 91661,
     "analysis:mime-type": "application/zip",
     "analysis:checksum": "bef1de04601dedaf2d127418759b16915ba083be",
     "analysis:last-modified-at": "2022-11-27T23:00:54.762000",
     "analysis:last-modified-detection": "harvest-resource-metadata",
  }
  ```





  Multiple docker-compose files are provided:
  - a minimal `docker-compose.yml` with two PostgreSQL containers (one for catalog and metadata, the other for converted CSV to database)
  - `docker-compose.broker.yml` adds a Redis broker
  - `docker-compose.test.yml` launches a test DB, needed to run tests

  NB: you can launch compose from multiple files like this: `docker compose -f docker-compose.yml -f docker-compose.test.yml up`



  The log level can be adjusted using the environment variable LOG_LEVEL.
  For example, to set the log level to `DEBUG` when initializing the database, use `LOG_LEVEL="DEBUG" udata-hydra init_db `.



  1. Add a file named `migrations/{YYYYMMDD}_{description}.sql` and write the SQL you need to perform migration.
  2. `udata-hydra migrate` will migrate the database as needeed.



  3 services need to be deployed for the full stack to run:
  - worker
  - api / app
  - crawler

  Refer to each section to learn how to launch them. The only differences from dev to prod are:
  - use `HYDRA_SETTINGS` env var to point to your custom `config.toml`
  - use `HYDRA_APP_SOCKET_PATH` to configure where aiohttp should listen to a [reverse proxy connection (eg nginx)](https://docs.aiohttp.org/en/stable/deployment.html#nginx-configuration) and use `udata-hydra-app` to launch the app server



  Before contributing to the repository and making any PR, it is necessary to initialize the pre-commit hooks:
  ```bash
  pre-commit install
  ```
  Once this is done, code formatting and linting, as well as import sorting, will be automatically checked before each commit.

  If you cannot use pre-commit, it is necessary to format, lint, and sort imports with [Ruff](https://docs.astral.sh/ruff/) before committing:
  ```bash
  ruff check --fix .
  ruff format .
  ```


pkgId: 278d80c43c5cb9bc5153624a49936a1f2797ad2096a4afc74a07a66dd27f7133
name: python-ufig-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for ufig
url: https://pypi.org/project/ufig/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ufig-1.0.0-1.src.rpm
location_href: Packages/python-ufig-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/)
  [![PyPI pyversions](https://img.shields.io/pypi/pyversions/ufig.svg)](https://pypi.python.org/pypi/ufig/)
  [![PyPI version](https://badge.fury.io/py/ufig.svg)](https://badge.fury.io/py/ufig)
  [![pipeline](https://gitlab.com/cosmology-ethz/ufig/badges/main/pipeline.svg)](https://gitlab.com/cosmology-ethz/ufig/-/pipelines)
  [![coverage](https://gitlab.com/cosmology-ethz/ufig/badges/main/coverage.svg)](https://gitlab.com/cosmology-ethz/ufig)
  <a href="https://cosmo-docs.phys.ethz.ch/ufig/htmlcov/index.html">
    <img src="https://img.shields.io/badge/coverage_report-green"
      alt="coverage report"/>
  </a>

  [![image](https://img.shields.io/badge/arXiv-1209.1200-B31B1B.svg?logo=arxiv&style=flat)](https://arxiv.org/abs/1209.1200)
  [![image](https://img.shields.io/badge/arXiv-2412.08716-B31B1B.svg?logo=arxiv&style=flat)](https://arxiv.org/abs/2412.08716)
  [![Docs](https://badgen.net/badge/icon/Documentation?icon=https://cdn.jsdelivr.net/npm/simple-icons@v13/icons/gitbook.svg&label)](https://cosmo-docs.phys.ethz.ch/ufig/)
  [![Source Code](https://badgen.net/badge/icon/Source%20Code?icon=github&label)](https://gitlab.com/cosmology-ethz/ufig)

  Simulate realistic astronomical images with high-speed and modular adjustable image properties according to the user.

  For the original paper describing this project, see: [Bergé et al. (2013)](http://arxiv.org/abs/1209.1200).
  The first public release of UFig is descibed in [Fischbacher et al. (2024)](https://arxiv.org/abs/2412.08716).



  To install the latest release from PyPI, use pip:

  ```bash
  pip install ufig
  ```



  - Ultra fast speed
  - Modular structure that can be easily integrated and expanded
  - User interacts with the program through Python scripts
  - Structured unit tests for continuous robust development

  Note: For not supported features, see the plugins (including the deprecated ones)
  in the archive branch (https://gitlab.com/cosmology-ethz/ufig/-/tree/old_master_before_11_2024).



  The **Ultra Fast Image Generator (UFig)** is an image simulation tool that generates simulated astronomical images for scientific usage.

  The code is implemented in pure Python and highly optimized in terms of speed.

  The output images are useful for developing analysis algorithms and data processing pipelines in the field of astronomy/cosmology.

  Conceptually, a typical UFig program involves two things:

  1. **Config file:** sets up the workflow by calling a series of plugins.

     The content in each config file includes importing or setting the relevant input parameters and arranging the list of plugins that are being called. The main set of common parameters are listed in the "common" module at `ufig.config.common`. Examples of config files can be found also be found in the documentation.

  2. **Plugin:** implement specific jobs.

     The nature of the plugins ranges from mundane data handling (e.g., I/O of data files), PSF estimation and background addition to rendering and processing the images. The plugins are stored in `ufig.plugins` and can be easily extended by the user.



  This package was developped by the Cosmology group at ETH Zurich and is currently
  maintained by Silvan Fischbacher: silvanf@phys.ethz.ch


  Contributions are welcome, and they are greatly appreciated! Every
  little bit helps, and credit will always be given.


pkgId: be5d8c1fb7fb24d040b0367d8b3e59a36ae91e136f0cd898b03d55c8c364b7b2
name: python-ufload3-help
arch: noarch
version: 1.4
epoch: 0
release: 1
summary: Development documents and examples for ufload3
url: https://github.com/Unifield/ufload3
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ufload3-1.4-1.src.rpm
location_href: Packages/python-ufload3-help-1.4-1.noarch.rpm
checksum_type: sha256
description:
  The Unifield Loader

  [![Build Status](https://travis-ci.org/Unifield/ufload3.svg?branch=master)](https://travis-ci.org/Unifield/ufload3)

  ufload3 is targeted at people who load dumps from live Unifield
  instances into non-production testing/staging/training
  instances. ufload3 will never leave a non-production database in a
  production configuration (it will stomp production passwords and
  disconnect from the live sync server).

  ufload3 is 100% Python, and has been tested on Linux and Windows.

  ufload3 can iterate over all the backups in a directory on ownCloud,
  and restore the latest backup for each instance. You can limit the
  list of instances to be restored.

  ufload3 can make coffee for you in the morning, and then do your dishes.



  1. Install Python 3.10 from here: https://www.python.org/downloads/windows/
  2. Add this directory to your PATH, separated from previous ones
  by a semi-colon:
    * ;C:\Python27;C:\Python27\Scripts
    or with cmd line in windows:
     ```SETX /M PATH "%PATH%;C:\Python3;C:\Python3\Scripts"```
  3. In a new CMD.EXE window, type: ```pip install --upgrade ufload3```
  4. Run ```ufload3 -h``` to get help.
  5. Use Notepad to create a config file. Put the file in the same place CMD.EXE starts from, for example ```d:\Users\jae```. The file should be named ufload3.txt. Be careful: notepad.exe will create a file called ufload3.txt.txt by default. To avoid this, use "Save as..." and do not include .txt. Put the following into it:
  ```
  [owncloud]
  user=username
  pw=password for OneDrive backup
  oc=your OC:OCA/OCB/OCG/OCP

  [postgres]
  db_user=openpg
  db_pw=yourdatabasepassword

  [restore]



  workingdir=D:\

  [logs]
  local=D:\logs
  ```
  6. Use "dir" to confirm that the file is where you expect it to be, and is named "ufload3.txt" and not "ufload3.txt.txt".

  For each line, put the right thing. If you do not want to put your
  password in the file, you can add the ```-pw``` flag to any command,
  after ```ufload3.exe```.



  ```sudo pip install --upgrade ufload3```

  The config file is in $HOME/.ufload3



  Use the same command as you used to install it: ```pip install --upgrade ufload3```



  To see a list of all backup files for an instance: ```ufload3 ls -i OCG_HQ```

  For all instances, remove the ```-i``` flag.

  To load all of the instances from OneDrive: ```ufload3 restore```

  To load the OCG_HQ instance and all the OCG_NE1 instances from OneDrive: ```ufload3 restore -i OCG_HQ -i OCG_NE1```

  To load the OCG_HQ and OCG_NE1 instances from OneDrive and load a sync server: ```ufload3 restore -i OCG_HQ -i OCG_NE1 -load-sync-server```



  You can use the Windows Task Scheduler to run ufload3 in order to update a
  sandbox environment every night.

  Use the remote option in the [logs] section to arrange for remote logging.

  Use a command like this to schedule it once a day: ```schtasks /create /F /TN Ufload /SC DAILY /st 20:00 /tr "cmd.exe /C start /min cmd.exe /C C:\python27\Scripts\ufload3 restore -load-sync-server"```

  Or this to make it run every hour: ```schtasks /create /F /TN Ufload /SC DAILY /RI 60 /st 00:00 /du 24:00 /tr "cmd.exe /C start /min cmd.exe /C C:\python27\Scripts\ufload3 restore -load-sync-server"```



  Ufload's ```restore``` command has a ```-notify``` flag which will
  call a program each time a database is sucessfully loaded. The program
  receives the name of the newly loaded database as it's first argument.

  For instance, the following script sends e-mail when a backup file is
  older than expected:

  ```


  db=$1


  d=`echo $db | perl -F_ -lane 'print $F[-2]'`
  limit=`date --date='5 days ago' +%Y%m%d`

  if [ "$d" -lt "$limit" ]; then
     echo "Database $db is too old." | mail user@example.org
  fi
  ```

  If it was loaded in ```/bin/notify-old-db```, then
  ```ufload3 restore -notify /bin/notify-old-db``` will run the script.


pkgId: 942767339c77dc1ffaf8fb6f5914244d495ffbd4eb3aa3a89713519d68464e66
name: python-ufs2arco-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for ufs2arco
url: https://pypi.org/project/ufs2arco/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ufs2arco-0.2.1-1.src.rpm
location_href: Packages/python-ufs2arco-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  Tools for converting Unified Forecast System (UFS) output to Analysis Ready, Cloud Optimized (ARCO) format






  ```bash
  pip install ufs2arco
  ```



  To obtain the latest development version, clone
  [the repository](https://github.com/NOAA-PSL/ufs2arco>)
  and install it as follows

  ```bash
  git clone https://github.com/NOAA-PSL/ufs2arco.git
  cd ufs2arco
  pip install -e .
  ```


pkgId: c490213e9cdfc5432478dc63d0ba080ec1a024333daf1e6ee79f63e516975be9
name: python-ugraph-help
arch: noarch
version: 0.75.0
epoch: 0
release: 1
summary: Development documents and examples for ugraph
url: https://github.com/WonJayne/ugraph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ugraph-0.75.0-1.src.rpm
location_href: Packages/python-ugraph-help-0.75.0-1.noarch.rpm
checksum_type: sha256
description:
  Graphs often represent more than their edges and nodes—they carry data, behaviors, and relationships that need to be understood in context. `ugraph` bridges this gap by enabling:
  - **Custom node and link classes**: Add type-safe attributes and behaviors to your graph elements.
  - **Data serialization**: Easily save and load your graphs in JSON format for persistence and sharing.
  - **3D visualization**: Render interactive, browser-based 3D visualizations in HTML using Plotly.


pkgId: 1e79a1dd6d875f0d9a0f0545500cc19fa87f5e1608130e604b839d8927ba3812
name: python-uhaf-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for uhaf
url: https://github.com/SuperBianC/uhaf
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uhaf-0.1.6-1.src.rpm
location_href: Packages/python-uhaf-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  uHAF is a Python library developed to address the challenges of inconsistent cell type annotations in single-cell transcriptomics, such as varied naming conventions and hierarchical granularity. It integrates organ-specific hierarchical cell type trees (uHAF-T) and a mapping tool (uHAF-GPT) powered by large language models to provide a standardized framework for annotation. By enabling consistent label unification, hierarchical analysis, and integration of diverse datasets, uHAF enhances machine learning applications and facilitates biologically meaningful evaluations. This library is an essential resource for the single-cell research community, fostering collaborative refinement and standardization of cell type annotations.



  - [uHAF-T Explorer](https://uhaf.unifiedcellatlas.org): Browse and explore uHAF-Ts.
  - [uHAF-GPT Mapping](https://uhaf.unifiedcellatlas.org/#/uHAFMapping): Map custom cell type labels to uHAF-Ts.



  Install uHAF via pip:

  ```bash
  pip install uhaf
  ```





  Start by building a uHAF object for your dataset:

  ```python
  import uhaf as uhaflib

  uhaf = uhaflib.build_uhaf(latest=True)
  print(len(uhaf.df_uhafs))
  ```

  This generates a uHAF instance containing annotations for all organs. The example above initializes the `uHAF2.2.0` dataset.



  Trace the hierarchical ancestry of a target cell type:

  ```python
  ancestors = uhaf.track_cell_from_uHAF(sheet_name='Lung', cell_type_target='CD8 T cell')
  print(ancestors)
  ```

  Output:

  ```
  ['Cell', 'Lymphocyte', 'T cell', 'CD8 T cell']
  ```



  Retrieve hierarchical annotation levels for cell types. Specify the desired level (e.g., main, middle, or fine).

  ```python
  example_cell_types = ['Pericyte', 'Macrophage', 'Monocyte-derived macrophage', 'Monocyte', 'Dendritic cell']
  annotation_level = 2  # Middle cell type level
  annotations = uhaf.set_annotation_level(example_cell_types, sheet_name='Heart', annotation_level=annotation_level)
  print(annotations)
  ```

  Example Output:

  ```
  {'Pericyte': 'Pericyte', 'Macrophage': 'Macrophage', 'Monocyte-derived macrophage': 'Macrophage', 'Monocyte': 'Monocyte', 'Dendritic cell': 'Dendritic cell'}
  ```



  To map custom cell type labels to uHAF:

  1. Prepare unique cell type labels from your dataset:

     ```python
     original_labels = ['V-CM', 'LA-CM', 'RA-CM', 'Capillary-EC', 'Lymphatic-EC']
     ```

  2. Generate uHAF-GPT prompts:

     ```python
     print(uhaf.generate_uhaf_GPTs_prompts('Heart', original_labels))
     ```

     Copy the output and use it on the [uHAF-GPT Mapping Website](https://uhaf.unifiedcellatlas.org/#/uHAFMapping) to get the mapped labels.

  3. Use the mapping dictionary to transform your labels:

     ```python
     mapping_results = {"V-CM": "Ventricle cardiomyocyte cell", "LA-CM": "Atrial cardiomyocyte cell"}
     transformed_labels = [mapping_results[label] for label in original_labels]
     print(transformed_labels)
     ```



  Export the uHAF tree for a specific organ in nested JSON format:

  ```python
  print(uhaf.dict_uhafs['Heart'])
  ```



  We welcome contributions to improve and expand the uHAF library. For more details, please refer to our contribution guidelines.



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


pkgId: 9b98663121967eb58bc2539f3663bda350b80ad86fa79014af78551874aea5af
name: python-uhlive-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for uhlive
url: https://github.com/uhlive/python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uhlive-1.6.0-1.src.rpm
location_href: Packages/python-uhlive-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  The Uh!live Python SDK provides convenient access to the Uh!live API from
  applications written in the Python language.

  Read the [full documentation](https://python-uhlive-sdk.netlify.app/).





  Install with `pip install .[examples]` to install the the library and all the dependencies necessary to run the examples.



  ```
  pip install uhlive
  ```



  To play with the examples, you should have a raw audio file.
  This raw audio file should be in the proper format. This can be done
  using a source audio file in wav format using the following command:
  ```
  sox audio_file.wav  -t raw -c 1 -b 16 -r 8k -e signed-integer audio_file.raw
  ```



  See the `README.md` in each of the example folders.


pkgId: 2436bd6db1c73800085abd47de04213eb78bf361f1fb58cdaa0e233714274917
name: python-uiprotect-help
arch: noarch
version: 7.1.0
epoch: 0
release: 1
summary: Development documents and examples for uiprotect
url: https://github.com/uilibs/uiprotect
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uiprotect-7.1.0-1.src.rpm
location_href: Packages/python-uiprotect-help-7.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://uiprotect.readthedocs.io" target="_blank">https://uiprotect.readthedocs.io </a>


pkgId: e72ed3d1e1d903ca5e6d87cbb24a24a901e866551fcf95c5624e7cc05395ae93
name: python-ultimate-sitemap-parser-help
arch: noarch
version: 0.5
epoch: 0
release: 1
summary: Development documents and examples for ultimate-sitemap-parser
url: https://github.com/berkmancenter/mediacloud-ultimate_sitemap_parser
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ultimate-sitemap-parser-0.5-1.src.rpm
location_href: Packages/python-ultimate-sitemap-parser-help-0.5-1.noarch.rpm
checksum_type: sha256
description:
  - Supports all sitemap formats:
    - `XML sitemaps <https://www.sitemaps.org/protocol.html#xmlTagDefinitions>`_
    - `Google News sitemaps <https://support.google.com/news/publisher-center/answer/74288?hl=en>`_
    - `plain text sitemaps <https://www.sitemaps.org/protocol.html#otherformats>`_
    - `RSS 2.0 / Atom 0.3 / Atom 1.0 sitemaps <https://www.sitemaps.org/protocol.html#otherformats>`_
    - `Sitemaps linked from robots.txt <https://developers.google.com/search/reference/robots_txt#sitemap>`_
  - Field-tested with ~1 million URLs as part of the `Media Cloud project <https://mediacloud.org/>`_
  - Error-tolerant with more common sitemap bugs
  - Tries to find sitemaps not listed in ``robots.txt``
  - Uses fast and memory efficient Expat XML parsing
  - Doesn't consume much memory even with massive sitemap hierarchies
  - Provides a generated sitemap tree as easy to use object tree
  - Supports using a custom web client
  - Uses a small number of actively maintained third-party modules
  - Reasonably tested


pkgId: b254a45ae1c8f9d0c25f32a6fc793a42b5eceae718706919506ff32feb57df91
name: python-ultipa-help
arch: noarch
version: 5.0.3
epoch: 0
release: 1
summary: Development documents and examples for ultipa
url: https://www.ultipa.com/document/ultipa-drivers/python-installation
rpm_license: PSF
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ultipa-5.0.3-1.src.rpm
location_href: Packages/python-ultipa-help-5.0.3-1.noarch.rpm
checksum_type: sha256
description:
  This Python SDK is a part of Ultipa Drivers, a set of specifications for developing software and applications using Java, Python, Go and NodeJs. This SDK provides instructions on introducing query and management operations of Ultipa Graph Database into Python programs, both by calling command through interfaces and sending assembled UQLs to an Ultipa server. A basic understanding of UQL query commands and the returned data structures is needed to guarantee a proper usage of the SDK.


  - Python version: >=3.6
  - Ultipa Server Version: >= 5.0.1


  Package is uploaded on [PyPI](https://pypi.org/project/ultipa/).

  <p tit="Bash"></p>

  ```bash
  python3 -m pip install ultipa
  ```

  If you are using Ultipa 4.0 version

  <p tit="Bash"></p>

  ```bash
  python3 -m pip install ultipa==4.5.x
  ```

  Documentation is available online: [https://www.ultipa.com/document/ultipa-drivers/python-installation/v5.0](https://www.ultipa.com/document/ultipa-drivers/python-installation/v5.0).



  Example: Create a server connection and use graphset 'amz'
  <p tit= "Python" ></p>

  ```python
  from ultipa import Connection, UltipaConfig

  ultipaConfig = UltipaConfig()
  ultipaConfig.hosts = ["192.168.1.85:60061", "192.168.1.86:60061", "192.168.1.87:60061"]
  ultipaConfig.username = "***"
  ultipaConfig.password = "***"
  ultipaConfig.defaultGraph = "amz"

  conn = Connection.NewConnection(defaultConfig=ultipaConfig)
  conn.test().Print()

  req = conn.uql("show().graph()")
  req.Print()
  ```


  If you have any questions please contact: [Ultipa Support](mailto:support@ultipa.com)


pkgId: c400eb87cd301399f0ecf2ec76b2f9147fbc7dbfd31778bfb83e75edf3de7593
name: python-ultralytics-actions-help
arch: noarch
version: 0.0.25
epoch: 0
release: 1
summary: Development documents and examples for ultralytics-actions
url: https://ultralytics.com
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ultralytics-actions-0.0.25-1.src.rpm
location_href: Packages/python-ultralytics-actions-help-0.0.25-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://www.ultralytics.com/" target="_blank"><img src="https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svg" width="320" alt="Ultralytics logo"></a>



  Welcome to the [Ultralytics Actions](https://github.com/ultralytics/actions) repository, your go-to solution for maintaining consistent code quality across Ultralytics Python and Swift projects. This GitHub Action is designed to automate the formatting of Python, Markdown, and Swift files, ensuring adherence to our coding standards.

  [![GitHub Actions Marketplace](https://img.shields.io/badge/Marketplace-Ultralytics_Actions-blue?style=flat&logo=github)](https://github.com/marketplace/actions/ultralytics-actions) [![Ultralytics Actions](https://github.com/ultralytics/actions/actions/workflows/format.yml/badge.svg)](https://github.com/ultralytics/actions/actions/workflows/format.yml) <a href="https://discord.com/invite/ultralytics"><img alt="Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a> <a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a> <a href="https://reddit.com/r/ultralytics"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>

  [![PyPI version](https://badge.fury.io/py/ultralytics-actions.svg)](https://badge.fury.io/py/ultralytics-actions) [![Downloads](https://static.pepy.tech/badge/ultralytics-actions)](https://www.pepy.tech/projects/ultralytics-actions)



  Ultralytics Actions automatically applies formats, updates, and enhancements:

  - **Python Code:** Using [Ruff](https://github.com/astral-sh/ruff), a fast Python auto-formatter.
  - **Markdown Files:** With [Prettier](https://github.com/prettier/prettier), ensuring a consistent style in documentation.
  - **Docstrings:** Utilizing [docformatter](https://github.com/PyCQA/docformatter) for clean and standardized documentation comments.
  - **Swift Code:** Formatting Swift files using `swift-format` to ensure consistent coding style across Swift projects. _(Requires `macos-latest` to run correctly.)_
  - **Spell Check:** Employing [codespell](https://github.com/codespell-project/codespell) for catching common misspellings.
  - **Broken Links Check:** Implementing [Lychee](https://github.com/lycheeverse/lychee) to report broken links in docs and markdown files.
  - **PR Summary:** Generating concise [OpenAI](https://openai.com/) GPT4o-powered PR summaries, enhancing PR clarity.
  - **Auto-labeling:** Applying relevant labels to issues and pull requests using [OpenAI](https://openai.com/) GPT-4o for intelligent categorization.



  Ultralytics Actions triggers on various GitHub events:

  - **Push Events:** Automatically formats code when changes are pushed to the `main` branch.
  - **Pull Requests:**
    - Ensures that contributions meet our formatting standards before merging.
    - Generates a concise summary of the changes using GPT-4o.
    - Automatically applies relevant labels using GPT-4o for intelligent categorization.
  - **Issues:** Automatically applies relevant labels using GPT-4o when new issues are created.

  These actions help maintain code quality, improve documentation clarity, and streamline the review process by providing consistent formatting, informative summaries, and appropriate categorization of issues and pull requests.



  To use this action in your Ultralytics repository:

  1. **Create a Workflow File:** In your repository, create a file under `.github/workflows/`, e.g., `ultralytics-actions.yml`.

  2. **Add the Action:** Use the Ultralytics Actions in your workflow file as follows:

     ```yaml
     name: Ultralytics Actions

     on:
       issues:
         types: [opened]
       pull_request:
         branches: [main]
         types: [opened, closed]

     jobs:
       format:
         runs-on: ubuntu-latest
         steps:
           - name: Run Ultralytics Formatting
             uses: ultralytics/actions@main
             with:
               token: ${{ secrets.GITHUB_TOKEN }} # automatically generated, do not modify
               labels: true # autolabel issues and PRs
               python: true # format Python code and docstrings
               prettier: true # format YAML, JSON, Markdown and CSS
               swift: true # format Swift code (requires 'macos-latest')
               spelling: true # check spelling
               links: true # check broken links
               summary: true # print PR summary with GPT4o (requires 'openai_api_key')
               openai_api_key: # your OpenAI API key
     ```

  3. **Customize:** Adjust the workflow settings as necessary for your project.



  Ultralytics thrives on community collaboration; we immensely value your involvement! We urge you to peruse our [Contributing Guide](https://docs.ultralytics.com/help/contributing/) for detailed insights on how you can participate. Don't forget to share your feedback with us by contributing to our [Survey](https://www.ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey). A heartfelt thank you 🙏 goes out to everyone who has already contributed!

  <a href="https://github.com/ultralytics/yolov5/graphs/contributors">
  <img width="100%" src="https://github.com/ultralytics/assets/raw/main/im/image-contributors.png" alt="Ultralytics open-source contributors"></a>



  Ultralytics presents two distinct licensing paths to accommodate a variety of scenarios:

  - **AGPL-3.0 License**: This official [OSI-approved](https://opensource.org/license) open-source license is perfectly aligned with the goals of students, enthusiasts, and researchers who believe in the virtues of open collaboration and shared wisdom. Details are available in the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) document.
  - **Enterprise License**: Tailored for commercial deployment, this license authorizes the unfettered integration of Ultralytics software and AI models within commercial goods and services, without the copyleft stipulations of AGPL-3.0. Should your use case demand an enterprise solution, direct your inquiries to [Ultralytics Licensing](https://www.ultralytics.com/license).



  For bugs or feature suggestions pertaining to Ultralytics, please lodge an issue via [GitHub Issues](https://github.com/ultralytics/pre-commit/issues). You're also invited to participate in our [Discord](https://discord.com/invite/ultralytics) community to engage in discussions and seek advice!

  <br>
  <div align="center">
    <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
  </div>


pkgId: 3b080d792642d394ef113624d5de13c40f1788ce201e6ec29cfda4847550f99d
name: python-ultralytics-help
arch: noarch
version: 8.3.50
epoch: 0
release: 1
summary: Development documents and examples for ultralytics
url: https://ultralytics.com
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ultralytics-8.3.50-1.src.rpm
location_href: Packages/python-ultralytics-help-8.3.50-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <p>
      <a href="https://www.ultralytics.com/events/yolovision" target="_blank">
        <img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png" alt="YOLO Vision banner"></a>
    </p>

  [中文](https://docs.ultralytics.com/zh) | [한국어](https://docs.ultralytics.com/ko) | [日本語](https://docs.ultralytics.com/ja) | [Русский](https://docs.ultralytics.com/ru) | [Deutsch](https://docs.ultralytics.com/de) | [Français](https://docs.ultralytics.com/fr) | [Español](https://docs.ultralytics.com/es) | [Português](https://docs.ultralytics.com/pt) | [Türkçe](https://docs.ultralytics.com/tr) | [Tiếng Việt](https://docs.ultralytics.com/vi) | [العربية](https://docs.ultralytics.com/ar) <br>

  <div>
      <a href="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml"><img src="https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml/badge.svg" alt="Ultralytics CI"></a>
      <a href="https://pepy.tech/projects/ultralytics"><img src="https://static.pepy.tech/badge/ultralytics" alt="Ultralytics Downloads"></a>
      <a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="Ultralytics YOLO Citation"></a>
      <a href="https://discord.com/invite/ultralytics"><img alt="Ultralytics Discord" src="https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue"></a>
      <a href="https://community.ultralytics.com/"><img alt="Ultralytics Forums" src="https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue"></a>
      <a href="https://reddit.com/r/ultralytics"><img alt="Ultralytics Reddit" src="https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue"></a>
      <br>
      <a href="https://console.paperspace.com/github/ultralytics/ultralytics"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run Ultralytics on Gradient"></a>
      <a href="https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open Ultralytics In Colab"></a>
      <a href="https://www.kaggle.com/models/ultralytics/yolo11"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open Ultralytics In Kaggle"></a>
      <a href="https://mybinder.org/v2/gh/ultralytics/ultralytics/HEAD?labpath=examples%2Ftutorial.ipynb"><img src="https://mybinder.org/badge_logo.svg" alt="Open Ultralytics In Binder"></a>
  </div>
  <br>

  [Ultralytics](https://www.ultralytics.com/) [YOLO11](https://github.com/ultralytics/ultralytics) is a cutting-edge, state-of-the-art (SOTA) model that builds upon the success of previous YOLO versions and introduces new features and improvements to further boost performance and flexibility. YOLO11 is designed to be fast, accurate, and easy to use, making it an excellent choice for a wide range of object detection and tracking, instance segmentation, image classification and pose estimation tasks.

  We hope that the resources here will help you get the most out of YOLO. Please browse the Ultralytics <a href="https://docs.ultralytics.com/">Docs</a> for details, raise an issue on <a href="https://github.com/ultralytics/ultralytics/issues/new/choose">GitHub</a> for support, questions, or discussions, become a member of the Ultralytics <a href="https://discord.com/invite/ultralytics">Discord</a>, <a href="https://reddit.com/r/ultralytics">Reddit</a> and <a href="https://community.ultralytics.com/">Forums</a>!

  To request an Enterprise License please complete the form at [Ultralytics Licensing](https://www.ultralytics.com/license).

  <a href="https://docs.ultralytics.com/models/yolo11/" target="_blank">
    <img width="100%" src="https://raw.githubusercontent.com/ultralytics/assets/refs/heads/main/yolo/performance-comparison.png" alt="YOLO11 performance plots">
  </a>

  <div align="center">
    <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="2%" alt="Ultralytics GitHub"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
    <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="2%" alt="Ultralytics LinkedIn"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
    <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="2%" alt="Ultralytics Twitter"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
    <a href="https://youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="2%" alt="Ultralytics YouTube"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
    <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="2%" alt="Ultralytics TikTok"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
    <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="2%" alt="Ultralytics BiliBili"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="2%" alt="space">
    <a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="2%" alt="Ultralytics Discord"></a>
  </div>
  </div>



  See below for a quickstart install and usage examples, and see our [Docs](https://docs.ultralytics.com/) for full documentation on training, validation, prediction and deployment.

  <details open>
  <summary>Install</summary>

  Pip install the ultralytics package including all [requirements](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) in a [**Python>=3.8**](https://www.python.org/) environment with [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/).

  [![PyPI - Version](https://img.shields.io/pypi/v/ultralytics?logo=pypi&logoColor=white)](https://pypi.org/project/ultralytics/) [![Ultralytics Downloads](https://static.pepy.tech/badge/ultralytics)](https://www.pepy.tech/projects/ultralytics) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ultralytics?logo=python&logoColor=gold)](https://pypi.org/project/ultralytics/)

  ```bash
  pip install ultralytics
  ```

  For alternative installation methods including [Conda](https://anaconda.org/conda-forge/ultralytics), [Docker](https://hub.docker.com/r/ultralytics/ultralytics), and Git, please refer to the [Quickstart Guide](https://docs.ultralytics.com/quickstart/).

  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics?logo=condaforge)](https://anaconda.org/conda-forge/ultralytics) [![Docker Image Version](https://img.shields.io/docker/v/ultralytics/ultralytics?sort=semver&logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics) [![Ultralytics Docker Pulls](https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker)](https://hub.docker.com/r/ultralytics/ultralytics)

  </details>

  <details open>
  <summary>Usage</summary>



  YOLO may be used directly in the Command Line Interface (CLI) with a `yolo` command:

  ```bash
  yolo predict model=yolo11n.pt source='https://ultralytics.com/images/bus.jpg'
  ```

  `yolo` can be used for a variety of tasks and modes and accepts additional arguments, e.g. `imgsz=640`. See the YOLO [CLI Docs](https://docs.ultralytics.com/usage/cli/) for examples.



  YOLO may also be used directly in a Python environment, and accepts the same [arguments](https://docs.ultralytics.com/usage/cfg/) as in the CLI example above:

  ```python
  from ultralytics import YOLO


  model = YOLO("yolo11n.pt")


  train_results = model.train(
      data="coco8.yaml",  # path to dataset YAML
      epochs=100,  # number of training epochs
      imgsz=640,  # training image size
      device="cpu",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
  )


  metrics = model.val()


  results = model("path/to/image.jpg")
  results[0].show()


  path = model.export(format="onnx")  # return path to exported model
  ```

  See YOLO [Python Docs](https://docs.ultralytics.com/usage/python/) for more examples.

  </details>



  YOLO11 [Detect](https://docs.ultralytics.com/tasks/detect/), [Segment](https://docs.ultralytics.com/tasks/segment/) and [Pose](https://docs.ultralytics.com/tasks/pose/) models pretrained on the [COCO](https://docs.ultralytics.com/datasets/detect/coco/) dataset are available here, as well as YOLO11 [Classify](https://docs.ultralytics.com/tasks/classify/) models pretrained on the [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/) dataset. [Track](https://docs.ultralytics.com/modes/track/) mode is available for all Detect, Segment and Pose models. All [Models](https://docs.ultralytics.com/models/) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.

  <a href="https://docs.ultralytics.com/tasks/" target="_blank">
      <img width="100%" src="https://github.com/ultralytics/docs/releases/download/0/ultralytics-yolov8-tasks-banner.avif" alt="Ultralytics YOLO supported tasks">
  </a>
  <br>
  <br>

  <details open><summary>Detection (COCO)</summary>

  See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/detect/coco/), which include 80 pre-trained classes.

  | Model                                                                                | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
  | ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
  | [YOLO11n](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt) | 640                   | 39.5                 | 56.1 ± 0.8                     | 1.5 ± 0.0                           | 2.6                | 6.5               |
  | [YOLO11s](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt) | 640                   | 47.0                 | 90.0 ± 1.2                     | 2.5 ± 0.0                           | 9.4                | 21.5              |
  | [YOLO11m](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m.pt) | 640                   | 51.5                 | 183.2 ± 2.0                    | 4.7 ± 0.1                           | 20.1               | 68.0              |
  | [YOLO11l](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l.pt) | 640                   | 53.4                 | 238.6 ± 1.4                    | 6.2 ± 0.1                           | 25.3               | 86.9              |
  | [YOLO11x](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x.pt) | 640                   | 54.7                 | 462.8 ± 6.7                    | 11.3 ± 0.2                          | 56.9               | 194.9             |

  - **mAP<sup>val</sup>** values are for single-model single-scale on [COCO val2017](https://cocodataset.org/) dataset. <br>Reproduce by `yolo val detect data=coco.yaml device=0`
  - **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val detect data=coco.yaml batch=1 device=0|cpu`

  </details>

  <details><summary>Segmentation (COCO)</summary>

  See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for usage examples with these models trained on [COCO-Seg](https://docs.ultralytics.com/datasets/segment/coco/), which include 80 pre-trained classes.

  | Model                                                                                        | size<br><sup>(pixels) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
  | -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
  | [YOLO11n-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-seg.pt) | 640                   | 38.9                 | 32.0                  | 65.9 ± 1.1                     | 1.8 ± 0.0                           | 2.9                | 10.4              |
  | [YOLO11s-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-seg.pt) | 640                   | 46.6                 | 37.8                  | 117.6 ± 4.9                    | 2.9 ± 0.0                           | 10.1               | 35.5              |
  | [YOLO11m-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-seg.pt) | 640                   | 51.5                 | 41.5                  | 281.6 ± 1.2                    | 6.3 ± 0.1                           | 22.4               | 123.3             |
  | [YOLO11l-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-seg.pt) | 640                   | 53.4                 | 42.9                  | 344.2 ± 3.2                    | 7.8 ± 0.2                           | 27.6               | 142.2             |
  | [YOLO11x-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-seg.pt) | 640                   | 54.7                 | 43.8                  | 664.5 ± 3.2                    | 15.8 ± 0.7                          | 62.1               | 319.0             |

  - **mAP<sup>val</sup>** values are for single-model single-scale on [COCO val2017](https://cocodataset.org/) dataset. <br>Reproduce by `yolo val segment data=coco.yaml device=0`
  - **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val segment data=coco.yaml batch=1 device=0|cpu`

  </details>

  <details><summary>Classification (ImageNet)</summary>

  See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for usage examples with these models trained on [ImageNet](https://docs.ultralytics.com/datasets/classify/imagenet/), which include 1000 pretrained classes.

  | Model                                                                                        | size<br><sup>(pixels) | acc<br><sup>top1 | acc<br><sup>top5 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) at 640 |
  | -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
  | [YOLO11n-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-cls.pt) | 224                   | 70.0             | 89.4             | 5.0 ± 0.3                      | 1.1 ± 0.0                           | 1.6                | 3.3                      |
  | [YOLO11s-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-cls.pt) | 224                   | 75.4             | 92.7             | 7.9 ± 0.2                      | 1.3 ± 0.0                           | 5.5                | 12.1                     |
  | [YOLO11m-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-cls.pt) | 224                   | 77.3             | 93.9             | 17.2 ± 0.4                     | 2.0 ± 0.0                           | 10.4               | 39.3                     |
  | [YOLO11l-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-cls.pt) | 224                   | 78.3             | 94.3             | 23.2 ± 0.3                     | 2.8 ± 0.0                           | 12.9               | 49.4                     |
  | [YOLO11x-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-cls.pt) | 224                   | 79.5             | 94.9             | 41.4 ± 0.9                     | 3.8 ± 0.0                           | 28.4               | 110.4                    |

  - **acc** values are model accuracies on the [ImageNet](https://www.image-net.org/) dataset validation set. <br>Reproduce by `yolo val classify data=path/to/ImageNet device=0`
  - **Speed** averaged over ImageNet val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val classify data=path/to/ImageNet batch=1 device=0|cpu`

  </details>

  <details><summary>Pose (COCO)</summary>

  See [Pose Docs](https://docs.ultralytics.com/tasks/pose/) for usage examples with these models trained on [COCO-Pose](https://docs.ultralytics.com/datasets/pose/coco/), which include 1 pre-trained class, person.

  | Model                                                                                          | size<br><sup>(pixels) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
  | ---------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
  | [YOLO11n-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-pose.pt) | 640                   | 50.0                  | 81.0               | 52.4 ± 0.5                     | 1.7 ± 0.0                           | 2.9                | 7.6               |
  | [YOLO11s-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-pose.pt) | 640                   | 58.9                  | 86.3               | 90.5 ± 0.6                     | 2.6 ± 0.0                           | 9.9                | 23.2              |
  | [YOLO11m-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-pose.pt) | 640                   | 64.9                  | 89.4               | 187.3 ± 0.8                    | 4.9 ± 0.1                           | 20.9               | 71.7              |
  | [YOLO11l-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-pose.pt) | 640                   | 66.1                  | 89.9               | 247.7 ± 1.1                    | 6.4 ± 0.1                           | 26.2               | 90.7              |
  | [YOLO11x-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-pose.pt) | 640                   | 69.5                  | 91.1               | 488.0 ± 13.9                   | 12.1 ± 0.2                          | 58.8               | 203.3             |

  - **mAP<sup>val</sup>** values are for single-model single-scale on [COCO Keypoints val2017](https://cocodataset.org/) dataset. <br>Reproduce by `yolo val pose data=coco-pose.yaml device=0`
  - **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu`

  </details>

  <details><summary>OBB (DOTAv1)</summary>

  See [OBB Docs](https://docs.ultralytics.com/tasks/obb/) for usage examples with these models trained on [DOTAv1](https://docs.ultralytics.com/datasets/obb/dota-v2/#dota-v10/), which include 15 pre-trained classes.

  | Model                                                                                        | size<br><sup>(pixels) | mAP<sup>test<br>50 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
  | -------------------------------------------------------------------------------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
  | [YOLO11n-obb](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-obb.pt) | 1024                  | 78.4               | 117.6 ± 0.8                    | 4.4 ± 0.0                           | 2.7                | 17.2              |
  | [YOLO11s-obb](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-obb.pt) | 1024                  | 79.5               | 219.4 ± 4.0                    | 5.1 ± 0.0                           | 9.7                | 57.5              |
  | [YOLO11m-obb](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-obb.pt) | 1024                  | 80.9               | 562.8 ± 2.9                    | 10.1 ± 0.4                          | 20.9               | 183.5             |
  | [YOLO11l-obb](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-obb.pt) | 1024                  | 81.0               | 712.5 ± 5.0                    | 13.5 ± 0.6                          | 26.2               | 232.0             |
  | [YOLO11x-obb](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-obb.pt) | 1024                  | 81.3               | 1408.6 ± 7.7                   | 28.6 ± 1.0                          | 58.8               | 520.2             |

  - **mAP<sup>test</sup>** values are for single-model multiscale on [DOTAv1](https://captain-whu.github.io/DOTA/index.html) dataset. <br>Reproduce by `yolo val obb data=DOTAv1.yaml device=0 split=test` and submit merged results to [DOTA evaluation](https://captain-whu.github.io/DOTA/evaluation.html).
  - **Speed** averaged over DOTAv1 val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu`

  </details>



  Our key integrations with leading AI platforms extend the functionality of Ultralytics' offerings, enhancing tasks like dataset labeling, training, visualization, and model management. Discover how Ultralytics, in collaboration with [W&B](https://docs.wandb.ai/guides/integrations/ultralytics/), [Comet](https://bit.ly/yolov8-readme-comet), [Roboflow](https://roboflow.com/?ref=ultralytics) and [OpenVINO](https://docs.ultralytics.com/integrations/openvino/), can optimize your AI workflow.

  <a href="https://www.ultralytics.com/hub" target="_blank">
      <img width="100%" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics active learning integrations">
  </a>
  <br>
  <br>

  <div align="center">
    <a href="https://www.ultralytics.com/hub">
      <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-ultralytics-hub.png" width="10%" alt="Ultralytics HUB logo"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
    <a href="https://docs.wandb.ai/guides/integrations/ultralytics/">
      <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-wb.png" width="10%" alt="ClearML logo"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
    <a href="https://bit.ly/yolov8-readme-comet">
      <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-comet.png" width="10%" alt="Comet ML logo"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="15%" height="0" alt="space">
    <a href="https://bit.ly/yolov5-neuralmagic">
      <img src="https://github.com/ultralytics/assets/raw/main/partners/logo-neuralmagic.png" width="10%" alt="NeuralMagic logo"></a>
  </div>

  |                                                         Ultralytics HUB 🚀                                                         |                                                               W&B                                                               |                                                                       Comet ⭐ NEW                                                                        |                                              Neural Magic                                              |
  | :--------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------: |
  | Streamline YOLO workflows: Label, train, and deploy effortlessly with [Ultralytics HUB](https://www.ultralytics.com/hub). Try now! | Track experiments, hyperparameters, and results with [Weights & Biases](https://docs.wandb.ai/guides/integrations/ultralytics/) | Free forever, [Comet](https://bit.ly/yolov5-readme-comet) lets you save YOLO11 models, resume training, and interactively visualize and debug predictions | Run YOLO11 inference up to 6x faster with [Neural Magic DeepSparse](https://bit.ly/yolov5-neuralmagic) |



  Experience seamless AI with [Ultralytics HUB](https://www.ultralytics.com/hub) ⭐, the all-in-one solution for data visualization, YOLO11 🚀 model training and deployment, without any coding. Transform images into actionable insights and bring your AI visions to life with ease using our cutting-edge platform and user-friendly [Ultralytics App](https://www.ultralytics.com/app-install). Start your journey for **Free** now!

  <a href="https://www.ultralytics.com/hub" target="_blank">
  <img width="100%" src="https://github.com/ultralytics/assets/raw/main/im/ultralytics-hub.png" alt="Ultralytics HUB preview image"></a>



  We love your input! Ultralytics YOLO would not be possible without help from our community. Please see our [Contributing Guide](https://docs.ultralytics.com/help/contributing/) to get started, and fill out our [Survey](https://www.ultralytics.com/survey?utm_source=github&utm_medium=social&utm_campaign=Survey) to send us feedback on your experience. Thank you 🙏 to all our contributors!

  <!-- SVG image from https://opencollective.com/ultralytics/contributors.svg?width=990 -->

  <a href="https://github.com/ultralytics/ultralytics/graphs/contributors">
  <img width="100%" src="https://github.com/ultralytics/assets/raw/main/im/image-contributors.png" alt="Ultralytics open-source contributors"></a>



  Ultralytics offers two licensing options to accommodate diverse use cases:

  - **AGPL-3.0 License**: This [OSI-approved](https://opensource.org/license) open-source license is ideal for students and enthusiasts, promoting open collaboration and knowledge sharing. See the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for more details.
  - **Enterprise License**: Designed for commercial use, this license permits seamless integration of Ultralytics software and AI models into commercial goods and services, bypassing the open-source requirements of AGPL-3.0. If your scenario involves embedding our solutions into a commercial offering, reach out through [Ultralytics Licensing](https://www.ultralytics.com/license).



  For Ultralytics bug reports and feature requests please visit [GitHub Issues](https://github.com/ultralytics/ultralytics/issues). Become a member of the Ultralytics [Discord](https://discord.com/invite/ultralytics), [Reddit](https://www.reddit.com/r/ultralytics/), or [Forums](https://community.ultralytics.com/) for asking questions, sharing projects, learning discussions, or for help with all things Ultralytics!

  <br>
  <div align="center">
    <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
    <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
    <a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
  </div>


pkgId: 1e212cdf6eb05b6d408077f9564d29beb8b3ea01e60181f46b569aaeb08233e9
name: python-ultravox-client-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for ultravox-client
url: https://ultravox.ai
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ultravox-client-0.0.8-1.src.rpm
location_href: Packages/python-ultravox-client-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Python client SDK for [Ultravox](https://ultravox.ai).

  [![pypi-v](https://img.shields.io/pypi/v/ultravox-client.svg?label=ultravox-client&color=orange)](https://pypi.org/project/ultravox-client/)



  ```bash
  pip install ultravox-client
  ```



  ```python
  import asyncio
  import signal

  import ultravox_client as uv

  session = uv.UltravoxSession()
  done = asyncio.Event()

  @session.on("status")
  def on_status():
      if session.status == uv.UltravoxSessionStatus.DISCONNECTED:
          done.set()

  await session.join_call(os.getenv("JOIN_URL", None))
  loop = asyncio.get_running_loop()
  loop.add_signal_handler(signal.SIGINT, lambda: done.set())
  loop.add_signal_handler(signal.SIGTERM, lambda: done.set())
  await done.wait()
  await session.leave_call()
  ```

  See the included example app for a more complete example. To get a `joinUrl`, you'll want to integrate your server with the [Ultravox REST API](https://fixie-ai.github.io/ultradox/).


pkgId: cd0a61944e0b459eb76963bd2b09b044fa98b14f445e4da1c1c841d9e63d4c60
name: python-umap-project-help
arch: noarch
version: 2.7.3
epoch: 0
release: 1
summary: Development documents and examples for umap-project
url: https://pypi.org/project/umap-project/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-umap-project-2.7.3-1.src.rpm
location_href: Packages/python-umap-project-help-2.7.3-1.noarch.rpm
checksum_type: sha256
description:
  uMap lets you create maps with OpenStreetMap layers in a minute and embed them in your site.
  *Because we think that the more OSM will be used, the more OSM will be improved.*
  Built on top of Django and Leaflet.

  - Have a look at [our website](https://umap-project.org) for an introduction
  - See [our docs](https://docs.umap-project.org/) for technical information
  - Come [chat with us on matrix.org](https://app.element.io/#/room/#umap:matrix.org), or join [the mailing-list](https://lists.openstreetmap.org/listinfo/umap)


pkgId: e12e9a129b25a495a65d229afa6bd73835f875db2fe59fe8cc9dcd70236090df
name: python-umnet-napalm-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for umnet-napalm
url: https://pypi.org/project/umnet-napalm/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-umnet-napalm-0.2.0-1.src.rpm
location_href: Packages/python-umnet-napalm-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This is a project that augments the [NAPALM](https://napalm.readthedocs.io/en/latest/) library in ways that are relevant to our interests.
  More specifically, new [getter functions](https://napalm.readthedocs.io/en/latest/support/index.html#getters-support-matrix) have been implemented to pull
  data from routers and parse it into a vender agnostic format.

  Currently, the following NAPALM classes have been augmented:
  * IOS
  * NXOS-SSH
  * Junos
  * PANOS (from [napalm-panos](https://github.com/napalm-automation-community/napalm-panos))

  Have also written a NAPALM class for ASA - the community ASA napalm is based on the http API.

  The following "getter" methods have been added:
  * `get_ip_interfaces`
  * `get_active_routes`
  * `get_mpls_switching`
  * `get_vni_information`
  * `get_inventory`


pkgId: d0643b2df8c3afb93a01401110f913b23678f7f0b54c47e25868615486bfb1db
name: python-umnet-scripts-help
arch: noarch
version: 1.0.9
epoch: 0
release: 1
summary: Development documents and examples for umnet-scripts
url: https://gitlab.umich.edu/its-inf-net/umnet-scripts
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-umnet-scripts-1.0.9-1.src.rpm
location_href: Packages/python-umnet-scripts-help-1.0.9-1.noarch.rpm
checksum_type: sha256
description:
  A set of python modules/classes for interacting with UMnet tools.

  This package is hosted on pypi - you can install it with `pip install umnet-scripts` and use it in your own code.


  As of Dec 2021 this repo defines db wrapper classes for Equipdb, Netinfo, and Netdisco.
  To use these classes you need to set specific environment variables with the credentials
  for each db respectively:
  * Netinfo: `NETINFO_USERNAME`, `NETINFO_PASSSWORD`
  * Netdisco: `NETDISCO_DB_USER`, `NETDISCO_DB_PASSWORD`
  * Equipdb: `EQUIP_DB_USER`, `EQUIP_DB_PASSWORD`

  Queries for specific things are added as they're needed. As of Dec 2021 there are only a few methods defined for netdisco and equipdb.
  Each class inherits a super basic sql query builder method as well as an 'execute' method from a base class (see `umnetdb.py`).


  The rancid helper class currently parses the router.db files in `/home/rancid/` as well as the `/home/rancid/Topology`
  into a list of `Device` objects with rancid-related data as attributes, particularly the following:
  * `rancid_name`: The name of the device as rancid knows it (the name of the config file). IP address for AL, DNS name for everything else.
  * `rancid_type`: The rancid perl script that is used to back up the device (eg `juniper` or `Cat3750`)
  * `rancid_role`: This is the folder the device config lives in, eg `accesslayer` or `core`. Maps 1:1 to the equipdb device `type`.
  * `model`: Device model as populated in equipdb, eg 'EX2200-24T-4G'
  * `cfg_file`: Full path to the config file, eg `/home/rancid/accesslayer/10.233.0.10`
  * `status`: Up or down per the equipdb `offline` flag (offline is down).
  * `neighbors`: A dict of the device's neighbors as reported by TopologyWalker.

  There are also two attributes that look like attributes but are actually 'property' functions: `hostname` and `ip` that return the device's hostname
  or IP respectively. If you call 'hostname' for a device whose rancid name is an IP, a dns reverse lookup is done. Similarly,
  if you call 'ip' on a device whose rancid name is a DNS name, a forward dns lookup is done.

  Note that if you're only focusing on one rancid config folder (eg datacenter, accesslayer, etc),
  to speed your code up you can limit which folders are processed when you instantiate the Rancid class.
  Note that if you want to get devices by dl_zone you *must* include the distlayer folder at minimum.


pkgId: ef208c2edc944113435b7b8e81db538c9e26d7fd7c5bfbe8a58ab97bcd3fbd47
name: python-undo-code-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for undo-code
url: https://pypi.org/project/undo-code/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-undo-code-1.0.0-1.src.rpm
location_href: Packages/python-undo-code-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/undo-code.svg)](https://badge.fury.io/py/undo-code)

  `undo-code` is a Python package that allows developers to easily integrate undo/redo functionality into their projects. This package simplifies the process of managing changes and restoring previous states in applications, making it especially useful for text editors, graphic design tools, and other software requiring history tracking.



  - **Simple API**: Easy-to-use methods for adding, undoing, and redoing actions.
  - **Flexible Integration**: Works seamlessly with various data structures and custom objects.
  - **Lightweight**: Minimal dependencies and efficient performance.



  Install `undo-code` using pip:

  ```bash
  pip install undo-code
  ```



  Here's a basic example to get started:

  ```python
  from undo_code import UndoManager


  undo_manager = UndoManager()


  def add_action():
      print("Action added!")

  def remove_action():
      print("Action undone!")


  undo_manager.add_action(add_action, remove_action)


  undo_manager.undo()


  undo_manager.redo()
  ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a new branch for your feature: `git checkout -b feature-name`.
  3. Commit your changes: `git commit -m 'Add some feature'`.
  4. Push to the branch: `git push origin feature-name`.
  5. Open a pull request.



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



  If you have any questions or feedback, feel free to reach out to [Your Email or GitHub Profile].


pkgId: 4b37abe951c7332358314a902f42d0be28b549d2d1b78c09ab465a08cc15b5d3
name: python-unet-help
arch: noarch
version: 0.8.1
epoch: 0
release: 1
summary: Development documents and examples for unet
url: https://github.com/fepegar/unet
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unet-0.8.1-1.src.rpm
location_href: Packages/python-unet-help-0.8.1-1.noarch.rpm
checksum_type: sha256
description:
  PyTorch implementation of 1D, 2D and 3D U-Net.
  The U-Net architecture was first described in
  `Ronneberger et al. 2015, U-Net: Convolutional Networks for Biomedical Image
  Segmentation <https://arxiv.org/abs/1505.04597>`_.
  The 3D version was described in
  `Çiçek et al. 2016, 3D U-Net: Learning Dense Volumetric Segmentation from
  Sparse Annotation <https://arxiv.org/abs/1606.06650>`_.


pkgId: ebcc779def928370a1dfb0bc4f5d2a5cede5fe42b6d04c0a2fef3764856402b3
name: python-unicat-help
arch: noarch
version: 0.7.5
epoch: 0
release: 1
summary: Development documents and examples for unicat
url: https://pypi.org/project/unicat/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unicat-0.7.5-1.src.rpm
location_href: Packages/python-unicat-help-0.7.5-1.noarch.rpm
checksum_type: sha256
description:
  Unicat is a Product Information Management SaaS.

  This library is still a work in progress, not all Unicat API options are covered yet.

  Documentation still needs a bit of work too.


  First, connect to Unicat (https://unicat.app):

  ```
  import sys
  from unicat import Unicat
  from .env import server, project_gid, api_key, local_folder

  unicat = Unicat(server, project_gid, api_key, local_folder)
  if not unicat.connect():
    print("Invalid connection settings")
    sys.exit(1)
  ```

  Download all assets for the project (you can find them in the local_folder):

  ```
  for asset in unicat.walk_asset_tree():
    if asset.is_file:
      asset.download()
  ```

  Or, write an XML product feed:

  ```
  with open("product-feed.xml", "w", encoding="utf-8") as f:
    f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
    f.write('<products>\n')

    for record in unicat.walk_record_tree():
      if record.definition.name != "article":
        continue

      fields = record.fields["nl"]

      artnr = fields["artnr"].value
      price = fields["price"].value
      stock = fields["stock"].value

      f.write(f'  <product artnr="{artnr}" price="{price:%0.02f}" stock="{stock}"/>\n')
    f.write('</products>\n')
  ```

  There's also unicat.mutate, with options to update the Unicat project server-side, like unicat.mutate.create_record, unicat.mutate.modify_field and many more.




  The Unicat package is split into connection, reading/traversing, and mutating. All mutating methods below are available on the `unicat.mutate` property. All methods raise a UnicatError on error.




  ```python
  unicat.connect() -> bool
  unicat.sync() -> True
  ```



  ```python
  unicat.get_record(gid: str, *, force: bool) -> UnicatRecord | None
  unicat.get_records(gids: list[str], *, force: bool) -> list[UnicatRecord]
  unicat.get_root_record() -> UnicatRecord
  unicat.get_asset(gid: str, *, force: bool) -> UnicatAsset | None
  unicat.get_asset_by_pathname(pathname: str, *, force: bool) -> UnicatAsset | None
  unicat.get_assets(gids: list[str], *, force: bool) -> list[UnicatAsset]
  unicat.get_assets_by_pathname(pathnames: list[str], *, force: bool) -> dict[str, UnicatAsset]
  unicat.get_root_asset() -> UnicatAsset
  unicat.get_definition(gid: str) -> UnicatDefinition | None
  unicat.get_definitions(gids: list[str]) -> list[UnicatDefinition]
  unicat.get_definition_by_name(name: str) -> UnicatDefinition | None
  unicat.get_definitions_by_name(names: list[str]) -> dict[str, UnicatDefinition]
  unicat.get_class(gid: str) -> UnicatClass | None
  unicat.get_classes(gids: list[str]) -> list[UnicatClass]
  unicat.get_class_by_name(name: str) -> UnicatClass | None
  unicat.get_classes_by_name(names: list[str]) -> dict[str, UnicatClass]
  unicat.get_field(gid: str) -> UnicatField | None
  unicat.get_fields(gids: list[str]) -> list[UnicatField]
  unicat.get_field_by_name(name: str) -> UnicatField | None
  unicat.get_fields_by_name(names: list[str]) -> dict[str, UnicatField]
  unicat.get_query(gid: str) -> UnicatQuery | None
  unicat.get_queries(gids: list[str]) -> list[UnicatQuery]
  unicat.get_record_query_by_name(name: str) -> UnicatQuery | None
  unicat.get_record_queries_by_name(names: list[str]) -> dict[str, UnicatQuery]
  unicat.get_asset_query_by_name(name: str) -> UnicatQuery | None
  unicat.get_asset_queries_by_name(names: list[str]) -> dict[str, UnicatQuery]
  unicat.get_schema_query_by_name(name: str) -> UnicatQuery | None
  unicat.get_schema_queries_by_name(names: list[str]) -> dict[str, UnicatQuery]
  ```



  ```python
  unicat.walk_record_children(parent_record: UnicatRecord, channel: gid, ordering: gid) -> Iterator[UnicatRecord]
  unicat.walk_record_tree(channel: gid, ordering: gid) -> Iterator[UnicatRecord]
  unicat.walk_record_query(language: str, query: UnicatQuery, *, limit: int) -> Iterator[tuple[int, UnicatRecord]]
  unicat.walk_asset_children(parent_asset: UnicatAsset) -> Iterator[UnicatAsset]
  unicat.walk_asset_tree() -> Iterator[UnicatAsset]
  unicat.walk_asset_query(language: str, query: UnicatQuery, *, limit: int) -> Iterator[tuple[int, UnicatAsset]]
  unicat.walk_definitions() -> Iterator[UnicatDefinition]
  unicat.walk_classes() -> Iterator[UnicatClass]
  unicat.walk_fields() -> Iterator[UnicatField]
  unicat.walk_schema_query(language: str, query: UnicatQuery, *, limit: int) -> Iterator[tuple[int, UnicatQuery]]
  unicat.walk_queries() -> Iterator[UnicatQuery]
  ```



  ```python
  unicat.project: UnicatProject
  ```



  ```python
  project.gid: gid
  project.name: str
  project.owner: UnicatUser
  project.icon: str  # used to construct /media url
  project.status: str
  project.languages: list[str]
  project.default_language: str
  project.channels: dict[str, gid]
  project.default_channel: gid
  project.channel_name(key: gid) -> str
  project.orderings: dict[str, gid]
  project.default_ordering: gid
  project.ordering_name(key: gid) -> str
  project.fieldlists: dict[str, gid]
  project.default_fieldlist: gid
  project.fieldlist_name(key: gid) -> str
  project.backups: list[UnicatProjectBackup]  # new in v0.6.0
  project.get_backup(version: int) -> UnicatProjectBackup | None  # new in v0.6.0
  project.members: list[UnicatProjectMember]
  ```



  ```python
  user.gid: gid
  user.username: str
  user.name: str
  user.avatar: str  # used to construct /media url
  ```



  ```python
  projectmember.project: UnicatProject
  projectmember.user: UnicatUser
  projectmember.status: str
  projectmember.roles: list[str]
  projectmember.options: dict
  projectmember.key: str
  ```



  New in v0.6.0

  ```python
  backup.version: int
  backup.name: str
  backup.created_by: str
  backup.timestamp: timestamp  # 1610635123.351925
  ```



  ```python
  definition.gid: gid
  definition.original: UnicatDefinition | None
  definition.name: str
  definition.label: dict[str, str]  # key is language
  definition.classes: list[UnicatClass]
  definition.classes_as_gids: list[gid]
  definition.fields: list[UnicatField]
  definition.fields_as_gids: list[gid]
  definition.titlefield: UnicatField
  definition.fieldlists: dict[str, list[UnicatField]]  # key is fieldlist key
  definition.layout: UnicatLayout
  definition.childdefinitions: list[UnicatDefinition]
  definition.is_base: bool
  definition.is_new: bool
  definition.is_extended: bool
  definition.is_working_copy: bool
  definition.is_committed: bool
  definition.all_fields: list[UnicatField]
  definition.base_classes: list[UnicatClass]
  definition.base_fields: list[UnicatField]
  definition.all_base_fields: list[UnicatField]
  definition.extended_classes: list[UnicatClass]
  definition.extended_fields: list[UnicatField]
  definition.all_extended_fields: list[UnicatField]
  ```



  ```python
  class_.gid: gid
  class_.original: UnicatClass | None
  class_.name: str
  class_.label: dict[str, str]  # key is language
  class_.fields: list[UnicatField]
  class_.fields_as_gids: list[gid]
  class_.layout: UnicatLayout
  class_.is_new: bool
  class_.is_working_copy: bool
  class_.is_committed: bool
  ```



  ```python
  field.gid: gid
  field.original: UnicatField | None
  field.name: str
  field.type: str
  field.class_: UnicatClass | None
  field.options: dict
  field.is_localized: bool
  field.is_required: bool
  field.label: dict[str, str]  # key is language
  field.initial: dict[str, str]  # key is language
  field.unit: str
  field.title: dict[str, str]  # key is language
  field.is_new: bool
  field.is_working_copy: bool
  field.is_committed: bool
  ```



  ```python
  layout.gid: gid
  layout.original: UnicatLayout | None
  layout.name: str
  layout.root: gid
  layout.components: dict[gid, dict]
  layout.is_new: bool
  layout.is_working_copy: bool
  ```



  ```python
  query.gid: gid
  query.type: str  # schema, record, or asset
  query.name: str
  query.q: str
  query.filter: list
  ```



  ```python
  asset.gid: gid
  asset.pathname: str
  asset.path: str
  asset.name: str
  asset.is_file: bool
  asset.type: str
  asset.childcount: int
  asset.status: str
  asset.is_deleted: bool
  asset.info: dict
  asset.transforms: dict[str, dict] | None
  asset.default_transform: dict | None
  asset.title: dict[str, str]  # key is language
  asset.description: dict[str, str]  # key is language
  asset.updated_on: timestamp  # 1610635123.351925
  asset.publish() -> str  # public_url
  asset.publish_transformed(transform: UnicatTransform | None) -> str  # public_url
  asset.download(pathname: str | None) -> False | None | str  # local_filepath
  asset.download_transformed(transform: UnicatTransform | None, pathname: str | None) -> False | None | str  # local_filepath
  ```



  ```python
  record.gid: gid
  record.canonical: gid
  record.parent: gid
  record.backlinks: list[gid]
  record.is_link: bool
  record.is_deleted: bool
  record.treelevel: int
  record.path: list[gid]
  record.title: dict[str, str]  # key is language
  record.channels: list[gid]  # enabled channels only
  record.orderings: dict[gid, int]
  record.childcount: int
  record.definition: UnicatDefinition
  record.fields: dict[str, dict[str, UnicatRecordField]]  # key is language, then fieldname
  record.validation_report: None | list[dict[str, Any]]  # validation result after updates
  ```



  ```python
  recordfield.field: UnicatField
  recordfield.value: Any
  ```

  A record field can have a value, a reference (record, asset), or it can be nested for class-fields. \
  We also support 'list' versions of these.

  > Note: this will probably be refactored in an upcoming version \
  >       then, it may work like recordfield.label["en"] == "Image" \
  >       and, for e.g. image fields, recordfield.value.pathname == "/asset-1-name.svg"

  ```python


  artnr = record.fields[language]["artnr"]  # a recordfield
  artnr.value             # "CMS 225-945"
  artnr.field.label       # "Article number"
  artnr.field.type        # "textline"



  image = record.fields[language]["image"]  # both recordfield and asset
  image.value             # "a0a80c9c-fa1b-4573-ac98-b7b07c81b583"
  image.field.label       # "Image"
  image.pathname          # "/products/cms225.eps"



  dimensions_interior = record.fields[language]["dimensions_interior"]
                          
  dimensions_interior.value               # {"width__mm": 374, …}
  dimensions_interior["width__mm"].value  # 374  -- this is a recordfield



  colors = record.fields[language]["colors"]
  colors.value            # ["Red", "Blue"]
  colors.field.label      # "Colors"
  colors[0].value         # "Red" -- this is just a string



  images = record.fields[language]["images"]
  images.value            # ["a0a80c9c-fa1b-4573-ac98-b7b07c81b583", ]
  images.field.label      # "Images"
  images[0]               # this is just an asset
  images[0].pathname      # "/products/cms225.eps"



  tablespecs = record.fields[language]["tablespecs"]
  tablespecs.value                        # [{"width__mm": 7, …}, …]
  tablespecs.field.label                  # "Table specs"
  tablespecs[0]                           # this is recordfield-like
  tablespecs[0]["width__mm"].value        # 7
  tablespecs[0]["width__mm"].field.label  # "Width"
  ```




  ```python
  mutate.add_language(language: str) -> bool
  mutate.remove_language(language: str) -> bool

  mutate.create_channel(name: str) -> gid  # gid type is actually a string
  mutate.delete_channel(gid: gid) -> bool

  mutate.create_ordering(name: str) -> gid
  mutate.delete_ordering(gid: gid) -> bool

  mutate.create_fieldlist(name: str) -> gid
  mutate.delete_fieldlist(gid: gid) -> bool
  ```



  ```python
  mutate.create_definition(*, name: str, label: dict[str, str], classes: list[UnicatClass], fields: list[UnicatField], titlefield: UnicatField, childdefinitions: list[UnicatDefinition]) -> UnicatDefinition
  mutate.modify_definition(definition: UnicatDefinition, *, name: str, label: dict[str, str], classes: list[UnicatClass], fields: list[UnicatField], titlefield: UnicatField, childdefinitions: list[UnicatDefinition]) -> UnicatDefinition
  mutate.modify_definition_modify_layout(definition: UnicatDefinition, *, name: str, root: gid, components: dict[gid, dict]) -> UnicatDefinition
  mutate.modify_definition_add_class(definition: UnicatDefinition, class_: UnicatClass) -> UnicatDefinition
  mutate.modify_definition_remove_class(definition: UnicatDefinition, class_: UnicatClass) -> UnicatDefinition
  mutate.modify_definition_add_field(definition: UnicatDefinition, field: UnicatField) -> UnicatDefinition
  mutate.modify_definition_remove_field(definition: UnicatDefinition, field: UnicatField) -> UnicatDefinition
  mutate.modify_definition_fieldlist_add_field(definition: UnicatDefinition, fieldlist: gid, field: UnicatField) -> UnicatDefinition
  mutate.modify_definition_fieldlist_remove_field(definition: UnicatDefinition, fieldlist: gid, field: UnicatField) -> UnicatDefinition
  mutate.modify_definition_add_childdefinition(definition: UnicatDefinition, childdefinition: UnicatDefinition) -> UnicatDefinition
  mutate.modify_definition_remove_childdefinition(definition: UnicatDefinition, childdefinition: UnicatDefinition) -> UnicatDefinition
  mutate.commit_definition(new_or_working_copy: UnicatDefinition) -> UnicatDefinition
  mutate.save_as_new_definition(working_copy: UnicatDefinition) -> UnicatDefinition
  mutate.delete_definition(definition: UnicatDefinition) -> bool
  ```



  ```python
  mutate.create_class(*, name: str, label: dict[str, str], fields: list[UnicatField]) -> UnicatClass
  mutate.modify_class(class_: UnicatClass, *, name: str, label: dict[str, str], fields: list[UnicatField]) -> UnicatClass
  mutate.modify_class_modify_layout(class_: UnicatClass, *, name: str, root: gid, components: dict[gid, dict]) -> UnicatClass
  mutate.modify_class_add_field(class_: UnicatClass, field: UnicatField) -> UnicatClass
  mutate.modify_class_remove_field(class_: UnicatClass, field: UnicatField) -> UnicatClass
  mutate.commit_class(new_or_working_copy: UnicatClass) -> UnicatClass
  mutate.save_as_new_class(working_copy: UnicatClass) -> UnicatClass
  mutate.delete_class(class_: UnicatClass) -> bool
  ```



  ```python
  mutate.create_field(*, name: str, type: str, is_localized: bool, is_required: bool, label: dict, unit: str, initial: dict, options: dict) -> UnicatField
  mutate.modify_field(field: UnicatField, *, name: str, type: str, is_localized: bool, is_required: bool, label: dict, unit: str, initial: dict, options: dict) -> UnicatField
  mutate.commit_field(new_or_working_copy: UnicatField) -> UnicatField
  mutate.save_as_new_field(working_copy: UnicatField) -> UnicatField
  mutate.delete_field(field: UnicatField) -> bool
  ```



  ```python
  mutate.create_record(parent: UnicatRecord, ordering: gid) -> UnicatRecord
  mutate.set_record_definition(record: UnicatRecord, definition: UnicatDefinition) -> UnicatRecord
  mutate.extend_record_definition_add_class(record: UnicatRecord, class_: UnicatClass) -> UnicatRecord
  mutate.extend_record_definition_add_field(record: UnicatRecord, field: UnicatField) -> UnicatRecord
  mutate.extend_record_definition_add_fieldlist_field(record: UnicatRecord, fieldlist: gid, field: UnicatField) -> UnicatRecord
  mutate.extend_record_definition_remove_class(record: UnicatRecord, class_: UnicatClass) -> UnicatRecord
  mutate.extend_record_definition_remove_field(record: UnicatRecord, field: UnicatField) -> UnicatRecord
  mutate.extend_record_definition_remove_fieldlist_field(record: UnicatRecord, fieldlist: gid, field: UnicatField) -> UnicatRecord
  mutate.update_record(record: UnicatRecord, localizedfielddata: dict) -> UnicatRecord
  mutate.set_record_channels(record: UnicatRecord, channels: list[gid], enabled: bool) -> UnicatRecord
  mutate.copy_record_channels_from_parent(record: UnicatRecord, channels: list[gid] | None) -> UnicatRecord
  mutate.copy_record_channels_down(record: UnicatRecord, channels: list[gid] | None, return_job: Bool = False) -> UnicatRecord | UnicatJob
  mutate.copy_record_channels_up(record: UnicatRecord, channels: list[gid] | None) -> UnicatRecord
  mutate.set_record_orderings(record: UnicatRecord, orderings: dict) -> UnicatRecord
  mutate.link_record(parent: UnicatRecord, record: UnicatRecord, ordering: gid) -> UnicatRecord
  mutate.delete_record(record: UnicatRecord) -> UnicatRecord
  mutate.undelete_record(record: UnicatRecord) -> UnicatRecord
  mutate.permanent_delete_record(record: UnicatRecord, return_job: Bool = False) -> UnicatRecord | UnicatJob
  ```



  ```python
  mutate.upload_asset(localfilepath: Path | str, folderasset: UnicatAsset) -> UnicatAsset
  mutate.upload_update_asset(localfilepath: Path | str, asset: UnicatAsset) -> UnicatAsset
  mutate.create_asset(parentasset: UnicatAsset, name: str) -> UnicatAsset
  mutate.update_asset(asset: UnicatAsset, name: str, title: dict, description: dict) -> UnicatAsset
  mutate.delete_asset(asset: UnicatAsset) -> UnicatAsset
  mutate.undelete_asset(asset: UnicatAsset) -> UnicatAsset
  mutate.permanent_delete_asset(asset: UnicatAsset) -> bool
  ```



  ```python
  mutate.create_query(type: str, name: str, q: str, filter: list) -> UnicatQuery
  mutate.update_query(query: UnicatQuery, name: str, q: str, filter: list) -> UnicatQuery
  mutate.delete_query(query: UnicatQuery) -> bool
  ```




  New in v0.6.0

  ```python
  mutate.create_backup(created_by: str, name: str, return_job: Bool = False) -> UnicatProjectBackup | UnicatJob
  mutate.update_backup(backup: UnicatProjectBackup, name: str) -> UnicatProjectBackup
  mutate.restore_backup(backup: UnicatProjectBackup, return_job: Bool = False) -> UnicatProject | UnicatJob
  mutate.delete_backup(backup: UnicatProjectBackup) -> UnicatProject
  mutate.delete_backups(backups: list[UnicatProjectBackup]) -> UnicatProject
  ```




  Some mutating methods can return a job if requested, so you can choose to wait for completion yourself (`track` method), or ignore it and let it finish in the background some time. The job always has the `return_value` from the (mutating) method available -- this is the "immediately returned" value, not some result from running the actual job (look in `status` and `info` instead).

  Usage:

  ```python

  record = unicat.mutate.copy_record_channels_down(record, channels)


  job = unicat.mutate.copy_record_channels_down(record, channels, return_job=True)
  for status in job.track():
      assert status == job.status
      print(job.name, job.status)
  record = job.return_value


  job = unicat.mutate.copy_record_channels_down(record, channels, return_job=True)
  record = job.return_value
  ```



  ```python
  job.gid: gid
  job.name: str
  job.status: str
  job.info: dict
  job.created_on: timestamp | None
  job.updated_on: timestamp | None
  job.progress: dict  # combined gid, name, status, info, and timestamps
  job.return_value: Any
  job.track(timeout_in_seconds: float | None = None, poll_interval_in_seconds: float = 1.0) -> Generator[str]
  ```




  We handle errors with the `UnicatError` exception.

  ```python
  from unicat import Unicat, UnicatError
  from config import PROJECT_GID, SECRET_API_KEY, LOCAL_ASSET_FOLDER

  unicat = Unicat("https://unicat.app", PROJECT_GID, SECRET_API_KEY, LOCAL_ASSET_FOLDER)
  if not unicat.connect():
      raise Exception("Invalid connection settings")

  ...

  try:
      unicat.mutate.update_record(record, {language: fields_data})
  except UnicatError as e:
      print(e, e.code, e.message, e.info)
  ```

  The `.code`, `.message`, and `.info` properties match the API error result.




  ```python
  from unicat import UnicatTransform
  ```

  We use this on assets, for publishing and/or downloading transformed versions.

  ```python
  transform = UnicatTransform(resize="fill", width=400, height=300, type="jpg", dpr=2, optimize=True)

  public_url = asset.publish_transformed(transform)

  transform.merge(UnicatTransform(width=200, height=200, key="thumb")) # keeps type, dpr, etc

  local_pathname = asset.download_transformed(transform)
  ```

  A `UnicatTransfrom` accepts any combination of the following arguments.

  ```text
  name
  key
  force
  optimize
  resize
  width
  height
  type
  hotspot
  crop
  padding
  quality
  background
  dpr
  ```

  Each argument explained:

      name = "seo-optimized-name"

  Default: use source filename \
  Use this as the filename instead of the source filename. Mustn't include the extension.

      key = "2x"

  Default: auto-generate a key from a hash of the options \
  If you make multiple transforms from the same file, you can use keys to individualize them. They are included in the filename after the name and before the extension. A key is prepended by a '@', so we would get /filename@2x.jpg. You can use @'s in filenames and in keys, just make sure that the combinations add up to a unique final filename.

      type = "jpg"

  Options: jpg, png, or gif \
  Both extension and transformed file type. If you don't specify this, the source extension is used, which can lead to faulty results if it isn't one of the supported file types (jpg, png, or gif).

      force = True

  Default: False \
  If force isn't enabled, no transformation is done if a file with the transform filename exists and is newer than the source.

      optimize = True

  Default: False \
  We support pngcrush, jhead, jpegoptim, jpeg-recompress, gifsicle, scour, and svgo to strip down and compress the transformed file. Since this is a time-consuming process, it is disabled by default.

      resize = "fill"

  Options: width, height, fit, or fill \
  Resizing will always respect the aspect ratio. Placement of the resized source on the canvas is controlled by the width, height, hotspot, crop, and padding options. Images are never scaled up, only down.

      width = 400

  Resulting width of the transformed asset, in logical pixels (see also `dpr`).

  Value is capped at 5000 pixels.

      height = 300

  Resulting height of the transformed asset, in logical pixels (see also `dpr`).

  Value is capped at 5000 pixels.

      hotspot = (0.5, 0.5)

  Default: 0.5,0.5 (the center) \
  The hotspot serves two purposes: first to place the resized image on the canvas with the hotspot as close as possible to the center of the canvas, and second as the centerpoint for the crop transform if one is requested.
  The hotspot is given as an x,y coordinate, with values as a fraction of the width and height, respectively. Valid values are 0.0 through 1.0 for each.

      crop = (0.6, 0.6)

  Default: don't crop \
  Use crop to select an area from the source that will then be resized to be placed on the canvas. The crop is centered on the hotspot.
  The crop is given as w,h dimensions, with values as a fraction of the width and height, respectively. Valid values are 0.0 through 1.0 for each.

      padding = (0, "auto", 0, "auto")

  Default: `auto`,`auto`,`auto`,`auto` \
  Specify padding in the target image. The values are for top, right, bottom, and left padding (clockwise starting at top). If a value is set to `auto`, that padding will grow to fill available space. If two opposing sides have non-`auto` values, they will get at least the specified padding, plus half of the remaining available space each. If you want to anchor the image to the top-right of the canvas, you can specify 0,0,"auto","auto".

  Values are capped at 1000 pixels.

      background = "abcdef"

  Default: transparent (or white if transformed file doesn't support transparency) \
  Specify a background color to use for transparent areas in the source and for any padding added.
  There are two predefined options, `transparent` and `white`. Any other background color must be specified as an rgb hex value, similar to CSS but without the \# sign. Use the full 6-character rgb hex, not a CSS shortcut like bbb.

      quality = 82

  Default: 100 \
  Lower quality leads to smaller filesizes, but higher quality looks better. This is a compromise, use your best judgment.
  Allowed values are 0 through 100.

      dpr = 2

  Default: 1 \
  Device pixel ratio is abbreviated dpr, and is used to indicate the number of physical pixels the device screen has per logical pixel. You always specify the resizing and padding values in logical pixels. Regular screens have a dpr of 1. High resolution or retina screens have a dpr of 2 or 3. We support a max dpr of 4, just in case. A dpr of 2 means that for a requested width of 400, you get a transformed image with 800 (physical) pixels.





  ```python
  from unicat.utils import *
  ```


  ```python
  def gid() -> str  # a uuid4

  def maybe_gid(possible_gid: Any) -> bool

  def test_true(data: Any) -> bool

  def test_false(data: Any) -> bool

  def make_bool(any: Any) -> bool

  def make_bool_str(any: Any) -> str

  def make_str(any: Any) -> str

  def make_json_str(any: Any) -> str

  def make_json(any: Any) -> Any

  def make_json_list(any: Any) -> list[Any]

  def make_int(any: Any) -> int

  def make_float(any: Any) -> float

  def noop(any: Any) -> Any

  def make_str_list(any: Any) -> list[str]

  def convert_value_to_fielddata(fieldtype: str, value: Any) -> bool | str | Any | int | float | list[str] | list[Any]
      """Return a value suitable for writing to Unicat, for list field types this
      means converting newline-separated entries to lists.
      For class or classlist fields, we produce a JSON data structure.

      This can raise exceptions when the value doesn't match the type, e.g. converting a
      string to a float.
      """

  def convert_fielddata_to_value(fieldtype: str, fielddata: Any) -> str | int | float
      """Return a value suitable for writing in a cell, such as a text or a number.
      Lists will be flattened by stringifying each item and concatenating with \n.
      For class or classlist fields, we will have pretty-printed JSON.
      """

  def merge_dicts(a: dict, b: dict) -> dict
      """Merge b into a, returning a.

      a is updated; if you don't want to mutate a, call it as `merge_dicts(dict(a), b)`.
      """

  def diff_record_fields_data(unicat: Unicat, record: UnicatRecord, localizedfielddata: dict) -> dict  # dict format: d[language][fieldname] = value
      """Return a version of localizedfielddata that only has data that is different from
      the raw record data.
      """

  def hash_text(text: str) -> str  # unicode ok

  def hash_data(data: Any) -> str  # data must be json-serializable

  class DuckObject  # quickly construct an object-like duck from a dict or kwargs, see below

  class FieldColumns  # flatten a list of (class-)fields, see below
  ```




  DuckObjects are used to quickly construct an object-like duck.

  Uses keyword arguments to construct any duck-like object with those attributes.

  ```python
  ducklike = DuckObject(walk="waddle", talk="quack")
  assert ducklike.walk == "waddle"
  assert ducklike.talk == "quack"
  assert not hasattr(ducklike, "bill")

  duckquery = DuckObject(
      q="",
      filter=["value", "is", [base_artnr_field.gid, article.base_artnr]]
  )
  print(duckquery.q, duckquery.filter)

  duckrecord = DuckObject(gid="<anything gid-like>")
  print(duckrecord.gid)
  ```




  FieldColumns are needed for class fields, that have nested subfields.

  With FieldColumns, we can flatten a list of fields to a list of columns,
  associated with those fields.

  Each column has a fieldstack, that is a list of the field and nested subfields.
  For a regular field, the fieldstack is just that field.
  A classfield with three subfields will yield three columns, and each column has
  a fieldstack with the classfield first, and then the subfield for that column.
  If that subfield is another classfield, we'll get more columns and deeper
  stackfields.

  For example, you have `[image, dimensions]` as fields, and `dimensions` is of type class, and has subfields `width` and `length`; FieldColumns will give you `[image, dimensions.width, dimensions.length]`, useable for writing to tab-separated files or spreadsheets.

  Most of the time, you won't need the stackfield in the client code, see also the
  \_FieldColumn implementation where we get the 'name' for a column by walking the
  fieldstack.

  Client code can look something like this, for reading from Unicat:

  ```python
  columns = FieldColumns(fields, prefix_column_count=3)
  for column in columns:
      column_name = column.name()  # e.g. 'image' or 'dimensions.width__mm'
      column_label = column.label()  # e.g. 'Image' or 'Dimensions\nWidth [mm]'
      column_value = None
      error = None
      try:
          record_field = column.extract_record_field(record.fields[language])
          column_value = record_field.value if record_field else None
      except KeyError:
          error = (
              "Field is not part of this definition. Do not enter data here."
          )
  ```

  FieldColumns can also be used to write to Unicat, when we need a record's fields
  data structure:

  ```python
  recordfields_data = {}
  for column in columns:
      fieldvalue = row[column.index].value
      column.update_fields_data(recordfields_data, fieldvalue)
  unicat.mutate.update_record(record, {language: recordfields_data})
  ```







  Specifically, 'nee' (Dutch), 'nein' (German), and 'non' (French) are now interpreted as false. Also, 'nil' is interpreted as false.

  This affects test_true as well, since it is implemented as `not test_false`.




  In rare cases an assetlist or recordlist field can have references to assets or records that no longer exist. This used to throw a UnicatError for the entire list, but now it returns None for that specific item, so you can still use the rest of the items.




  A new sync() method that brings the local storage in sync with the server. Raises `UnicatError` on error.

  ```python
  unicat.sync() -> True
  ```

  Internally, the return value for api.sync() changed from `None` to a tuple `(bool, result)`. The boolean indicates failure or success. On failure, result holds a standard Unicat error response . On success, the result is a boolean that indicates if we're in sync (True), or if there's more data to be synced (False).




  If pathname is given for a (transformed) download, updated_on is checked earlier, so a transform call (which is fairly expensive) can be skipped.




  Renamed `get_assets_by_pathnames` to `get_assets_by_pathname`, and changed the return
  value to a dict keyed by pathname, for consistency with other by_name functions.

  ```python
  unicat.get_assets_by_pathname(pathnames: list[str], *, force: bool) -> dict[str, UnicatAsset]
  ```

  Fixed docs for by_name functions that fetch multiple items - they return dicts keyed by
  name. Fixed returned values for those to return empty dicts when the names list is
  empty.

  ```python
  unicat.get_definitions_by_name(names: list[str]) -> dict[str, UnicatDefinition]
  unicat.get_classes_by_name(names: list[str]) -> dict[str, UnicatClass]
  unicat.get_fields_by_name(names: list[str]) -> dict[str, UnicatField]
  unicat.get_record_queries_by_name(names: list[str]) -> dict[str, UnicatQuery]
  unicat.get_asset_queries_by_name(names: list[str]) -> dict[str, UnicatQuery]
  unicat.get_schema_queries_by_name(names: list[str]) -> dict[str, UnicatQuery]
  ```

  Fixed `walk_schema_query` crash.

  Fixed error-reporting from a UnicatJob gone wrong.




  New project properties and methods

  ```python
  project.backups: list[UnicatProjectBackup]
  project.get_backup(version: int) -> UnicatProjectBackup | None
  ```

  New UnicatProjectBackup class

  ```python
  backup.version: int
  backup.name: str
  backup.created_by: str
  backup.timestamp: timestamp  # 1610635123.351925
  ```

  New mutation methods

  ```python
  mutate.create_backup(created_by: str, name: str, return_job: Bool = False) -> UnicatProjectBackup | UnicatJob
  mutate.update_backup(backup: UnicatProjectBackup, name: str) -> UnicatProjectBackup
  mutate.restore_backup(backup: UnicatProjectBackup, return_job: Bool = False) -> UnicatProject | UnicatJob
  mutate.delete_backup(backup: UnicatProjectBackup) -> UnicatProject
  mutate.delete_backups(backups: list[UnicatProjectBackup]) -> UnicatProject
  ```




  All the things that came before

rpm_license:
  MIT License  Copyright (c) 2023-2024 Guidance Rotterdam BV  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: 60de49841c839bb937823e04d2b07bb70d384c30d1735437a4d93d69ff0985d2
name: python-unichat-help
arch: noarch
version: 2.1.5
epoch: 0
release: 1
summary: Development documents and examples for unichat
url: https://pypi.org/project/unichat/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unichat-2.1.5-1.src.rpm
location_href: Packages/python-unichat-help-2.1.5-1.noarch.rpm
checksum_type: sha256
description:
  Universal API chat Python client for OpenAI, MistralAI, Anthropic, xAI, and Google AI.


  ```shell
  rm -rf dist build *.egg-info
  ```
  ```shell
  python3 -m build
  ```
  ```shell
  twine upload dist/*
  ```



  1. Install the pip package:

  ```shell
  pip install unichat
  ```

  2. Add the class 'UnifiedChatApi' from module 'unichat' to your application:

  3. [optional] Import MODELS_LIST as well for additional validation


  Try the eclosed in the source code 'sample_chat.py' file:

  ```shell
  python3 sample_chat.py
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Stefan  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: f41533fa927dd76ae7d4222aaf74e52e469ec66bc769b68ee7c45a29b964f26a
name: python-unidas-help
arch: noarch
version: 0.0.0
epoch: 0
release: 1
summary: Development documents and examples for unidas
url: https://github.com/unidas-dev/unidas
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unidas-0.0.0-1.src.rpm
location_href: Packages/python-unidas-help-0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![coverage](https://codecov.io/gh/dasdae/unidas/branch/main/graph/badge.svg)](https://codecov.io/gh/dasdae/unidas)
  [![PyPI Version](https://img.shields.io/pypi/v/unidas.svg)](https://pypi.python.org/pypi/unidas)
  [![supported versions](https://img.shields.io/pypi/pyversions/unidas.svg?label=python_versions)](https://pypi.python.org/pypi/unidas)
  [![Licence](https://img.shields.io/badge/license-MIT-blue)](https://opensource.org/license/mit)

  A DAS compatibility package.

  There is an increasing number of open-source libraries for working with distributed acoustic sensing (DAS) data. Each of these has its own strengths and weaknesses, and often it is desirable to use features from multiple libraries in research workflows. Moreover, creators of DAS packages which perform specific operations (e.g., machine learning for phase picking) currently have to choose a single DAS library to support, or undertake writing conversion codes on their own.

  Unidas solves these problems by providing simple ways to interoperate between DAS libraries.



  There are two ways to use unidas. First, the `adapter` decorator allows a function to simply declare which library's data structure to use.

  ```python
  import unidas


  @unidas.adapter("daspy.Section")
  def daspy_function(sec, **kwargs):
      """A useful daspy function"""
      
      
      return sec


  import dascore as dc

  patch = dc.get_example_patch()

  out = daspy_function(patch)
  assert isinstance(out, dc.Patch)
  ```

  You can also use `adpater` to wrap un-wrapped functions.

  ```python
  import dascore as dc
  import unidas
  from xdas.signal import hilbert

  dascore_hilbert = unidas.adapter("xdas.DataArray")(hilbert)
  patch = dc.get_example_patch()

  patch_hilberto = dascore_hilbert(patch)
  ```

  The `convert` function converts from one library's data structure to another library's data structure.

  ```python
  import daspy
  import unidas


  sec = daspy.read()
  blast = unidas.convert(sec, to="lightguide.Blast")
  blast.afk_filter(exponent=0.8)
  sec_out = unidas.convert(blast, to='daspy.Section')
  ```


  Simply install unidas with pip or mamba:

  ```bash
  pip install unidas
  ```

  ```bash
  mamba install unidas
  ```

  By design, unidas has no hard dependencies other than numpy, but an `ImportError` will be raised if the libraries needed to perform a requested conversion are not installed.

  Unidas is single file (src/unidas.py) so it can also be vendored (copied directly into your project). If you do this, please consider sharing any improvements so the entire community can benefit.


  If you are creating/maintaining a library for doing some kind of specialized DAS processing in python, we recommend you do two things:

  1. Pick the DAS library you prefer and use it internally.
  2. Apply the `adapter` decorator to your project's API.

  Doing so will make your project easily accessible by users of all the libraries supported by unidas.

  For example:

  ```python
  import unidas

  @unidas.adapter("daspy.Section")
  def fancy_machine_learning_function(sec):
      """Cutting edge machine learning DAS research function."""
      
      
      

      ...  # Fancy stuff goes here.

      return sec
  ```



  To add support for a new data structure/library, you need to do two things:

  1. Create a subclass of `Converter` which has (at least) a conversion method to unidas' BaseDAS.
  2. Add a conversion method to UnidasBasDASConverter to convert from unidas' BaseDAS back to your data structure.
  3. Write a test in test/test_unidas.py (this is important for maintainability).

  Feel free to open a discussion if you need help.



  - [DASCore](https://github.com/DASDAE/dascore)
  - [DASPy](https://github.com/HMZ-03/DASPy)
  - [lightguide](https://github.com/pyrocko/lightguide)
  - [Xdas](https://github.com/xdas-dev/xdas)


pkgId: d645161e4942f2c381d8807ed973f50bce7ad2ccfa8b0cbf0e9668eda05be745
name: python-unifi-backup-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for unifi-backup
url: https://github.com/numo68/unifi-backup
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unifi-backup-0.2.2-1.src.rpm
location_href: Packages/python-unifi-backup-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  **unifi-backup** is a simple tool to fetch configuration backups from
  the UniFi Network Application.


pkgId: 21f32807d1e96d250b4aea64ae301d8a11fb420e642afa50f8d3f6112e9f2616
name: python-unified-planning-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for unified-planning
url: https://www.aiplan4eu-project.eu
rpm_license: APACHE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unified-planning-1.1.0-1.src.rpm
location_href: Packages/python-unified-planning-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Unified Planning: A library that makes it easy to formulate planning problems and to invoke automated planners.


pkgId: b9f9dae54bd1446c8deb0303cd0e79f0e0668bc21850653121dd0ac0250f4243
name: python-union-help
arch: noarch
version: 0.1.112
epoch: 0
release: 1
summary: Development documents and examples for union
description:
  The SDK for [Union.ai](https://www.union.ai/).



  Install `union`:

  ```bash
  pip install union
  ```

url: https://www.union.ai/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-union-0.1.112-1.src.rpm
location_href: Packages/python-union-help-0.1.112-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Source code in this repository is licensed under the Business Source License 1.1 (BSL) and the Apache License 2.0 (APL). A copy of each license can be found in the licenses directory. Source code in a given file is licensed under the BSL and the copyright belongs to Union Systems, Inc. unless otherwise noted at the beginning of the file.


pkgId: 3f25b076f4435674b8d30c9821232d6f0005ab4db7052ae79a40e2cb69b9aa7c
name: python-union-runtime-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for union-runtime
url: https://pypi.org/project/union-runtime/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-union-runtime-0.1.2-1.src.rpm
location_href: Packages/python-union-runtime-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  Union runtime library for [Union.ai](https://www.union.ai/).



  Install `union-runtime`:

  ```bash
  pip install union-runtime
  ```

rpm_license:
  Source code in this repository is licensed under the Business Source License 1.1 (BSL) and the Apache License 2.0 (APL). A copy of each license can be found in the licenses directory. Source code in a given file is licensed under the BSL and the copyright belongs to Union Systems, Inc. unless otherwise noted at the beginning of the file.


pkgId: 0dde1f369a01be322ec8a0a81ec25df63c1dd5db0af5c7bd24709f16b77d97eb
name: python-uniplot-help
arch: noarch
version: 0.16.2
epoch: 0
release: 1
summary: Development documents and examples for uniplot
url: https://github.com/olavolav/uniplot
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uniplot-0.16.2-1.src.rpm
location_href: Packages/python-uniplot-help-0.16.2-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/olavolav/uniplot/workflows/Unit%20Tests/badge.svg)](https://github.com/olavolav/uniplot/actions?query=workflow%3A"Unit+Tests")
  [![PyPI Version](https://badge.fury.io/py/uniplot.svg)](https://pypi.org/project/uniplot/)
  [![PyPI Downloads](https://pepy.tech/badge/uniplot)](https://pepy.tech/project/uniplot)

  Lightweight plotting to the terminal. 4x resolution via Unicode.

  ![uniplot demo GIF](https://github.com/olavolav/uniplot/raw/master/resource/uniplot-demo.gif)

  When working with production data science code it can be handy to have plotting
  tool that does not rely on graphics dependencies or works only in a Jupyter
  notebook.

  The **use case** that this was built for is to have plots as part of your data
  science / machine learning CI/CD pipeline - that way whenever something goes
  wrong, you get not only the error and backtrace but also plots that show what
  the problem was.




  * Unicode drawing, so 4x the resolution (pixels) of usual ASCII plots
  * Super simple API
  * Interactive mode (pass `interactive=True`)
  * Color mode (pass `color=True`) useful in particular when plotting multiple series
  * It's fast: Plotting 1M data points takes 100ms thanks to NumPy magic
  * Only one dependency: NumPy (but you have that anyway don't you)

  Please note that Unicode drawing will work correctly only when using a font
  that fully supports the [Block Elements character
  set](https://en.wikipedia.org/wiki/Box-drawing_character) or the [Braille
  character set](https://en.wikipedia.org/wiki/Braille_Patterns). Please refer to
  [this page for a (incomplete) list of supported
  fonts](https://www.fileformat.info/info/unicode/block/block_elements/fontsupport.htm)
  and the options below to select the character set.





  ```python
  import math
  x = [math.sin(i/20)+i/300 for i in range(600)]
  from uniplot import plot
  plot(x, title="Sine wave")
  ```

  Result:
  ```
                            Sine wave
  ┌────────────────────────────────────────────────────────────┐
  │                                                    ▟▀▚     │
  │                                                   ▗▘ ▝▌    │
  │                                       ▗▛▜▖        ▞   ▐    │
  │                                       ▞  ▜       ▗▌    ▌   │ 2
  │                           ▟▀▙        ▗▘  ▝▌      ▐     ▜   │
  │                          ▐▘ ▝▖       ▞    ▜      ▌     ▝▌  │
  │              ▗▛▜▖        ▛   ▜      ▗▌    ▝▌    ▐▘      ▜  │
  │              ▛  ▙       ▗▘   ▝▖     ▐      ▚    ▞       ▝▌ │
  │  ▟▀▖        ▐▘  ▝▖      ▟     ▚     ▌      ▝▖  ▗▌        ▜▄│ 1
  │ ▐▘ ▐▖       ▛    ▙      ▌     ▐▖   ▗▘       ▚  ▞           │
  │ ▛   ▙      ▗▘    ▐▖    ▐       ▙   ▞        ▝▙▟▘           │
  │▐▘   ▐▖     ▐      ▌    ▛       ▐▖ ▗▘                       │
  │▞     ▌     ▌      ▐   ▗▘        ▜▄▛                        │
  │▌─────▐────▐▘───────▙──▞────────────────────────────────────│ 0
  │       ▌   ▛        ▝▙▟▘                                    │
  │       ▜  ▐▘                                                │
  │        ▙▄▛                                                 │
  └────────────────────────────────────────────────────────────┘
           100       200       300       400       500       600
  ```

  For more examples, please see the `examples/` folder.




  The `plot` function accepts a number of parameters, all listed below. Note that
  only `ys` is required, all others are optional.

  There is also a `plot_to_string` function with the same signature, if you want
  the result as a list of strings, to include the output elsewhere. The only
  difference is that `plot_to_string` does not support interactive mode.




  * `xs` - The x coordinates of the points to plot. Can either be `None`, or a
    list or NumPy array for plotting a single series, or a list of those for
    plotting multiple series. Defaults to `None`, meaning that the x axis will be
    just the sample index of `ys`.
  * `ys` - The y coordinates of the points to plot. Can either be a list or NumPy
    array for plotting a single series, or a list of those for plotting multiple
    series.

  In both cases, NaN values are ignored.

  Note that since v0.12.0 you can also pass a list or an NumPy array of
  timestamps, and the axis labels should be formatted correctly. Limitations see
  below.




  In alphabetical order:



  * `color` - Draw series in color. Defaults to `False` when plotting a single
    series, and to `True` when plotting multiple. Also accepts a list of strings,
    to modify the default order of
    `["blue", "magenta", "green", "yellow", "cyan", "red"]`.
  * `height` - The height of the plotting region, in characters. Default is `17`.
  * `interactive` - Enable interactive mode. Defaults to `False`.
  * `legend_labels` - Labels for the series. Can be `None` or a list of strings.
    Defaults to `None`.
  * `lines` - Enable lines between points. Can either be `True` or `False`, or a
    list of Boolean values for plotting multiple series. Defaults to `False`.
  * `title` - The title of the plot. Defaults to `None`.
  * `width` - The width of the plotting region, in characters. Default is `60`.
    Note that if the `line_length_hard_cap` option (see "Advanced options" below)
    is used and there is not enough space, the actual width may be smaller.
  * `x_max` - Maximum x value of the view. Defaults to a value that shows all
    data points.
  * `x_min` - Minimum x value of the view. Defaults to a value that shows all
    data points.
  * `x_unit` - Unit of the x axis. This is a string that is appended to the axis
    labels. Defaults to `""`.
  * `y_max` - Maximum y value of the view. Defaults to a value that shows all
    data points.
  * `y_min` - Minimum y value of the view. Defaults to a value that shows all
    data points.
  * `y_unit` - Unit of the y axis. This is a string that is appended to the axis
    labels. Defaults to `""`.



  * `character_set` - Which Unicode character set to use. Use `"block"` for
    the [Block Elements character
    set](https://en.wikipedia.org/wiki/Block_Elements) with 4x resolution, or
    `"braille"` for the [Braille character
    set](https://en.wikipedia.org/wiki/Braille_Patterns) with 8x resolution.
    The latter has a lighter look overall. Defaults to `"block"`.
  * `force_ascii` - Force ASCII characters for plotting only. This can be useful
    for compatibility, for example when using uniplot inside of CI/CD systems
    that do not support Unicode. Defaults to `False`.
  * `force_ascii_characters` -  List of characters to use when plotting in
    `force_ascii` mode. Default to `["+", "x", "o", "*", "~", "."]`.
  * `line_length_hard_cap` - Enforce a hard limit on the number of characters per
    line of the plot area. This may override the `width` option if there is not
    enough space. Defaults to `None`.
  * `x_as_log` - Plot the x axis as logarithmic scale. Defaults to `False`.
  * `x_gridlines` - A list of x values that have a vertical line for better
    orientation. Defaults to `[0]`, or to `[]` if `x_as_log` is enabled.
  * `y_as_log` - Plot the y axis as logarithmic scale. Defaults to `False`.
  * `y_gridlines` - A list of y values that have a horizontal line for better
    orientation. Defaults to `[0]`, or to `[]` if `y_as_log` is enabled.




  uniplot does not store a state of the configuration parameters. However, you
  can define a new plot funtion with new defaults by defining a `partial`. See
  the following example:

  ```python
  from functools import partial
  from uniplot import plot as default_plot
  plot = partial(default_plot, height=25, width=80)
  ```

  This defines a new `plot` function that is identical to the original, except
  the default values for `width` and `height` are now different.






  For convenience there is also a `histogram` function that accepts one or more
  series and plots bar-chart like histograms. It will automatically discretize
  the series into a number of bins given by the `bins` option and display the
  result.

  Additional options, in alphabetical order:

  * `bins` - Number of bins to use. Defaults to `20`.
  * `bins_min` - Lower limit of the first bin. Defaults to the minimum of the
    series.
  * `bins_max` - Upper limit of the last bin. Defaults to the maximum of the
    series.

  When calling the `histogram` function, the `lines` option is `True` by default.

  Example:

  ```python
  import numpy as np
  x = np.sin(np.linspace(1, 1000))
  from uniplot import histogram
  histogram(x)
  ```

  Result:
  ```
  ┌────────────────────────────────────────────────────────────┐
  │   ▛▀▀▌                       │                   ▐▀▀▜      │ 5
  │   ▌  ▌                       │                   ▐  ▐      │
  │   ▌  ▌                       │                   ▐  ▐      │
  │   ▌  ▀▀▀▌                    │                ▐▀▀▀  ▝▀▀▜   │
  │   ▌     ▌                    │                ▐        ▐   │
  │   ▌     ▌                    │                ▐        ▐   │
  │   ▌     ▙▄▄▄▄▄▖              │          ▗▄▄▄  ▐        ▐   │
  │   ▌           ▌              │          ▐  ▐  ▐        ▐   │
  │   ▌           ▌              │          ▐  ▐  ▐        ▐   │
  │   ▌           ▌              │          ▐  ▐  ▐        ▐   │
  │   ▌           ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▜  ▐▀▀▀  ▝▀▀▀        ▐   │
  │   ▌                          │    ▐  ▐                 ▐   │
  │   ▌                          │    ▐  ▐                 ▐   │
  │   ▌                          │    ▐▄▄▟                 ▐   │
  │   ▌                          │                         ▐   │
  │   ▌                          │                         ▐   │
  │▄▄▄▌▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁│▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▐▄▄▄│ 0
  └────────────────────────────────────────────────────────────┘
       -1                        0                       1
  ```



  There is inital support for using timestamps for the axis labels. It should
  work with most formats.

  Missing so far are nicer axis labels for time stamps, as well as timezone
  support.

  Example:

  ```python
  import numpy as np
  dates =  np.arange('2024-02-17T12:10', 4*60, 60, dtype='M8[m]')
  from uniplot import plot
  plot(xs=dates, ys=[1,2,3,2])
  ```

  Result:
  ```
  ┌────────────────────────────────────────────────────────────┐
  │                                       ▝                    │ 3
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                    ▘                                      ▝│ 2
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │                                                            │
  │▖                                                           │ 1
  └────────────────────────────────────────────────────────────┘
                 13:00               14:00               15:00
  ```




  Install via pip using:

  ```sh
  pip install uniplot
  ```




  Clone this repository, and install dependecies via `poetry install`.

  You can run the tests via `poetry run ./run_tests` to make sure your setup is
  good. Then proceed with issues, PRs etc. the usual way.


pkgId: 00db8611b2fc1c47bc5ee650efb1830c5af44cf8e896d7ffdd431105a06de278
name: python-unique_sdk-help
arch: noarch
version: 0.9.15
epoch: 0
release: 1
summary: Development documents and examples for unique_sdk
url: https://pypi.org/project/unique_sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unique_sdk-0.9.15-1.src.rpm
location_href: Packages/python-unique_sdk-help-0.9.15-1.noarch.rpm
checksum_type: sha256
description:
  Unique FinanceGPT is a tailored solution for the financial industry, designed to increase productivity by automating manual workloads through AI and ChatGPT solutions.

  The Unique Python SDK provides access to the public API of Unique FinanceGPT. It also enables verification of Webhook signatures to ensure the authenticity of incoming Webhook requests.



  1. [Installation](#installation)
  2. [Requirements](#requirements)
  3. [Usage Instructions](#usage-instructions)
  4. [Webhook Triggers](#webhook-triggers)
  5. [Available API Resources](#available-api-resources)
     - [Content](#content)
     - [Message](#message)
     - [Chat Completion](#chat-completion)
     - [Embeddings](#embeddings)
     - [Acronyms](#acronyms)
     - [Search](#search)
     - [Search String](#search-string)
     - [Short Term Memory](#short-term-memory)
  6. [UniqueQL](#uniqueql)
     - [Query Structure](#uniqueql-query-structure)
     - [Metadata Filtering](#metadata-filtering)
  7. [Util functions](#utils)
     - [Chat History](#chat-history)
     - [File Io](#file-io)
     - [Sources](#sources)
     - [token](#token)
  8. [Error Handling](#error-handling)
  9. [Examples](#examples)



  Install UniqueSDK and its peer dependency `requests` and when planning to run async requests also `httpx` or `aiohttp` via pip using the following commands:

  ```bash
  pip install unique_sdk
  pip install requests
  ```

  Optional for async requests:

  ```bash
  pip install httpx
  ```

  or

  ```bash
  pip install aiohttp
  ```



  - Python >=3.11 (Other Python versions 3.6+ might work but are not tested)
  - requests (peer dependency. Other HTTP request libraries might be supported in the future)
  - Unique App-ID & API Key

  Please contact your customer success manager at Unique for your personal developer App-ID & API Key.



  The library needs to be configured with your Unique `app_id` & `api_key`. Additionally, each individual request must be scoped to a User and provide a `user_id` & `company_id`.

  ```python
  import unique_sdk
  unique_sdk.api_key = "ukey_..."
  unique_sdk.app_id = "app_..."
  ```

  The SDK includes a set of classes for API resources. Each class contains CRUD methods to interact with the resource.



  ```python
  import unique_sdk
  unique_sdk.api_key = "ukey_..."
  unique_sdk.app_id = "app_..."


  messages = unique_sdk.Message.list(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
  )

  print(messages.data[0].text)
  ```



  A core functionality of FinanceGPT is the ability for users to engage in an interactive chat feature. SDK developers can hook into this chat to provide new functionalities.

  Your App (refer to `app-id` in [Requirements](#requirements)) must be subscribed to each individual Unique event in order to receive a webhook.

  Each webhook sent by Unique includes a set of headers:

  ```yaml
  X-Unique-Id: evt_... # Event id, same as in the body.
  X-Unique-Signature: ... # A HMAC-SHA256 hex signature of the entire body.
  X-Unique-Version: 1.0.0 # Event payload version.
  X-Unique-Created-At: 1705960141 # Unix timestamp (seconds) of the delivery time.
  X-Unique-User-Id: ... # The user who initiated the message.
  X-Unique-Company-Id: ... # The company to which the user belongs.
  ```



  - Webhooks are considered successfully delivered if your endpoint returns a status code between `200` and `299`.
  - If your endpoint returns a status code of `300` - `399`, `429`, or `500` - `599`, Unique will retry the delivery of the webhook with an exponential backoff up to five times.
  - If your endpoint returns any other status (e.g., `404`), it is marked as expired and will not receive any further requests.



  The webhook body, containing a timestamp of the delivery time, is signed with HMAC-SHA256. Verify the signature by constructing the `event` with the `unique_sdk.Webhook` class:

  ```python
  from http import HTTPStatus
  from flask import Flask, jsonify, request
  import unique_sdk

  endpoint_secret = "YOUR_ENDPOINT_SECRET"

  @app.route("/webhook", methods=["POST"])
  def webhook():
      event = None
      payload = request.data

      sig_header = request.headers.get("X-Unique-Signature")
      timestamp = request.headers.get("X-Unique-Created-At")

      if not sig_header or not timestamp:
          print("⚠️  Webhook signature or timestamp headers missing.")
          return jsonify(success=False), HTTPStatus.BAD_REQUEST

      try:
          event = unique_sdk.Webhook.construct_event(
              payload, sig_header, timestamp, endpoint_secret
          )
      except unique_sdk.SignatureVerificationError as e:
          print("⚠️  Webhook signature verification failed. " + str(e))
          return jsonify(success=False), HTTPStatus.BAD_REQUEST
  ```

  The `construct_event` method will compare the signature and raise a `unique_sdk.SignatureVerificationError` if the signature does not match. It will also raise this error if the `createdAt` timestamp is outside of a default tolerance of 5 minutes. Adjust the `tolerance` by passing a fifth parameter to the method (tolerance in seconds), e.g.:

  ```python
  event = unique_sdk.Webhook.construct_event(
      payload, sig_header, timestamp, endpoint_secret, 0
  )
  ```





  ```json
  {
    "id": "evt_...", // see header
    "version": "1.0.0", // see header
    "event": "unique.chat.user-message.created", // The name of the event
    "createdAt": "1705960141", // see header
    "userId": "...", // see header
    "companyId": "...", // see header
    "payload": {
      "chatId": "chat_...", // The id of the chat
      "assistantId": "assistant_...", // The id of the selected assistant
      "text": "Hello, how can I help you?" // The user message
    }
  }
  ```

  This webhook is triggered for every new chat message sent by the user. This event occurs regardless of whether it is the first or a subsequent message in a chat. Use the `unique_sdk.Message` class to retrieve other messages from the same `chatId` or maintain a local state of the messages in a single chat.

  This trigger can be used in combination with assistants marked as `external`. Those assistants will not execute any logic, enabling your code to respond to the user message and create an answer.



  ```json
  {
    "id": "evt_...",
    "version": "1.0.0",
    "event": "unique.chat.external-module.chosen",
    "createdAt": "1705960141", // Unix timestamp (seconds)
    "userId": "...",
    "companyId": "...",
    "payload": {
      "name": "example-sdk", // The name of the module selected by the module chooser
      "description": "Example SDK", // The description of the module
      "configuration": {}, // Module configuration in JSON format
      "chatid": "chat_...", // The chat ID
      "assistantId:": "assistant_...", // The assistant ID
      "userMessage": {
        "id": "msg_...",
        "text": "Hello World!", // The user message leading to the module selection
        "createdAt": "2024-01-01T00:00:00.000Z" // ISO 8601
      },
      "assistantMessage": {
        "id": "msg_...",
        "createdAt": "2024-01-01T00:00:00.000Z" // ISO 8601
      }
    }
  }
  ```

  This Webhook is triggered when the Unique FinanceGPT AI selects an external module as the best response to a user message. The module must be marked as `external` and available for the assistant used in the chat to be selected by the AI.

  Unique's UI will create an empty `assistantMessage` below the user message and update this message with status updates.

  **The SDK is expected to modify this assistantMessage with its answer to the user message.**

  ```python
  unique_sdk.Message.modify(
      user_id=user_id,
      company_id=company_id,
      id=assistant_message_id,
      chatId=chat_id,
      text="Here is your answer.",
  )
  ```



  - [Content](#content)
  - [Message](#message)
  - [Chat Completion](#chat-completion)
  - [Search](#search)
  - [Search String](#search-string)

  Most of the API services provide an asynchronous version of the method. The async methods are suffixed with `_async`.





  Allows you to load full content/files from the knowledge-base of unique with the rights of the userId and companyId. Provided a `where` query for filtering. Filtering can be done on any of the following fields: `

  - `id`
  - `key`
  - `ownerId`
  - `title`
  - `url`

  Here an example of retrieving all files that contain the number 42 in the `title` or the `key` typically this is used to search by filename.

  ```python
  unique_sdk.Content.search(
      user_id=userId,
      company_id=companyId,
      where={
          "OR": [
              {
                  "title": {
                      "contains": "42",
                  },
              },
              {
                  "key": {
                      "contains": "42",
                  },
              },
          ],
      },
      chatId=chatId,
  )
  ```



  Enables upload of a new Content into the Knowledge base of unique into a specific scope with `scopeId` or a specific `chatId`. One of the two must be set.

  Typical usage is the following. That creates a Content and uploads a file

  ```python

  createdContent = upload_file(
      userId,
      companyId,
      "/path/to/file.pdf",
      "test.pdf",
      "application/pdf",
      "scope_stcj2osgbl722m22jayidx0n",
  )

  def upload_file(
      userId,
      companyId,
      path_to_file,
      displayed_filename,
      mimeType,
      scope_or_unique_path,
  ):
      size = os.path.getsize(path_to_file)
      createdContent = unique_sdk.Content.upsert(
          user_id=userId,
          company_id=companyId,
          input={
              "key": displayed_filename,
              "title": displayed_filename,
              "mimeType": mimeType,
          },
          scopeId=scope_or_unique_path,
      )

      uploadUrl = createdContent.writeUrl

      
      with open(path_to_file, "rb") as file:
          requests.put(
              uploadUrl,
              data=file,
              headers={
                  "X-Ms-Blob-Content-Type": mimeType,
                  "X-Ms-Blob-Type": "BlockBlob",
              },
          )

      unique_sdk.Content.upsert(
          user_id=userId,
          company_id=companyId,
          input={
              "key": displayed_filename,
              "title": displayed_filename,
              "mimeType": mimeType,
              "byteSize": size,
          },
          scopeId=scope_or_unique_path,
          readUrl=createdContent.readUrl,
      )

      return createdContent

  ```





  Retrieve a list of messages for a provided `chatId`.

  ```python
  messages = unique_sdk.Message.list(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
  )
  ```



  Get a single chat message.

  ```python
  message = unique_sdk.Message.retrieve(
      user_id=user_id,
      company_id=company_id,
      id=message_id,
      chatId=chat_id,
  )
  ```



  Create a new message in a chat.

  ```python
  message = unique_sdk.Message.create(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
      assistantId=assistant_id,
      text="Hello.",
      role="ASSISTANT",
  )
  ```



  Modify an existing chat message.

  ℹ️ if you modify the debugInfo only do it on the user message as this is the only place that is displayed in the frontend.

  ```python
  message = unique_sdk.Message.modify(
      user_id=user_id,
      company_id=company_id,
      id=message_id,
      chatId=chat_id,
      text="Updated message text"
  )
  ```



  Delete a chat message.

  ```python
  message = unique_sdk.Message.delete(
      message_id,
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
  )
  ```



  Streams the answer to the chat frontend. Given the messages.

  if the stream creates [source0] it is referenced with the references from the search context.

  E.g.

  ```
  Hello this information is from [srouce1]
  ```

  adds the reference at index 1 and then changes the text to:

  ```
  Hello this information is from <sub>0</sub>
  ```

  ```python
  unique_sdk.Integrated.chat_stream_completion(
      user_id=userId,
      company_id=companyId,
      assistantMessageId=assistantMessageId,
      userMessageId=userMessageId,
      messages=[
          {
              "role": "system",
              "content": "be friendly and helpful"
          },
          {
              "role": "user",
              "content": "hello"
          }
      ],
      chatId=chatId,

      searchContext=  [
          {
              "id": "ref_qavsg0dcl5cbfwm1fvgogrvo",
              "chunkId": "0",
              "key": "some reference.pdf : 8,9,10,11",
              "sequenceNumber": 1,
              "url": "unique://content/cont_p8n339trfsf99oc9f36rn4wf"
          }
      ],  # optional
      debugInfo={
          "hello": "test"
      }, # optional
      startText= "I want to tell you about: ", # optional
      model= "AZURE_GPT_4_32K_0613", # optional
      timeout=8000,  # optional in ms
      options={
                  "temperature": 0.5
              } # optional
  )
  ```

  **Warning:** Currently, the deletion of a chat message does not automatically sync with the user UI. Users must refresh the chat page to view the updated state. This issue will be addressed in a future update of our API.





  Send a prompt to an AI model supported by Unique FinanceGPT and receive a result. The `messages` attribute must follow the [OpenAI API format](https://platform.openai.com/docs/api-reference/chat).

  ```python
  chat_completion = unique_sdk.ChatCompletion.create(
      company_id=company_id,
      model="AZURE_GPT_35_TURBO",
      messages=[
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"},
      ],
      options={
              "temperature": 0.5
          } # optional
  )
  ```





  Sends an array of `text` to the AI model for embedding. And retrieve a vector of embeddings.

  ```python
  result = unique_sdk.Embeddings.create(
      user_id=user_id,
      company_id=company_id,
      texts=["hello", "hello"],
  )
  print(result.embeddings[0][0])
  ```





  Fetches the acronyms defined on the company. Often used to replace in user prompts, so the acronym is resolved to give better guidance to the LLM during completion.

  ```python
  result = unique_sdk.Acronyms.get(
      user_id=user_id,
      company_id=company_id,
  )
  print(result)
  ```





  Search the Unique FinanceGPT Knowledge database for RAG (Retrieval-Augmented Generation). The API supports vector search and a `searchType` that combines vector and full-text search, enhancing the precision of search results.

  These are the options are available for `searchType`:

  - `VECTOR`
  - `COMBINED`

  `limit` (max 1000) and `page` are optional for iterating over results.
  `chatOnly` Restricts the search exclusively to documents uploaded within the chat.
  `scopeIds` Specifies a collection of scope IDs to confine the search.
  `language` Optional. The language specification for full text search.
  `reranker` Optional. The reranker service to be used for re-ranking the search results.

  ```python
  search = unique_sdk.Search.create(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id
      searchString="What is the meaning of life, the universe and everything?",
      searchType="VECTOR",
      chatOnly=false,
      scopeIds=["scope_..."],
      language="German",
      reranker={"deploymentName": "my_deployment"},
      limit=20,
      page=1
  )
  ```





  User messages are sometimes suboptimal as input prompts for vector or full-text knowledge base searches. This is particularly true as a conversation progresses and a user question may lack crucial context for a successful search.

  This API transforms and translates (into English) the user's message into an ideal search string for use in the [Search.create](#unique_sdksearchcreate) API method.

  Adding a `chatId` or `messages` as arguments allows the message history to provide additional context to the search string. For example, "Who is the author?" will be expanded to "Who is the author of the book 'The Hitchhiker's Guide to the Galaxy'?" if previous messages referenced the book.

  ```python
  search_string = unique_sdk.SearchString.create(
      user_id=user_id,
      company_id=company_id,
      prompt="Was ist der Sinn des Lebens, des Universums und des ganzen Rests?",
      chat_id=chat_id
  )
  ```



  For saving data in between chats there is the Short Term Memory functionality to save small data in between rounds of chat e.g. language, search results and so on.
  For this 10k chars can be used. You can save a short term memory for a chat `chatId` or for a message `messageId`.
  you need to provide an `memoryName` as an identifier.

  you can then save it and retreive it live defined below.



  ```python
  c = unique_sdk.ShortTermMemory.create(
      user_id=user_id,
      company_id=company_id,
      data="hello",
      chatId="chat_x0xxtj89f7drjp4vmued3q",
      
      memoryName="your memory name",
  )
  print(c)
  ```



  ```python
  m = unique_sdk.ShortTermMemory.find_latest(
      user_id=user_id,
      company_id=company_id,
      chatId="chat_x0xxtj89f7drjp4vmued3q",
       
      memoryName="your memory name",
  )
  print(m)
  ```



  [UniqueQL](https://unique-ch.atlassian.net/wiki/x/coAXHQ) is an advanced query language designed to enhance search capabilities within various search modes such as Vector, Full-Text Search (FTS), and Combined. This query language enables users to perform detailed searches by filtering through metadata attributes like filenames, URLs, dates, and more. UniqueQL is versatile and can be translated into different query formats for various database systems, including PostgreSQL and Qdrant.



  A UniqueQL query is composed of a path, an operator, and a value. The path specifies the metadata attribute to be filtered, the operator defines the type of comparison, and the value provides the criteria for the filter.

  A metadata filter can be designed with UniqueQL's `UQLOperator` and `UQLCombinator` as follows:

  ```python
  metadata_filter = {
          "path": ['diet', '*'],
          "operator": UQLOperator.NESTED,
          "value": {
              UQLCombinator.OR : [
                  {
                      UQLCombinator.OR: [
                          {
                              "path": ['food'],
                              "operator": UQLOperator.EQUALS,
                              "value": "meat",
                          },
                          {
                              "path": ['food'],
                              "operator": UQLOperator.EQUALS,
                              "value": 'vegis',
                          },
                      ],
                  },
                  {
                      "path": ['likes'],
                      "operator": UQLOperator.EQUALS,
                      "value": true,
                  },
              ],
          },
      }
  ```



  A metadata filter such as the one designed above can be used in a `Search.create` call by passing it the `metaDataFilter` parameter.

  ```python
      search_results = unique_sdk.Search.create(
          user_id=user_id,
          company_id=company_id,
          chatId=chat_id,
          searchString=search_string,
          searchType="COMBINED",
          
          metaDataFilter=metadata_filter,
      )
  ```







  A helper function that makes sure the chat history is fully loaded and cut to the size of the token window that it fits into the next round of chat interactions.

  - `maxTokens` max tokens of the model used
  - `percentOfMaxTokens`=0.15 % max history in % of `maxTokens`
  - `maxMessages`=4, maximal number of messages included in the history.

  this method also directly returns a correct formatted history that can be used in the next chat round.

  ```python
  history = unique_sdk.utils.chat_history.load_history(
      userId,
      companyId,
      chatId
  )
  ```



  convert history into a string that can be injected into a prompt. it als returns the token length of the converted history.

  ```
  chat_history-string, chat_context_token_length = unique_sdk.utils.chat_history.convert_chat_history_to_injectable_string(
      history
  )
  ```



  Interacting with the knowledge-base.



  download files and save them into a folder in `/tmp`

  for example using the readUrl from a content.

  ```python
  pdfFile = download_content(
      companyId=companyId,
      userId=userId,
      content_id="cont_12412",
      filename="hello.pdf",
      chat_id=None # If specified, it downloads it from the chat
  }
  ```



  Allows for uploading files that then get ingested in a scope or a chat.

  ```python
  createdContent = upload_file(
      companyId=companyId,
      userId=userId,
      path_to_file="/tmp/hello.pdf",
      displayed_filename="hello.pdf",
      mimeType="application/pdf",
      uploadScope="scope_stcj2osgbl722m22jayidx0n",
      chat_id=None,
  )
  ```





  Merges multiple search results based on their 'id', removing redundant document and info markers.

  This function groups search results by their 'id' and then concatenates their texts,
  cleaning up any document or info markers in subsequent chunks beyond the first one.

  Parameters:

  - searchContext (list): A list of dictionaries, each representing a search result with 'id' and 'text' keys.

  Returns:

  - list: A list of dictionaries with merged texts for each unique 'id'.

  `searchContext` is an list of search objects that are returned by the search.

  ```python
  search = unique_sdk.Search.create(
      user_id=userId,
      company_id=companyId,
      chatId=chatId,
      searchString="Who is Harry P?",
      searchType="COMBINED",
      scopeIds="scope_dsf...",
      limit=30,
      chatOnly=False,
  )

  searchContext = unique_sdk.util.token.pick_search_results_for_token_window(
          search["data"], config["maxTokens"] - historyLength
      )

  searchContext = unique_sdk.util.sources.merge_sources(search)

  ```



  Sort sources by order of appearance in documents

  ```python

  search = unique_sdk.Search.create(
      user_id=userId,
      company_id=companyId,
      chatId=chatId,
      searchString="Who is Harry P?",
      searchType="COMBINED",
      scopeIds="scope_dsf...",
      limit=30,
      chatOnly=False,
  )

  searchContext = unique_sdk.util.token.pick_search_results_for_token_window(
          search["data"], config["maxTokens"] - historyLength
      )

  searchContext = unique_sdk.util.sources.sort_sources(search)
  ```



  Post-processes the provided text by converting source references into superscript numerals (required
  format by backend to display sources in the chat window)

  This function searches the input text for patterns that represent source references (e.g., [source1])
  and replaces them with superscript tags, incrementing the number by one.

  Parameters:

  - text (str): The text to be post-processed.

  Returns:

  - str: The text with source references replaced by superscript numerals.

  Examples:

  - postprocessSources("This is a reference [source0]") will return "This is a reference <sup>1</sup>".

  ```python

  text_with_sup = post_process_sources(text)
  ```





  Selects and returns a list of search results that fit within a specified token limit.

  This function iterates over a list of search results, each with a 'text' field, and
  encodes the text using a predefined encoding scheme. It accumulates search results
  until the token limit is reached or exceeded.

  Parameters:

  - searchResults (list): A list of dictionaries, each containing a 'text' key with string value.
  - tokenLimit (int): The maximum number of tokens to include in the output.

  Returns:

  - list: A list of dictionaries representing the search results that fit within the token limit.

  ```python
  search = unique_sdk.Search.create(
      user_id=userId,
      company_id=companyId,
      chatId=chatId,
      searchString="Who is Harry P?",
      searchType="COMBINED",
      scopeIds="scope_dsf...",
      limit=30,
      chatOnly=False,
  )

  searchContext = unique_sdk.util.token.pick_search_results_for_token_window(
          search["data"], config["maxTokens"] - historyLength
      )
  ```



  Counts the number of tokens in the provided text.

  This function encodes the input text using a predefined encoding scheme
  and returns the number of tokens in the encoded text.

  Parameters:

  - text (str): The text to count tokens for.

  Returns:

  - int: The number of tokens in the text.

  ```python
  hello = "hello you!"
  searchContext = unique_sdk.util.token.count_tokens(hello)
  ```





  An example Flask app demonstrating the usage of each API resource and how to interact with Webhooks is available in our repository at `/examples/custom-assistant`.



  This is a _fork_ / inspired-by the fantastic Stripe Python SDK (https://github.com/stripe/stripe-python).



  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).



  - Add `Internal server error` and `You can retry your request` to the retry logic


  - Add `contentIds` to `Search.create` and `Search.create_async`


  - Add retry for `5xx` errors, add additional error message.


  - Include original error message in returned exceptions


  - Add  `ingestionConfig` to `UpsertParams.Input` parameters


  - Remove `temperature` parameter from `Integrated.chat_stream_completion`, `Integrated.chat_stream_completion_async`, `ChatCompletion.create` and `ChatCompletion.create_async` methods. To use `temperature` parameter, set the attribute in `options` parameter instead.


  - Revert deletion of `Message.retrieve` method


  - Add `retries` for `_static_request` and `_static_request_async` in `APIResource` - When the error messages contains either  `"problem proxying the request"`,
          or `"Upstream service reached a hard timeout"`,

  - Add `completedAt` to `CreateParams` of `Message`


  - Added `metaDataFilter` to `Search` parameters.


  - Add `completedAt` to `ModifyParams`


  - Add `close` and `close_async` to `http_client`
  - Make `httpx` the default client for async requests


  - `Search.create`, `Message`, `ChatCompletion` parameters that were marked `NotRequired` are now also `Optional`


  - Bug fix in `Search.create`: langugage -> language


  - Added parameters to `Search.create` and `Search.create_async`
      - `language` for full text search
      - `reranker` to reranker search results


  - Added the possibility to make async requests to the unique APIs using either aiohttp or httpx as client


pkgId: 50294df634f7df0ef6d72cb3df96ddf116790c5dad73836a3b011694cd702d24
name: python-unique_sdk-help
arch: noarch
version: 0.9.16
epoch: 0
release: 1
summary: Development documents and examples for unique_sdk
url: https://pypi.org/project/unique_sdk/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unique_sdk-0.9.16-1.src.rpm
location_href: Packages/python-unique_sdk-help-0.9.16-1.noarch.rpm
checksum_type: sha256
description:
  Unique FinanceGPT is a tailored solution for the financial industry, designed to increase productivity by automating manual workloads through AI and ChatGPT solutions.

  The Unique Python SDK provides access to the public API of Unique FinanceGPT. It also enables verification of Webhook signatures to ensure the authenticity of incoming Webhook requests.



  1. [Installation](#installation)
  2. [Requirements](#requirements)
  3. [Usage Instructions](#usage-instructions)
  4. [Webhook Triggers](#webhook-triggers)
  5. [Available API Resources](#available-api-resources)
     - [Content](#content)
     - [Message](#message)
     - [Chat Completion](#chat-completion)
     - [Embeddings](#embeddings)
     - [Acronyms](#acronyms)
     - [Search](#search)
     - [Search String](#search-string)
     - [Short Term Memory](#short-term-memory)
  6. [UniqueQL](#uniqueql)
     - [Query Structure](#uniqueql-query-structure)
     - [Metadata Filtering](#metadata-filtering)
  7. [Util functions](#utils)
     - [Chat History](#chat-history)
     - [File Io](#file-io)
     - [Sources](#sources)
     - [token](#token)
  8. [Error Handling](#error-handling)
  9. [Examples](#examples)



  Install UniqueSDK and its peer dependency `requests` and when planning to run async requests also `httpx` or `aiohttp` via pip using the following commands:

  ```bash
  pip install unique_sdk
  pip install requests
  ```

  Optional for async requests:

  ```bash
  pip install httpx
  ```

  or

  ```bash
  pip install aiohttp
  ```



  - Python >=3.11 (Other Python versions 3.6+ might work but are not tested)
  - requests (peer dependency. Other HTTP request libraries might be supported in the future)
  - Unique App-ID & API Key

  Please contact your customer success manager at Unique for your personal developer App-ID & API Key.



  The library needs to be configured with your Unique `app_id` & `api_key`. Additionally, each individual request must be scoped to a User and provide a `user_id` & `company_id`.

  ```python
  import unique_sdk
  unique_sdk.api_key = "ukey_..."
  unique_sdk.app_id = "app_..."
  ```

  The SDK includes a set of classes for API resources. Each class contains CRUD methods to interact with the resource.



  ```python
  import unique_sdk
  unique_sdk.api_key = "ukey_..."
  unique_sdk.app_id = "app_..."


  messages = unique_sdk.Message.list(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
  )

  print(messages.data[0].text)
  ```



  A core functionality of FinanceGPT is the ability for users to engage in an interactive chat feature. SDK developers can hook into this chat to provide new functionalities.

  Your App (refer to `app-id` in [Requirements](#requirements)) must be subscribed to each individual Unique event in order to receive a webhook.

  Each webhook sent by Unique includes a set of headers:

  ```yaml
  X-Unique-Id: evt_... # Event id, same as in the body.
  X-Unique-Signature: ... # A HMAC-SHA256 hex signature of the entire body.
  X-Unique-Version: 1.0.0 # Event payload version.
  X-Unique-Created-At: 1705960141 # Unix timestamp (seconds) of the delivery time.
  X-Unique-User-Id: ... # The user who initiated the message.
  X-Unique-Company-Id: ... # The company to which the user belongs.
  ```



  - Webhooks are considered successfully delivered if your endpoint returns a status code between `200` and `299`.
  - If your endpoint returns a status code of `300` - `399`, `429`, or `500` - `599`, Unique will retry the delivery of the webhook with an exponential backoff up to five times.
  - If your endpoint returns any other status (e.g., `404`), it is marked as expired and will not receive any further requests.



  The webhook body, containing a timestamp of the delivery time, is signed with HMAC-SHA256. Verify the signature by constructing the `event` with the `unique_sdk.Webhook` class:

  ```python
  from http import HTTPStatus
  from flask import Flask, jsonify, request
  import unique_sdk

  endpoint_secret = "YOUR_ENDPOINT_SECRET"

  @app.route("/webhook", methods=["POST"])
  def webhook():
      event = None
      payload = request.data

      sig_header = request.headers.get("X-Unique-Signature")
      timestamp = request.headers.get("X-Unique-Created-At")

      if not sig_header or not timestamp:
          print("⚠️  Webhook signature or timestamp headers missing.")
          return jsonify(success=False), HTTPStatus.BAD_REQUEST

      try:
          event = unique_sdk.Webhook.construct_event(
              payload, sig_header, timestamp, endpoint_secret
          )
      except unique_sdk.SignatureVerificationError as e:
          print("⚠️  Webhook signature verification failed. " + str(e))
          return jsonify(success=False), HTTPStatus.BAD_REQUEST
  ```

  The `construct_event` method will compare the signature and raise a `unique_sdk.SignatureVerificationError` if the signature does not match. It will also raise this error if the `createdAt` timestamp is outside of a default tolerance of 5 minutes. Adjust the `tolerance` by passing a fifth parameter to the method (tolerance in seconds), e.g.:

  ```python
  event = unique_sdk.Webhook.construct_event(
      payload, sig_header, timestamp, endpoint_secret, 0
  )
  ```





  ```json
  {
    "id": "evt_...", // see header
    "version": "1.0.0", // see header
    "event": "unique.chat.user-message.created", // The name of the event
    "createdAt": "1705960141", // see header
    "userId": "...", // see header
    "companyId": "...", // see header
    "payload": {
      "chatId": "chat_...", // The id of the chat
      "assistantId": "assistant_...", // The id of the selected assistant
      "text": "Hello, how can I help you?" // The user message
    }
  }
  ```

  This webhook is triggered for every new chat message sent by the user. This event occurs regardless of whether it is the first or a subsequent message in a chat. Use the `unique_sdk.Message` class to retrieve other messages from the same `chatId` or maintain a local state of the messages in a single chat.

  This trigger can be used in combination with assistants marked as `external`. Those assistants will not execute any logic, enabling your code to respond to the user message and create an answer.



  ```json
  {
    "id": "evt_...",
    "version": "1.0.0",
    "event": "unique.chat.external-module.chosen",
    "createdAt": "1705960141", // Unix timestamp (seconds)
    "userId": "...",
    "companyId": "...",
    "payload": {
      "name": "example-sdk", // The name of the module selected by the module chooser
      "description": "Example SDK", // The description of the module
      "configuration": {}, // Module configuration in JSON format
      "chatid": "chat_...", // The chat ID
      "assistantId:": "assistant_...", // The assistant ID
      "userMessage": {
        "id": "msg_...",
        "text": "Hello World!", // The user message leading to the module selection
        "createdAt": "2024-01-01T00:00:00.000Z" // ISO 8601
      },
      "assistantMessage": {
        "id": "msg_...",
        "createdAt": "2024-01-01T00:00:00.000Z" // ISO 8601
      }
    }
  }
  ```

  This Webhook is triggered when the Unique FinanceGPT AI selects an external module as the best response to a user message. The module must be marked as `external` and available for the assistant used in the chat to be selected by the AI.

  Unique's UI will create an empty `assistantMessage` below the user message and update this message with status updates.

  **The SDK is expected to modify this assistantMessage with its answer to the user message.**

  ```python
  unique_sdk.Message.modify(
      user_id=user_id,
      company_id=company_id,
      id=assistant_message_id,
      chatId=chat_id,
      text="Here is your answer.",
  )
  ```



  - [Content](#content)
  - [Message](#message)
  - [Chat Completion](#chat-completion)
  - [Search](#search)
  - [Search String](#search-string)

  Most of the API services provide an asynchronous version of the method. The async methods are suffixed with `_async`.





  Allows you to load full content/files from the knowledge-base of unique with the rights of the userId and companyId. Provided a `where` query for filtering. Filtering can be done on any of the following fields: `

  - `id`
  - `key`
  - `ownerId`
  - `title`
  - `url`

  Here an example of retrieving all files that contain the number 42 in the `title` or the `key` typically this is used to search by filename.

  ```python
  unique_sdk.Content.search(
      user_id=userId,
      company_id=companyId,
      where={
          "OR": [
              {
                  "title": {
                      "contains": "42",
                  },
              },
              {
                  "key": {
                      "contains": "42",
                  },
              },
          ],
      },
      chatId=chatId,
  )
  ```



  Enables upload of a new Content into the Knowledge base of unique into a specific scope with `scopeId` or a specific `chatId`. One of the two must be set.

  Typical usage is the following. That creates a Content and uploads a file

  ```python

  createdContent = upload_file(
      userId,
      companyId,
      "/path/to/file.pdf",
      "test.pdf",
      "application/pdf",
      "scope_stcj2osgbl722m22jayidx0n",
  )

  def upload_file(
      userId,
      companyId,
      path_to_file,
      displayed_filename,
      mimeType,
      scope_or_unique_path,
  ):
      size = os.path.getsize(path_to_file)
      createdContent = unique_sdk.Content.upsert(
          user_id=userId,
          company_id=companyId,
          input={
              "key": displayed_filename,
              "title": displayed_filename,
              "mimeType": mimeType,
          },
          scopeId=scope_or_unique_path,
      )

      uploadUrl = createdContent.writeUrl

      
      with open(path_to_file, "rb") as file:
          requests.put(
              uploadUrl,
              data=file,
              headers={
                  "X-Ms-Blob-Content-Type": mimeType,
                  "X-Ms-Blob-Type": "BlockBlob",
              },
          )

      unique_sdk.Content.upsert(
          user_id=userId,
          company_id=companyId,
          input={
              "key": displayed_filename,
              "title": displayed_filename,
              "mimeType": mimeType,
              "byteSize": size,
          },
          scopeId=scope_or_unique_path,
          readUrl=createdContent.readUrl,
      )

      return createdContent

  ```





  Retrieve a list of messages for a provided `chatId`.

  ```python
  messages = unique_sdk.Message.list(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
  )
  ```



  Get a single chat message.

  ```python
  message = unique_sdk.Message.retrieve(
      user_id=user_id,
      company_id=company_id,
      id=message_id,
      chatId=chat_id,
  )
  ```



  Create a new message in a chat.

  ```python
  message = unique_sdk.Message.create(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
      assistantId=assistant_id,
      text="Hello.",
      role="ASSISTANT",
  )
  ```



  Modify an existing chat message.

  ℹ️ if you modify the debugInfo only do it on the user message as this is the only place that is displayed in the frontend.

  ```python
  message = unique_sdk.Message.modify(
      user_id=user_id,
      company_id=company_id,
      id=message_id,
      chatId=chat_id,
      text="Updated message text"
  )
  ```



  Delete a chat message.

  ```python
  message = unique_sdk.Message.delete(
      message_id,
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id,
  )
  ```



  Streams the answer to the chat frontend. Given the messages.

  if the stream creates [source0] it is referenced with the references from the search context.

  E.g.

  ```
  Hello this information is from [srouce1]
  ```

  adds the reference at index 1 and then changes the text to:

  ```
  Hello this information is from <sub>0</sub>
  ```

  ```python
  unique_sdk.Integrated.chat_stream_completion(
      user_id=userId,
      company_id=companyId,
      assistantMessageId=assistantMessageId,
      userMessageId=userMessageId,
      messages=[
          {
              "role": "system",
              "content": "be friendly and helpful"
          },
          {
              "role": "user",
              "content": "hello"
          }
      ],
      chatId=chatId,

      searchContext=  [
          {
              "id": "ref_qavsg0dcl5cbfwm1fvgogrvo",
              "chunkId": "0",
              "key": "some reference.pdf : 8,9,10,11",
              "sequenceNumber": 1,
              "url": "unique://content/cont_p8n339trfsf99oc9f36rn4wf"
          }
      ],  # optional
      debugInfo={
          "hello": "test"
      }, # optional
      startText= "I want to tell you about: ", # optional
      model= "AZURE_GPT_4_32K_0613", # optional
      timeout=8000,  # optional in ms
      options={
                  "temperature": 0.5
              } # optional
  )
  ```

  **Warning:** Currently, the deletion of a chat message does not automatically sync with the user UI. Users must refresh the chat page to view the updated state. This issue will be addressed in a future update of our API.





  Send a prompt to an AI model supported by Unique FinanceGPT and receive a result. The `messages` attribute must follow the [OpenAI API format](https://platform.openai.com/docs/api-reference/chat).

  ```python
  chat_completion = unique_sdk.ChatCompletion.create(
      company_id=company_id,
      model="AZURE_GPT_35_TURBO",
      messages=[
          {"role": "system", "content": "You are a helpful assistant."},
          {"role": "user", "content": "Hello!"},
      ],
      options={
              "temperature": 0.5
          } # optional
  )
  ```





  Sends an array of `text` to the AI model for embedding. And retrieve a vector of embeddings.

  ```python
  result = unique_sdk.Embeddings.create(
      user_id=user_id,
      company_id=company_id,
      texts=["hello", "hello"],
  )
  print(result.embeddings[0][0])
  ```





  Fetches the acronyms defined on the company. Often used to replace in user prompts, so the acronym is resolved to give better guidance to the LLM during completion.

  ```python
  result = unique_sdk.Acronyms.get(
      user_id=user_id,
      company_id=company_id,
  )
  print(result)
  ```





  Search the Unique FinanceGPT Knowledge database for RAG (Retrieval-Augmented Generation). The API supports vector search and a `searchType` that combines vector and full-text search, enhancing the precision of search results.

  These are the options are available for `searchType`:

  - `VECTOR`
  - `COMBINED`

  `limit` (max 1000) and `page` are optional for iterating over results.
  `chatOnly` Restricts the search exclusively to documents uploaded within the chat.
  `scopeIds` Specifies a collection of scope IDs to confine the search.
  `language` Optional. The language specification for full text search.
  `reranker` Optional. The reranker service to be used for re-ranking the search results.

  ```python
  search = unique_sdk.Search.create(
      user_id=user_id,
      company_id=company_id,
      chatId=chat_id
      searchString="What is the meaning of life, the universe and everything?",
      searchType="VECTOR",
      chatOnly=false,
      scopeIds=["scope_..."],
      language="German",
      reranker={"deploymentName": "my_deployment"},
      limit=20,
      page=1
  )
  ```





  User messages are sometimes suboptimal as input prompts for vector or full-text knowledge base searches. This is particularly true as a conversation progresses and a user question may lack crucial context for a successful search.

  This API transforms and translates (into English) the user's message into an ideal search string for use in the [Search.create](#unique_sdksearchcreate) API method.

  Adding a `chatId` or `messages` as arguments allows the message history to provide additional context to the search string. For example, "Who is the author?" will be expanded to "Who is the author of the book 'The Hitchhiker's Guide to the Galaxy'?" if previous messages referenced the book.

  ```python
  search_string = unique_sdk.SearchString.create(
      user_id=user_id,
      company_id=company_id,
      prompt="Was ist der Sinn des Lebens, des Universums und des ganzen Rests?",
      chat_id=chat_id
  )
  ```



  For saving data in between chats there is the Short Term Memory functionality to save small data in between rounds of chat e.g. language, search results and so on.
  For this 10k chars can be used. You can save a short term memory for a chat `chatId` or for a message `messageId`.
  you need to provide an `memoryName` as an identifier.

  you can then save it and retreive it live defined below.



  ```python
  c = unique_sdk.ShortTermMemory.create(
      user_id=user_id,
      company_id=company_id,
      data="hello",
      chatId="chat_x0xxtj89f7drjp4vmued3q",
      
      memoryName="your memory name",
  )
  print(c)
  ```



  ```python
  m = unique_sdk.ShortTermMemory.find_latest(
      user_id=user_id,
      company_id=company_id,
      chatId="chat_x0xxtj89f7drjp4vmued3q",
       
      memoryName="your memory name",
  )
  print(m)
  ```



  [UniqueQL](https://unique-ch.atlassian.net/wiki/x/coAXHQ) is an advanced query language designed to enhance search capabilities within various search modes such as Vector, Full-Text Search (FTS), and Combined. This query language enables users to perform detailed searches by filtering through metadata attributes like filenames, URLs, dates, and more. UniqueQL is versatile and can be translated into different query formats for various database systems, including PostgreSQL and Qdrant.



  A UniqueQL query is composed of a path, an operator, and a value. The path specifies the metadata attribute to be filtered, the operator defines the type of comparison, and the value provides the criteria for the filter.

  A metadata filter can be designed with UniqueQL's `UQLOperator` and `UQLCombinator` as follows:

  ```python
  metadata_filter = {
          "path": ['diet', '*'],
          "operator": UQLOperator.NESTED,
          "value": {
              UQLCombinator.OR : [
                  {
                      UQLCombinator.OR: [
                          {
                              "path": ['food'],
                              "operator": UQLOperator.EQUALS,
                              "value": "meat",
                          },
                          {
                              "path": ['food'],
                              "operator": UQLOperator.EQUALS,
                              "value": 'vegis',
                          },
                      ],
                  },
                  {
                      "path": ['likes'],
                      "operator": UQLOperator.EQUALS,
                      "value": true,
                  },
              ],
          },
      }
  ```



  A metadata filter such as the one designed above can be used in a `Search.create` call by passing it the `metaDataFilter` parameter.

  ```python
      search_results = unique_sdk.Search.create(
          user_id=user_id,
          company_id=company_id,
          chatId=chat_id,
          searchString=search_string,
          searchType="COMBINED",
          
          metaDataFilter=metadata_filter,
      )
  ```







  A helper function that makes sure the chat history is fully loaded and cut to the size of the token window that it fits into the next round of chat interactions.

  - `maxTokens` max tokens of the model used
  - `percentOfMaxTokens`=0.15 % max history in % of `maxTokens`
  - `maxMessages`=4, maximal number of messages included in the history.

  this method also directly returns a correct formatted history that can be used in the next chat round.

  ```python
  history = unique_sdk.utils.chat_history.load_history(
      userId,
      companyId,
      chatId
  )
  ```



  convert history into a string that can be injected into a prompt. it als returns the token length of the converted history.

  ```
  chat_history-string, chat_context_token_length = unique_sdk.utils.chat_history.convert_chat_history_to_injectable_string(
      history
  )
  ```



  Interacting with the knowledge-base.



  download files and save them into a folder in `/tmp`

  for example using the readUrl from a content.

  ```python
  pdfFile = download_content(
      companyId=companyId,
      userId=userId,
      content_id="cont_12412",
      filename="hello.pdf",
      chat_id=None # If specified, it downloads it from the chat
  }
  ```



  Allows for uploading files that then get ingested in a scope or a chat.

  ```python
  createdContent = upload_file(
      companyId=companyId,
      userId=userId,
      path_to_file="/tmp/hello.pdf",
      displayed_filename="hello.pdf",
      mimeType="application/pdf",
      uploadScope="scope_stcj2osgbl722m22jayidx0n",
      chat_id=None,
  )
  ```





  Merges multiple search results based on their 'id', removing redundant document and info markers.

  This function groups search results by their 'id' and then concatenates their texts,
  cleaning up any document or info markers in subsequent chunks beyond the first one.

  Parameters:

  - searchContext (list): A list of dictionaries, each representing a search result with 'id' and 'text' keys.

  Returns:

  - list: A list of dictionaries with merged texts for each unique 'id'.

  `searchContext` is an list of search objects that are returned by the search.

  ```python
  search = unique_sdk.Search.create(
      user_id=userId,
      company_id=companyId,
      chatId=chatId,
      searchString="Who is Harry P?",
      searchType="COMBINED",
      scopeIds="scope_dsf...",
      limit=30,
      chatOnly=False,
  )

  searchContext = unique_sdk.util.token.pick_search_results_for_token_window(
          search["data"], config["maxTokens"] - historyLength
      )

  searchContext = unique_sdk.util.sources.merge_sources(search)

  ```



  Sort sources by order of appearance in documents

  ```python

  search = unique_sdk.Search.create(
      user_id=userId,
      company_id=companyId,
      chatId=chatId,
      searchString="Who is Harry P?",
      searchType="COMBINED",
      scopeIds="scope_dsf...",
      limit=30,
      chatOnly=False,
  )

  searchContext = unique_sdk.util.token.pick_search_results_for_token_window(
          search["data"], config["maxTokens"] - historyLength
      )

  searchContext = unique_sdk.util.sources.sort_sources(search)
  ```



  Post-processes the provided text by converting source references into superscript numerals (required
  format by backend to display sources in the chat window)

  This function searches the input text for patterns that represent source references (e.g., [source1])
  and replaces them with superscript tags, incrementing the number by one.

  Parameters:

  - text (str): The text to be post-processed.

  Returns:

  - str: The text with source references replaced by superscript numerals.

  Examples:

  - postprocessSources("This is a reference [source0]") will return "This is a reference <sup>1</sup>".

  ```python

  text_with_sup = post_process_sources(text)
  ```





  Selects and returns a list of search results that fit within a specified token limit.

  This function iterates over a list of search results, each with a 'text' field, and
  encodes the text using a predefined encoding scheme. It accumulates search results
  until the token limit is reached or exceeded.

  Parameters:

  - searchResults (list): A list of dictionaries, each containing a 'text' key with string value.
  - tokenLimit (int): The maximum number of tokens to include in the output.

  Returns:

  - list: A list of dictionaries representing the search results that fit within the token limit.

  ```python
  search = unique_sdk.Search.create(
      user_id=userId,
      company_id=companyId,
      chatId=chatId,
      searchString="Who is Harry P?",
      searchType="COMBINED",
      scopeIds="scope_dsf...",
      limit=30,
      chatOnly=False,
  )

  searchContext = unique_sdk.util.token.pick_search_results_for_token_window(
          search["data"], config["maxTokens"] - historyLength
      )
  ```



  Counts the number of tokens in the provided text.

  This function encodes the input text using a predefined encoding scheme
  and returns the number of tokens in the encoded text.

  Parameters:

  - text (str): The text to count tokens for.

  Returns:

  - int: The number of tokens in the text.

  ```python
  hello = "hello you!"
  searchContext = unique_sdk.util.token.count_tokens(hello)
  ```





  An example Flask app demonstrating the usage of each API resource and how to interact with Webhooks is available in our repository at `/examples/custom-assistant`.



  This is a _fork_ / inspired-by the fantastic Stripe Python SDK (https://github.com/stripe/stripe-python).



  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).


  - Corrected return type of `Search.create` and `Search.create_async` to `List[Search]`
  - Retry on `Connection aborted` error


  - Add `Internal server error` and `You can retry your request` to the retry logic


  - Add `contentIds` to `Search.create` and `Search.create_async`


  - Add retry for `5xx` errors, add additional error message.


  - Include original error message in returned exceptions


  - Add  `ingestionConfig` to `UpsertParams.Input` parameters


  - Remove `temperature` parameter from `Integrated.chat_stream_completion`, `Integrated.chat_stream_completion_async`, `ChatCompletion.create` and `ChatCompletion.create_async` methods. To use `temperature` parameter, set the attribute in `options` parameter instead.


  - Revert deletion of `Message.retrieve` method


  - Add `retries` for `_static_request` and `_static_request_async` in `APIResource` - When the error messages contains either  `"problem proxying the request"`,
          or `"Upstream service reached a hard timeout"`,

  - Add `completedAt` to `CreateParams` of `Message`


  - Added `metaDataFilter` to `Search` parameters.


  - Add `completedAt` to `ModifyParams`


  - Add `close` and `close_async` to `http_client`
  - Make `httpx` the default client for async requests


  - `Search.create`, `Message`, `ChatCompletion` parameters that were marked `NotRequired` are now also `Optional`


  - Bug fix in `Search.create`: langugage -> language


  - Added parameters to `Search.create` and `Search.create_async`
      - `language` for full text search
      - `reranker` to reranker search results


  - Added the possibility to make async requests to the unique APIs using either aiohttp or httpx as client


pkgId: 64b3ff81f3404e5fd2d4e9780dd416c1577ad9ceb062ff67ab36bb9295108d0a
name: python-unique_toolkit-help
arch: noarch
version: 0.5.43
epoch: 0
release: 1
summary: Development documents and examples for unique_toolkit
url: https://pypi.org/project/unique_toolkit/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unique_toolkit-0.5.43-1.src.rpm
location_href: Packages/python-unique_toolkit-help-0.5.43-1.noarch.rpm
checksum_type: sha256
description:
  This package provides highlevel abstractions and methods on top of `unique_sdk` to ease application development for the Unique Platform.

  The Toolkit is structured along the following domains:
  - `unique_toolkit.chat`
  - `unique_toolkit.content`
  - `unique_toolkit.embedding`
  - `unique_toolkit.language_model`

  Each domain comprises a service class (in `service.py`) which encapsulates the basic functionalities to interact with the domain entities, the schemas
  (in `schemas.py`) used in the service and required for interacting with the service functions, utility functions (in `utils.py`) which give additional
  functionality to interact with the domain entities (all domains except embedding) and other domain specific functionalities which are explained in the respective domain documentation.

  In addition, the `unique_toolkit.app` module provides functions to initialize apps that interact with the Unique platform. It also includes some utility functions to run async tasks in parallel (async webserver and app implementation required).



  See the [CHANGELOG.md](https://github.com/Unique-AG/ai/blob/main/unique_toolkit/CHANGELOG.md) file for details on changes and version history.





  The `unique_toolkit.app` module encompasses functions for initializing and securing apps that will interact with the Unique platform.

  - `init_logging.py` can be used to initalize the logger either with unique dictConfig or an any other dictConfig.
  - `init_sdk.py` can be used to initialize the sdk using the correct env variables and retrieving the endpoint secret.
  - `schemas.py` contains the Event schema which can be used to parse and validate the unique.chat.external-module.chosen event.
  - `verification.py` can be used to verify the endpoint secret and construct the event.



  The `unique_toolkit.chat` module encompasses all chat related functionality.

  - `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
  - `schemas.py` comprises all relevant schemas, e.g., ChatMessage, used in the ChatService.
  - `utils.py` comprises utility functions to use and convert ChatMessage objects in assistants, e.g., convert_chat_history_to_injectable_string converts the chat history to a string that can be injected into a prompt.



  The `unique_toolkit.content` module encompasses all content related functionality. Content can be any type of textual data that is stored in the Knowledgebase on the Unique platform. During the ingestion of the content, the content is parsed, split in chunks, indexed, and stored in the database.

  - `service.py` comprises the ContentService and provides an interface to interact with the content, e.g., search content, search content chunks, upload and download content.
  - `schemas.py` comprises all relevant schemas, e.g., Content and ContentChunk, used in the ContentService.
  - `utils.py` comprise utility functions to manipulate Content and ContentChunk objects, e.g., sort_content_chunks and merge_content_chunks.



  The `unique_toolkit.embedding` module encompasses all embedding related functionality. Embeddings are used to represent textual data in a high-dimensional space. The embeddings can be used to calculate the similarity between two texts, for instance.

  - `service.py` encompasses the EmbeddingService and provides an interface to interact with the embeddings, e.g., embed text and calculate the similarity between two texts.
  - `schemas.py` comprises all relevant schemas, e.g., Embeddings, used in the EmbeddingService.



  The `unique_toolkit.language_model` module encompasses all language model related functionality and information on the different language models deployed through the
  Unique platform.

  - `infos.py` comprises the information on all language models deployed through the Unique platform. We recommend to use the LanguageModel class, initialized with the LanguageModelName, e.g., LanguageModel(LanguageModelName.AZURE_GPT_35_TURBO_16K) to get the information on the specific language model like the name, version, token limits or retirement date.
  - `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete or stream_complete.
  - `schemas.py` comprises all relevant schemas, e.g., LanguageModelResponse, used in the LanguageModelService.
  - `utils.py` comprises utility functions to parse the output of the language model, e.g., convert_string_to_json finds and parses the last json object in a string.



  1. Install poetry on your system (through `brew` or `pipx`).

  2. Install `pyenv` and install python 3.11. `pyenv` is recommended as otherwise poetry uses the python version used to install itself and not the user preferred python version.

  3. If you then run `python --version` in your terminal, you should be able to see python version as specified in `.python-version`.

  4. Then finally run `poetry install` to install the package and all dependencies.


  All notable changes to this project will be documented in this file.

  The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).




  - Add `Prompt` class to handle templated prompts that can be formatted into LanguageModelSystemMessage and LanguageModelUserMessage.


  - Update `LanguageModelTokenLimits` with fix avoiding floats for token


  - Update `LanguageModelTokenLimits` includes a fraction_input now to always have input/output token limits available.


  - Add `other_options` to `LanguageModelService.complete`, `LanguageModelService.complete_async`, `LanguageModelService.stream_complete` and `LanguageModelService.stream_complete_async`


  - Add `contentIds` to `Search.create` and `Search.create_async`
  - Use `metadata_filter` from event in `ContentService.search_content_chunks` and `ContentService.async_search_content_chunks` as default.


  - Added string representation to `LanguageModelMessage` and `LanguageModelMessages` class


  - `content` parameter in `ChatService.modify_assistant_message` and `ChatService.modify_assistant_message_async` is now optional
  - Added optional parameter `original_content` to `ChatService.modify_assistant_message` and `ChatService.modify_assistant_message_async`
  - Added optional parameter `original_content` to `ChatService.create_assistant_message` and `ChatService.create_assistant_message_async`


  - Add possibility to return the response from the download file from chat request
  - Add possibility to not specify a filename and use filename from response headers


  - Add the possibilty to upload files without triggering ingestion by setting `skip_ingestion` to `True` in `ContentService.upload_content`


  - Add `content_id_to_translate` to `EventAdditionalParameters`


  - Force randomizing tool_call_id. This is helpful to better identify the tool_calls.


  - Extending `LanguageModelName` with GPT-4o-2024-0806. This model is invoked using `AZURE_GPT_4o_2024_0806`.


  - Adding support for function calling. Assistant message for tool calls can be directly created with `LanguageModelFunctionCall.create_assistant_message_from_tool_calls`. Better separation of schemas for different types of `LanguageModelMessages`.


  - Correctly use `temperature` parameter in `LanguageModelService.complete` and `LanguageModelService.complete_async` methods


  - Allow numbers in `LanguageModelTool` name


  - Correctly use `temperature` parameter in `LanguageModelService.stream_complete` and `LanguageModelService.stream_complete_async` methods


  - Add encoder_name to to language model info
  - Verify tool name for `LanguageModelTool` to conform with frontent requirements.
  - Add `search_on_chat` to `ContentService`


  - Bump `unique_sdk` version


  - Add `evaluators` for hallucination and context relevancy evaluation


  - Add `originalText` to `_construct_message_modify_params` and `_construct_message_create_params`. This addition makes sure that the `originalText` on the database is populated with the `text`


  - Add `set_completed_at` as a boolen parameter to the following functions: `modify_user_message`, `modify_user_message_async`, `modify_assistant_message`, `modify_assistant_message_async`, `create_assistant_message` and `create_assistant_message`. This parameter allows the `completedAt` timestamp on the database to be updated when set to True.


  - Add `LanguageModelToolMessage` as additional `LanguageModelMessage`


  - Add `tool` as new role to `ChatMessage`, as well as `tool_calls` and `tool_call_id` as additional parameters


  - `LanguageModelService` now supports complete_util_async that can be called without instantiating the class, currently being used in the Hallucination service and evaluation API


  - `LanguageModelMessage` now supports content as a list of dictionary. Useful when adding image_url content along user message.


  - Adds option to use `metadata_filter` with search.
  - Adds `user_metadata`, `tool_parameters` and `metadata_filter` to `EventPayload`.
  - Adds `update_debug_info` and `modify_user_message` (and the corresponding `async` variants) to `ChatService`.


  - Add option to initiate `LanguageModel` with a string.
  - Add option to call `LanguageModelService` functions also with a string instead of `LanguageModelName` enum for parameter `model_name`.


  - Fix `ContentService.upload_content` function.


  - Possibility to specify root directory in `ContentService.download_content`


  - Add AZURE_GPT_4o_MINI_2024_0718 to language model infos


  - Added `items` to `LanguageModelToolParameterProperty` schema to add support for parameters with list types.
  - Added `returns` to `LanguageModelTool` schema to describe the return types of tool calls.


  - added `completedAt` datetime to `unique_sdk.Message.modify` and `unique_sdk.Message.modify_async`
  - added `original_text` and `language` to `EventUserMessage`


  - made all domain specific functions and classes directly importable from `unique_toolkit.[DOMAIN_NAME]`
  - renamed `RerankerConfig` to `ContentRerankerConfig`
  - renamed `get_cosine_similarity` to `calculate_cosine_similarity` and moved it to `unique_toolkit.embedding.utils`
  - moved `calculate_tokens` from `unique_toolkit.content.utils` to `unique_toolkit.embedding.utils`
  - disabled deprecation warning in `LanguageModel`
  - added `additional_parameters` to event
  - removed `ChatState` and use `Event` instead


  - fix content schema


  - added `created_at` and `updated_at` to content schema


  - `RerankerConfig` serialization alias added


  - Replace mocked async service calls with async calls in `unique_sdk`
  - Change async methods name from `async_*` to `*_async`
  - Remove `chat_only` and `scope_ids` attributes from `ChatState` class
  - Replace `AsyncExecutor` by simpler utility function `run_async_tasks_parallel`


  - Bug fix: `ContentService.search_content_chunks` and it's `async` equivalent now accept `None` as a valid parameter value for `scope_ids`.


  - Added parameters to `ContentService.search_content_chunks` and `ContentService.async_search_content_chunks`
    - `reranker_config` to optinally rerank the search results
    - `search_language` to specify a language for full-text-search


  - correct ChatMessage schema


  - downgrade numpy version to ^1.26.4 to be compatible with langchain libraries (require numpy<2.0)


  - correct event schema


  - correct documentation



  - Added `unique_toolkit.app` module with the following components:
    - `init_logging.py` for initializing the logger.
    - `init_sdk.py` for initializing the SDK with environment variables.
    - `schemas.py` containing the Event schema.
    - `verification.py` for verifying the endpoint secret and constructing the event.

  - Added `unique_toolkit.chat` module with the following components:
    - `state.py` containing the `ChatState` class.
    - `service.py` containing the `ChatService` class for managing chat interactions.
    - `schemas.py` containing relevant schemas such as `ChatMessage`.
    - `utils.py` with utility functions for chat interactions.

  - Added `unique_toolkit.content` module with the following components:
    - `service.py` containing the `ContentService` class for interacting with content.
    - `schemas.py` containing relevant schemas such as `Content` and `ContentChunk`.
    - `utils.py` with utility functions for manipulating content objects.

  - Added `unique_toolkit.embedding` module with the following components:
    - `service.py` containing the `EmbeddingService` class for working with embeddings.
    - `schemas.py` containing relevant schemas such as `Embeddings`.

  - Added `unique_toolkit.language_model` module with the following components:
    - `infos.py` containing information on language models deployed on the Unique platform.
    - `service.py` containing the `LanguageModelService` class for interacting with language models.
    - `schemas.py` containing relevant schemas such as `LanguageModelResponse`.
    - `utils.py` with utility functions for parsing language model output.


  - Initial release of `unique_toolkit`.


pkgId: 05e634ea4cfcc71fa7597c08f978bd46fa1cc5fe5a2f8cd32fef3887c9b5af8c
name: python-unitrad-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for unitrad
url: https://pypi.org/project/unitrad/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unitrad-0.1.0-1.src.rpm
location_href: Packages/python-unitrad-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  A WebSocket client for trading strategies.



  ```bash
  pip install unitrade

  USAGE

  from unitrade import run_unitrade

  results = run_unitrade('path_to_your_config.yaml')
  print(results)


pkgId: fa2289076d86f876dc1954db3b33b183d7e1ae3854994ed86c8d0d7d03b5f5d5
name: python-unittest-parallel-help
arch: noarch
version: 1.7.1
epoch: 0
release: 1
summary: Development documents and examples for unittest-parallel
url: https://github.com/craigahobbs/unittest-parallel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unittest-parallel-1.7.1-1.src.rpm
location_href: Packages/python-unittest-parallel-help-1.7.1-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Status](https://img.shields.io/pypi/status/unittest-parallel)](https://pypi.org/project/unittest-parallel/)
  [![PyPI](https://img.shields.io/pypi/v/unittest-parallel)](https://pypi.org/project/unittest-parallel/)
  [![GitHub](https://img.shields.io/github/license/craigahobbs/unittest-parallel)](https://github.com/craigahobbs/unittest-parallel/blob/main/LICENSE)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/unittest-parallel)](https://pypi.org/project/unittest-parallel/)

  unittest-parallel is a parallel unit test runner for Python with coverage support.




  To run unittest-parallel, specify the directory containing your unit tests with the `-s` argument
  and your package's top-level directory using the `-t` argument:

  ~~~
  unittest-parallel -t . -s tests
  ~~~

  By default, unittest-parallel runs unit test modules on all CPU cores available.

  To run your unit tests with coverage, add either the `--coverage` option (for line coverage) or the
  `--coverage-branch` for line and branch coverage.

  ~~~
  unittest-parallel -t . -s tests --coverage-branch
  ~~~




  By default, unittest-parallel runs test modules in parallel, which works with
  [test class and module fixtures](https://docs.python.org/3/library/unittest.html#class-and-module-fixtures).
  If you don't have any module fixtures, you can use the `--level=class` option to run test classes in
  parallel. If you don't have any module or class fixtures, you can use the `--level=test` option to
  run individual tests in parallel.




  unittest-parallel helps the most when you have many long-running unit tests, such as those that make
  web service calls or are compute-intensive. If you just have many fast-running unit tests,
  unittest-parallel may slow down unit test execution due to the cost of parallelization.

  For example, for one of my projects with thousands of long-running unit tests, running tests with
  unittest-parallel is **five times faster** than running tests using Python's built-in unit test
  runner.

  For another project, with hundreds of fast-running unit tests, running tests using unittest-parallel
  is **twice as slow** as running them using Python's built-in unit test runner.

  To determine if unittest-parallel will improve your unit test run times, you'll need to try it on
  your project.




  ~~~
  usage: unittest-parallel [-h] [-v] [-q] [-f] [-b] [-k TESTNAMEPATTERNS]
                           [-s START] [-p PATTERN] [-t TOP] [--runner RUNNER]
                           [--result RESULT] [-j COUNT]
                           [--level {module,class,test}]
                           [--disable-process-pooling] [--coverage]
                           [--coverage-branch] [--coverage-rcfile RCFILE]
                           [--coverage-include PAT] [--coverage-omit PAT]
                           [--coverage-source SRC] [--coverage-html DIR]
                           [--coverage-xml FILE] [--coverage-fail-under MIN]

  options:
    -h, --help            show this help message and exit
    -v, --verbose         Verbose output
    -q, --quiet           Quiet output
    -f, --failfast        Stop on first fail or error
    -b, --buffer          Buffer stdout and stderr during tests
    -k TESTNAMEPATTERNS   Only run tests which match the given substring
    -s, --start-directory START
                          Directory to start discovery ('.' default)
    -p, --pattern PATTERN
                          Pattern to match tests ('test*.py' default)
    -t, --top-level-directory TOP
                          Top level directory of project (defaults to start
                          directory)
    --runner RUNNER       Custom unittest runner class <module>.<class>
    --result RESULT       Custom unittest result class <module>.<class>

  parallelization options:
    -j, --jobs COUNT      The number of test processes (default is 0, all cores)
    --level {module,class,test}
                          Set the test parallelism level (default is 'module')
    --disable-process-pooling
                          Do not reuse processes used to run test suites

  coverage options:
    --coverage            Run tests with coverage
    --coverage-branch     Run tests with branch coverage
    --coverage-rcfile RCFILE
                          Specify coverage configuration file
    --coverage-include PAT
                          Include only files matching one of these patterns.
                          Accepts shell-style (quoted) wildcards.
    --coverage-omit PAT   Omit files matching one of these patterns. Accepts
                          shell-style (quoted) wildcards.
    --coverage-source SRC
                          A list of packages or directories of code to be
                          measured
    --coverage-html DIR   Generate coverage HTML report
    --coverage-xml FILE   Generate coverage XML report
    --coverage-fail-under MIN
                          Fail if coverage percentage under min
  ~~~




  This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).
  It was started using [python-template](https://github.com/craigahobbs/python-template#readme) as follows:

  ~~~
  template-specialize python-template/template/ unittest-parallel/ -k package unittest-parallel -k name 'Craig A. Hobbs' -k email 'craigahobbs@gmail.com' -k github 'craigahobbs' -k noapi 1
  ~~~


pkgId: c148ad3da39086ff3a4710feb0929dbcb9f429ee5a0495157c70d5a100969a7c
name: python-universal-test-runner-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for universal-test-runner
url: https://github.com/xavdid/universal-test-runner
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-universal-test-runner-0.7.0-1.src.rpm
location_href: Packages/python-universal-test-runner-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  platform darwin -- Python 3.11.0, pytest-7.3.1, pluggy-1.0.0
  rootdir: /Users/username/projects/test-runner
  collected 78 items
  tests/test_cli.py ...                                                        [  3%]
  tests/test_context.py .....................                                  [ 30%]
  tests/test_matchers.py ..................................................    [ 94%]


pkgId: a181f16c0b5ef52f60a10e4780e34bf486a5804ad9a0a84194e2090d32d6f5bc
name: python-universalasync-help
arch: noarch
version: 0.4.0.0
epoch: 0
release: 1
summary: Development documents and examples for universalasync
url: https://github.com/bitcart/universalasync
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-universalasync-0.4.0.0-1.src.rpm
location_href: Packages/python-universalasync-help-0.4.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/bitcart/universalasync.svg?style=svg)](https://circleci.com/gh/bitcart/universalasync)
  [![Codecov](https://img.shields.io/codecov/c/github/bitcart/universalasync?style=flat-square)](https://codecov.io/gh/bitcart/universalasync)
  [![PyPI version](https://img.shields.io/pypi/v/universalasync.svg?style=flat-square)](https://pypi.python.org/pypi/universalasync/)
  [![Read the Docs](https://img.shields.io/readthedocs/universalasync?style=flat-square)](https://universalasync.bitcart.ai)

  A library to help automate the creation of universal python libraries



  Have you ever been frustrated that you need to maintain both sync and async versions of your library, even thought their code differs by just async and await?
  You might have came up to rewriting your code before release or other unreliable solutions.

  This library helps you to focus only on the main async implementation of your library: sync one will be created automatically

  Via decorating all your public methods, the wrapped functions automatically detect different conditions and run the functions accordingly.

  If user uses your library in async context, minimal overhead is added, it just returns the coroutine right away.

  Otherwise the library calls the coroutine via various loop methods, like as if you did it manually.

  There should be no issues at all, the only limitation is that signals and async subprocesses are supported only when running in the main thread.

  Also note that when run from a different os thread, the library will create a new event loop there and run coroutines.

  This means that you might need to adapt your code a bit in case you use some resources bound to a certain event loop (like `aiohttp.ClientSession`).

  You can see an example of how this could be solved [here](https://github.com/bitcart/bitcart-sdk/blob/4a425f80f62a0c90f8c5fa19ccb7e578590dcead/bitcart/providers/jsonrpcrequests.py#L51-L58)

  For API reference see [the docs](https://universalasync.bitcart.ai)



  `pip install universalasync`



  ```python

  class Client:
      @async_to_sync_wraps
      async def help():
          ...

      @async_to_sync_wraps
      @property
      async def async_property():
          ...


  @wrap
  class Client:
      async def help(self):
          ...

      @property
      async def async_property():
          ...

  client = Client()

  def sync_call():
      client.help()
      client.async_property

  async def async_call():
      await client.help()
      await client.async_property


  sync_call()
  asyncio.run(async_call())
  threading.Thread(target=sync_call).start()
  threading.Thread(target=asyncio.run, args=(async_call(),)).start()
  ```



  Copyright (C) 2021 MrNaif2018

  Universal async-sync wrapper initially based on [this implementation](https://github.com/pyrogram/pyrogram/blob/master/pyrogram/sync.py)

  Licensed under the [MIT license](LICENSE)


pkgId: 6aff3af3f31051e668d70c4606df8581ed2823702406a03879c6e1088ebaff50
name: python-unstructured-expanded-help
arch: noarch
version: 0.16.11
epoch: 0
release: 1
summary: Development documents and examples for unstructured-expanded
url: https://github.com/isaackogan/unstructured_expanded
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unstructured-expanded-0.16.11-1.src.rpm
location_href: Packages/python-unstructured-expanded-help-0.16.11-1.noarch.rpm
checksum_type: sha256
description:
  The `unstructured_expanded` library is a wrapper around the `unstructured` open source library to add image-extraction capabilities to the API.

  Its only purpose is to provide a more complete API for the `unstructured` library, since the library maintainers of the open source project
  have chosen to lock image extraction for office documents behind a paywall.



  This library is meant to be used in conjunction with the `unstructured` library.

  Versions of this library are equivalent to the `unstructured` library version they are based on.

  ```shell

  pip install unstructured["all-docs"]


  pip install unstructured_expanded
  ```



  See the licensing information in the [LICENSE](LICENSE) file.



  If you use this library in your research, please include a citation:

  ```bibtex
  @misc{unstructured_expanded,
    title={Unstructured_expanded: A Python Library for Extracting Text and Images from Documents using the unstructured API.},
    author={Kogan, Isaac},
    year={2024},
    url={https://github.com/isaackogan/unstructured_expanded}
  }
  ```


pkgId: 5a292deabf09095dd78cb6a99681339e6539726f51e58b8ab5ae7b24f6abae73
name: python-untanglepyut-help
arch: noarch
version: 2.6.1
epoch: 0
release: 1
summary: Development documents and examples for untanglepyut
url: https://pypi.org/project/untanglepyut/
rpm_license: GNU AFFERO GENERAL PUBLIC LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-untanglepyut-2.6.1-1.src.rpm
location_href: Packages/python-untanglepyut-help-2.6.1-1.noarch.rpm
checksum_type: sha256
description:
  Use as follows:
  ```python
  from untanglepyut.Types import Document
  from untanglepyut.Types import DocumentTitle
  from untanglepyut.Types import UntangledOglClasses
  from untanglepyut.Types import UntangledOglLinks
  from untanglepyut.Types import UntangledOglNotes
  from untanglepyut.Types import UntangledOglTexts
  from untanglepyut.UnTangler import UnTangler
  fqFileName: str = 'MultiLinkDocument.xml'
  untangler: UnTangler = UnTangler()
  untangler.untangleFile(fqFileName=fqFileName)
  document: Document = untangler.documents[DocumentTitle('Diagram-1')]
  oglClasses: UntangledOglClasses = document.oglClasses
  oglLinks: UntangledOglLinks = document.oglLinks
  oglNotes: UntangledOglNotes = document.oglNotes
  oglTexts: UntangledOglTexts = document.oglTexts
  ```
  The following is the UML diagram for the Pyut Untangler
  ![UntanglePyut](https://github.com/hasii2011/untanglepyut/blob/master/docs/UntanglePyut.png)
  ___

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

  For all kind of problems, requests, enhancements, bug reports, etc.,
  please drop me an e-mail.


pkgId: b5679d50e8f1495dcd3d2838562f41042c68edcd40934ed2fa4679de2addfe40
name: python-unxt-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for unxt
url: https://github.com/GalacticDynamics/unxt
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-unxt-1.0.1-1.src.rpm
location_href: Packages/python-unxt-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Unxt is unitful quantities and calculations in [JAX][jax], built on
  [Equinox][equinox] and [Quax][quax].
  Unxt supports JAX's compelling features:
  - JIT compilation (`jit`)
  - vectorization (`vmap`, etc.)
  - auto-differentiation (`grad`, `jacobian`, `hessian`)
  - GPU/TPU/multi-host acceleration
  And best of all, `unxt` doesn't force you to use special unit-compatible
  re-exports of JAX libraries. You can use `unxt` with existing JAX code, and with
  [quax][quax]'s simple decorator, JAX will work with `unxt.Quantity`.

  [![PyPI version][pypi-version]][pypi-link]
  [![PyPI platforms][pypi-platforms]][pypi-link]
  ```bash
  pip install unxt
  ```
  <details>
    <summary>using <code>uv</code></summary>
  ```bash
  uv add unxt
  ```
  </details>
  <details>
    <summary>from source, using pip</summary>
  ```bash
  pip install git+https://https://github.com/GalacticDynamics/unxt.git
  ```
  </details>
  <details>
    <summary>building from source</summary>
  ```bash
  cd /path/to/parent
  git clone https://https://github.com/GalacticDynamics/unxt.git
  cd unxt
  pip install -e .  # editable mode
  ```
  </details>

  [![Read The Docs](https://img.shields.io/badge/read_docs-here-orange)](https://unxt.readthedocs.io/en/)

  ```python
  import unxt as u
  x = u.Quantity(jnp.arange(1, 5, dtype=float), "km")
  print(x)

  ```
  The constituent value and unit are accessible as attributes:
  ```python
  print(x.value)

  print(x.unit)

  ```
  `Quantity` objects obey the rules of unitful arithmetic.
  ```python

  print(x + x)


  print(2 * x)

  y = u.Quantity(jnp.arange(4, 8, dtype=float), "yr")
  print(x / y)


  print(x**2)


  try:
      x + y
  except Exception as e:
      print(e)

  ```
  Quantities can be converted to different units:
  ```python
  print(u.uconvert("m", x))  # via function

  print(x.uconvert("m"))  # via method

  ```
  Since `Quantity` is parametric, it can do runtime dimension checking!
  ```python
  LengthQuantity = u.Quantity["length"]
  print(LengthQuantity(2, "km"))

  try:
      LengthQuantity(2, "s")
  except ValueError as e:
      print(e)

  ```
  `unxt` is built on [`quax`][quax], which enables custom array-ish objects in
  JAX. For convenience we use the [`quaxed`][quaxed] library, which is just a
  `quax.quaxify` wrapper around `jax` to avoid boilerplate code.
  > [!NOTE]
  >
  > Using [`quaxed`][quaxed] is optional. You can directly use `quaxify`, and even
  > apply it to the top-level function instead of individual functions.
  ```python
  from quaxed import grad, vmap
  import quaxed.numpy as jnp
  print(jnp.square(x))

  print(qnp.power(x, 3))

  print(vmap(grad(lambda x: x**3))(x))

  ```
  See the [documentation][rtd-link] for more examples and details of JIT and AD

  [![DOI][zenodo-badge]][zenodo-link]
  If you found this library to be useful and want to support the development and
  maintenance of lower-level code libraries for the scientific community, please
  consider citing this work.

  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status][rtd-badge]][rtd-link]
  [![codecov][codecov-badge]][codecov-link]
  [![SPEC 0 — Minimum Supported Dependencies][spec0-badge]][spec0-link]
  [![pre-commit][pre-commit-badge]][pre-commit-link]
  [![ruff][ruff-badge]][ruff-link]
  We welcome contributions!
  <!-- prettier-ignore-start -->
  [equinox]: https://docs.kidger.site/equinox/
  [jax]: https://jax.readthedocs.io/en/latest/
  [quax]: https://github.com/patrick-kidger/quax
  [quaxed]: https://github.com/GalacticDynamics/quaxed
  [actions-badge]:            https://github.com/GalacticDynamics/unxt/actions/workflows/ci.yml/badge.svg?branch=main
  [actions-link]:             https://github.com/GalacticDynamics/unxt/actions
  [codecov-badge]:            https://codecov.io/gh/GalacticDynamics/unxt/graph/badge.svg
  [codecov-link]:             https://codecov.io/gh/GalacticDynamics/unxt
  [pre-commit-badge]:         https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit
  [pre-commit-link]:          https://pre-commit.com
  [pypi-link]:                https://pypi.org/project/unxt/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/unxt
  [pypi-version]:             https://img.shields.io/pypi/v/unxt
  [rtd-badge]:                https://readthedocs.org/projects/unxt/badge/?version=latest
  [rtd-link]:                 https://unxt.readthedocs.io/en/
  [ruff-badge]:               https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
  [ruff-link]:                https://docs.astral.sh/ruff/
  [spec0-badge]:              https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038
  [spec0-link]:               https://scientific-python.org/specs/spec-0000/
  [zenodo-badge]:             https://zenodo.org/badge/734877295.svg
  [zenodo-link]:              https://zenodo.org/doi/10.5281/zenodo.10850455
  <!-- prettier-ignore-end -->

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Nathaniel Starkman. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  * Neither the name of the vector package developers nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 47b3e62ec4e40ddb20795d2bb0d8f5b1a0ee5969af8ade710ff0db0b30f24d8d
name: python-upbge-stubs-help
arch: noarch
version: 0.3.0.27
epoch: 0
release: 1
summary: Development documents and examples for upbge-stubs
url: https://github.com/mysticfall/bpystubgen
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-upbge-stubs-0.3.0.27-1.src.rpm
location_href: Packages/python-upbge-stubs-help-0.3.0.27-1.noarch.rpm
checksum_type: sha256
description:
  This module provides type information for [Blender](https://www.blender.org) and
  [UPBGE](https://upbge.org)'s Python API, following the
  [PEP-561](https://www.python.org/dev/peps/pep-0561/) standard.
  It was generated using [BPY Stub Generator](https://github.com/mysticfall/bpystubgen) which
  is also available on [PyPI](https://pypi.org/project/bpystubgen) as a separate module.

  Auto-completion at work in PyCharm:
  ![Screenshot in PyCharm](https://github.com/mysticfall/bpystubgen/raw/main/images/screenshot-pycharm.png?raw=true "Screenshot in PyCharm")
  Pop-up documentation support in VSCode:
  ![Screenshot in VSCode](https://github.com/mysticfall/bpystubgen/raw/main/images/screenshot-vscode.png?raw=true "Screenshot in VSCode")

  There are two variants of the API stubs, one for Blender and the other for UPBGE. For Blender,
  you can install `blender-stubs` module with appropriate version qualifier as follows:
  ```bash
  $ pip install blender-stubs==3.1.26
  ```
  This will install the latest module for Blender 2.93, and for now stubs are provided for Blender
  2.80 and onwards. You can also specify the next unreleased version as `3.1.*` to get the latest
  snapshot of the module:
  ```bash
  $ pip install blender-stubs==3.2.*
  ```
  A stub module for UPBGE 0.3, as well as pre-release versions for the master branch are also
  available on PyPI repository. For the stable version, you can install it as follows:
  ```bash
  $ pip install upbge-stubs==0.3.0.26
  ```
  And for the latest snapshot,
  ```bash
  $ pip install upbge-stubs==0.3.1.*
  ```
  You can also install the module using `Pipenv`. Note that it is required to set `allow_preleases` option
  in case you want to install a snapshot release (e.g. UPBGE 0.3.1.*).
  You can use the following content as a template for your `Pipfile`:
  ```toml
  [[source]]
  name = "pypi"
  url = "https://pypi.org/simple"
  verify_ssl = true
  [packages]
  "upbge-stubs" = "==0.3.1.*"
  [requires]
  python_version = "3.10"
  [pipenv]
  allow_prereleases = true
  ```
  You may want to use `[dev-packages]` instead of `[packages]` as it's more appropriate to do so,
  in which case you can install or update the stubs using the `-d` flag like `pipenv update -d`.

  This project is provided under the terms of
  [GNU General Public License v3 (GPL3)](https://github.com/mysticfall/bpystubgen/blob/main/LICENSE).


pkgId: a55be90d1511bb2c0aba0b1458664183ad39118b13d1c8cebe20757bd0179003
name: python-uphy-controller-help
arch: noarch
version: 0.1.0.dev2794
epoch: 0
release: 1
summary: Development documents and examples for uphy-controller
url: https://pypi.org/project/uphy-controller/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uphy-controller-0.1.0.dev2794-1.src.rpm
location_href: Packages/python-uphy-controller-help-0.1.0.dev2794-1.noarch.rpm
checksum_type: sha256
description:
  This contain a python based U-Phy device controller that act as a fieldbus master/controller.

  Supported fieldbuses:

  - modbus-tcp



  ```sh
  uv pip install uphy-controller
  ```



  ```sh

  uphy-controller modbus-tcp --model [PATH_TO_MODEL] --target [UUID]:[HOST]:[PORT]
  ```

rpm_license:
  Copyright rt-labs AB, Sweden. All rights reserved.  You may not use this software in a commercial product without purchasing a license. Contact sales@rt-labs.com for more information.


pkgId: 013c810a509430245c2ccc87af9145177b779a73fd467f8b1fc588bf646ea146
name: python-uphy-upgen-help
arch: noarch
version: 1.0.0.dev2794
epoch: 0
release: 1
summary: Development documents and examples for uphy-upgen
url: https://pypi.org/project/uphy-upgen/
rpm_license: Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uphy-upgen-1.0.0.dev2794-1.src.rpm
location_href: Packages/python-uphy-upgen-help-1.0.0.dev2794-1.noarch.rpm
checksum_type: sha256
description:
  U-Phy device generator.



  Python Poetry is recommended. See
  https://python-poetry.org/docs/#installation for installation
  instructions.

      $ cd /path/to/upgen
      $ poetry install
      $ poetry shell



  Install dependencies on Ubuntu::

      apt install patchelf python3-dev build-essential

  The Nuitka compiler can be used to build a distributable binary. Note
  that it should be possible to run the binary on the currently used and
  all later Linux GLIBC versions, but not versions earlier than the one
  in the build platform.

      $ poetry run nuitka \
          --include-package-data=upgen \
          --onefile \
          upgen/cli.py
      $ mkdir -p bin
      $ mv cli.bin bin/upgen


pkgId: e92e2b8fae5f8356038c7390d4836ad892eb031f96d74c089996c8e448f39ae8
name: python-upinfopy-help
arch: noarch
version: 0.1.30
epoch: 0
release: 1
summary: Development documents and examples for upinfopy
url: https://github.com/www778878net/UpinfoPy
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-upinfopy-0.1.30-1.src.rpm
location_href: Packages/python-upinfopy-help-0.1.30-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">upinfopy</h1>
  <div align="center">

  English | [简体中文](./README.cn.md)

  **upinfopy** is a Python implementation of UpInfo78.

  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![QQ Group](https://img.shields.io/badge/QQ%20Group-323397913-blue.svg?style=flat-square&color=12b7f5&logo=qq)](https://qm.qq.com/cgi-bin/qm/qr?k=it9gUUVdBEDWiTOH21NsoRHAbE9IAzAO&jump_from=webapi&authKey=KQwSXEPwpAlzAFvanFURm0Foec9G9Dak0DmThWCexhqUFbWzlGjAFC7t0jrjdKdL)

  </div>





  1. Eighteen years of ERP development experience, ten years of cloud development experience, fifteen years of stock and futures investment experience, and ten years of investment analysis platform development experience.
  2. Not highly technical but understands business and excels at solving practical problems in production and operations.
  3. Gradually open-sourcing projects that have been optimized over many years and are continuously running stably.



  1. Provides the same functionality as the TypeScript version, easily usable in Python projects.
  2. Stable: Optimized through years of operation.
  3. Fast development: A few lines of code can handle common operations.
  4. Efficient: Designed for high-performance information processing.
  5. Easy to extend: Modular design for easy addition of new features.
  6. Cross-platform: Runs on various operating systems.
  7. Easy debugging: Configurable logging and error tracking.
  8. Easy to learn: Simple API design, easy to get started with.
  9. Easy maintenance: Includes comprehensive error handling and reporting mechanisms.
  10. Continuous updates: Constantly optimized and updated based on real project needs.
  11. SAAS-ready: Supports multi-tenancy and data isolation.



  **Suitable for `Python 3.x` projects**



  ```
  pip install upinfopy
  ```



  See the API documentation for details.



  See the API documentation for details.



  ```python
  from upinfopy import UpinfoPy


  up = UpinfoPy()


  result = up.some_method()
  print(result)
  ```

  For more examples, see the documentation link.



  You can check the test/ directory for more usage examples.


pkgId: 8ff45dd842517863352e7cafb97317a180cfbdb3ae7d00659f1b2112f640a49c
name: python-uproot-browser-help
arch: noarch
version: 0.7.2
epoch: 0
release: 1
summary: Development documents and examples for uproot-browser
url: https://pypi.org/project/uproot-browser/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uproot-browser-0.7.2-1.src.rpm
location_href: Packages/python-uproot-browser-help-0.7.2-1.noarch.rpm
checksum_type: sha256
description:
  <img alt="uproot-browser" width="100%" src="https://raw.githubusercontent.com/scikit-hep/uproot-browser/main/docs/_images/uproot-browser-logo.png"/>



  [![Actions Status][actions-badge]][actions-link]
  [![PyPI version][pypi-version]][pypi-link]
  [![PyPI platforms][pypi-platforms]][pypi-link]
  [![GitHub Discussion][github-discussions-badge]][github-discussions-link]
  [![Gitter][gitter-badge]][gitter-link]
  [![License][license-badge]][license-link]
  [![Scikit-HEP][sk-badge]](https://scikit-hep.org/)
  [![Conda-Forge][conda-badge]][conda-link]

  uproot-browser is a [plotext](https://github.com/piccolomo/plotext) based command line library in which the command line interface is provided by [Click](https://github.com/pallets/click). It is powered by [Hist](https://github.com/scikit-hep/hist) and it's TUI is put together by [Textual](https://github.com/Textualize/textual). Its aim is to enable a user to browse and look inside a ROOT file, completely via the terminal. It takes its inspiration from the [ROOT object browser](https://root.cern/doc/master/classTRootBrowser.html).



  You can install this library from [PyPI](https://pypi.org/project/uproot-browser/) with `pip`:

  ```bash
  python3 -m pip install uproot-browser
  ```

  You can also use `pipx` to run the library without installing it:

  ```bash
  pipx run uproot-browser
  ```



  uproot-browser currently provides the following features (get help with `-h` or `--help`, view the current version with `--version`):

  - `browse` can be used to display a TUI (text user interface), acts as default if no subcommand specified.
  - `plot` can be used to display a plot.
  - `tree` can be used to display a tree.




  This example uses data from the [scikit-hep-testdata](https://github.com/scikit-hep/scikit-hep-testdata) package. It is placed in the same directory as the uproot-browser repository.

  **`browse` command:**

  ```bash
  uproot-browser browse ../scikit-hep-testdata/src/skhep_testdata/data/uproot-Event.root
  ```

  ![GIF of the TUI functionality](https://github.com/scikit-hep/uproot-browser/releases/download/v0.5.0/tui.gif)

  **`plot` command:**

  ```bash
  uproot-browser plot ../scikit-hep-testdata/src/skhep_testdata/data/uproot-Event.root:hstat
                          hstat -- Entries: 1000
      ┌───────────────────────────────────────────────────────────────┐
  18.0┤▐▌                                                             │
      │▐▌                                                 ▗▖         ▄│
  15.6┤▐▌▗▖                                               ▐▌         █│
      │███▌               █                           █   ▐▌        ▐█│
  13.1┤████▟▌    ▗▖  ▗▖   █▌▗▖ ▐▌       ▄   █▌   ▄  ▟▌█ ▗▄▐▙▗▖    ▐▌▐█│
  10.6┤█████▌    ▐▌  ▐▙▖  █▌▐▌ ▐▙       █▄  █▙   █  █▌█ ▐█▟█▐▌  ▗▄▟▌▐█│
      │█████▌ █▌▐█▌  ████▌█▌▐█ ▐█▐▌ ▐▌  ███▐██  ▐█ ▐████▐███▐▌ ▐███▌▐█│
   8.2┤█████▌▐█▌▐█▌ █████▌██▐█ ██▐█ ▐▌▐████▐███▌▐█ █████▐███▐██▐████▐█│
      │████████▙██▌█████████▟█▖████▖▟██████▟██████▖████████████▟██████│
   5.8┤███████████▙███████████▙████▌██████████████▌███████████████████│
      │████████████████████████████▌██████████████████████████████████│
   3.3┤███████████████████████████████████████████████████████████████│
      └┬───────────────┬──────────────┬───────────────┬──────────────┬┘
       0.00          0.25           0.50            0.75          1.00
                                 [x] xaxis
  ```

  <details>
  <summary>If you're on macOS and using iTerm2, click here:</summary><br>

  You can get an iterm plot, the required dependencies can be installed via:

  ```bash
  python3 -m pip install uproot-browser[iterm]
  ```

  Or can be run via `pipx` without installing:

  ```bash
  pipx run uproot-browser[iterm]
  ```

  Adding the argument `--iterm` gives us the plot:

  ```bash
  uproot-browser plot ../scikit-hep-testdata/src/skhep_testdata/data/uproot-Event.root:hstat --iterm
  ```

  <img alt="iterm example" width="600px" src="https://raw.githubusercontent.com/scikit-hep/uproot-browser/main/docs/_images/iterm.png"/>

  </details><br>

  **`tree` command:**

  ```bash
  uproot-browser tree ../scikit-hep-testdata/src/skhep_testdata/data/uproot-Event.root
  📁 uproot-Event.root
  ┣━━ ❓ <unnamed> TProcessID
  ┣━━ 🌴 T (1000)
  ┃   ┗━━ 🌿 event Event
  ┃       ┣━━ 🌿 TObject (group of fUniqueID:uint32_t, fBits:uint32_t)
  ┃       ┃   ┣━━ 🍁 fBits uint32_t
  ┃       ┃   ┗━━ 🍁 fUniqueID uint32_t
  ┃       ┣━━ 🍁 fClosestDistance unknown[]
  ┃       ┣━━ 🍁 fEventName char*
  ┃       ┣━━ 🌿 fEvtHdr EventHeader
  ┃       ┃   ┣━━ 🍁 fEvtHdr.fDate int32_t
  ┃       ┃   ┣━━ 🍁 fEvtHdr.fEvtNum int32_t
  ┃       ┃   ┗━━ 🍁 fEvtHdr.fRun int32_t
  ┃       ┣━━ 🍁 fFlag uint32_t
  ┃       ┣━━ 🍁 fH TH1F
  ┃       ┣━━ 🍁 fHighPt TRefArray*
  ┃       ┣━━ 🍁 fIsValid bool
  ┃       ┣━━ 🍁 fLastTrack TRef
  ┃       ┣━━ 🍁 fMatrix[4][4] float[4][4]
  ┃       ┣━━ 🍁 fMeasures[10] int32_t[10]
  ┃       ┣━━ 🍁 fMuons TRefArray*
  ┃       ┣━━ 🍁 fNseg int32_t
  ┃       ┣━━ 🍁 fNtrack int32_t
  ┃       ┣━━ 🍁 fNvertex uint32_t
  ┃       ┣━━ 🍁 fTemperature float
  ┃       ┣━━ 🌿 fTracks TClonesArray*
  ┃       ┃   ┣━━ 🍃 fTracks.fBits uint32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fBx Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fBy Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fCharge Double32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fMass2 Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fMeanCharge float[]
  ┃       ┃   ┣━━ 🍃 fTracks.fNpoint int32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fNsp uint32_t[]
  ┃       ┃   ┣━━ 🍁 fTracks.fPointValue unknown[][]
  ┃       ┃   ┣━━ 🍃 fTracks.fPx float[]
  ┃       ┃   ┣━━ 🍃 fTracks.fPy float[]
  ┃       ┃   ┣━━ 🍃 fTracks.fPz float[]
  ┃       ┃   ┣━━ 🍃 fTracks.fRandom float[]
  ┃       ┃   ┣━━ 🍃 fTracks.fTArray[3] float[][3]
  ┃       ┃   ┣━━ 🍁 fTracks.fTriggerBits.fAllBits uint8_t[][]
  ┃       ┃   ┣━━ 🍃 fTracks.fTriggerBits.fBits uint32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fTriggerBits.fNbits uint32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fTriggerBits.fNbytes uint32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fTriggerBits.fUniqueID uint32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fUniqueID uint32_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fValid int16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fVertex[3] Double32_t[][3]
  ┃       ┃   ┣━━ 🍃 fTracks.fXfirst Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fXlast Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fYfirst Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fYlast Float16_t[]
  ┃       ┃   ┣━━ 🍃 fTracks.fZfirst Float16_t[]
  ┃       ┃   ┗━━ 🍃 fTracks.fZlast Float16_t[]
  ┃       ┣━━ 🌿 fTriggerBits TBits
  ┃       ┃   ┣━━ 🌿 fTriggerBits.TObject (group of fTriggerBits.fUniqueID:uint32_t, fTriggerBits.fBits:uint32_t)
  ┃       ┃   ┃   ┣━━ 🍁 fTriggerBits.fBits uint32_t
  ┃       ┃   ┃   ┗━━ 🍁 fTriggerBits.fUniqueID uint32_t
  ┃       ┃   ┣━━ 🍃 fTriggerBits.fAllBits uint8_t[]
  ┃       ┃   ┣━━ 🍁 fTriggerBits.fNbits uint32_t
  ┃       ┃   ┗━━ 🍁 fTriggerBits.fNbytes uint32_t
  ┃       ┣━━ 🍁 fType[20] int8_t[20]
  ┃       ┗━━ 🍁 fWebHistogram TRef
  ┣━━ 📊 hstat TH1F (100)
  ┗━━ 📊 htime TH1F (10)
  ```



  [![pre-commit.ci status][pre-commit-badge]][pre-commit-link]

  See [CONTRIBUTING.md](https://github.com/scikit-hep/uproot-browser/blob/main/.github/CONTRIBUTING.md) for details on how to set up a development environment.

  [actions-badge]:            https://github.com/scikit-hep/uproot-browser/workflows/CI/badge.svg
  [actions-link]:             https://github.com/scikit-hep/uproot-browser/actions
  [conda-badge]:              https://img.shields.io/conda/vn/conda-forge/uproot-browser
  [conda-link]:               https://github.com/conda-forge/uproot-browser-feedstock
  [github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
  [github-discussions-link]:  https://github.com/scikit-hep/uproot-browser/discussions
  [gitter-badge]:             https://badges.gitter.im/Scikit-HEP/community.svg
  [gitter-link]:              https://gitter.im/Scikit-HEP/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
  [license-badge]:            https://img.shields.io/badge/License-BSD_3--Clause-blue.svg
  [license-link]:             https://opensource.org/licenses/BSD-3-Clause
  [pypi-link]:                https://pypi.org/project/uproot-browser/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/uproot-browser
  [pypi-version]:             https://badge.fury.io/py/uproot-browser.svg
  [sk-badge]:                 https://scikit-hep.org/assets/images/Scikit--HEP-Project-blue.svg
  [pre-commit-badge]:         https://results.pre-commit.ci/badge/github/scikit-hep/uproot-browser/main.svg
  [pre-commit-link]:          https://results.pre-commit.ci/repo/github/scikit-hep/uproot-browser

rpm_license:
  BSD 3-Clause License  Copyright (c) 2021, Henry Schreiner All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 45d7544f7216b98acd5b9e17a366cd9cbfd4f83e8fa4b5c87ce1bcd3d335dcec
name: python-uproot-help
arch: noarch
version: 5.5.1
epoch: 0
release: 1
summary: Development documents and examples for uproot
url: https://github.com/scikit-hep/uproot5
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uproot-5.5.1-1.src.rpm
location_href: Packages/python-uproot-help-5.5.1-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/scikit-hep/uproot5/main/docs-img/logo/logo.svg" width="300px">

  [![PyPI version](https://badge.fury.io/py/uproot.svg)](https://pypi.org/project/uproot)
  [![Conda-Forge](https://img.shields.io/conda/vn/conda-forge/uproot)](https://github.com/conda-forge/uproot-feedstock)
  [![Python 3.9‒3.13](https://img.shields.io/badge/python-3.9%E2%80%923.13-blue)](https://www.python.org)
  [![BSD-3 Clause License](https://img.shields.io/badge/license-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Continuous integration tests](https://github.com/scikit-hep/uproot5/actions/workflows/build-test.yml/badge.svg)](https://github.com/scikit-hep/uproot5/actions)

  [![Scikit-HEP](https://scikit-hep.org/assets/images/Scikit--HEP-Project-blue.svg)](https://scikit-hep.org/)
  [![NSF-1836650](https://img.shields.io/badge/NSF-1836650-blue.svg)](https://nsf.gov/awardsearch/showAward?AWD_ID=1836650)
  [![DOI 10.5281/zenodo.4340632](https://zenodo.org/badge/DOI/10.5281/zenodo.4340632.svg)](https://doi.org/10.5281/zenodo.4340632)
  [![Documentation](https://img.shields.io/badge/docs-online-success)](https://uproot.readthedocs.io/)
  [![Gitter](https://img.shields.io/badge/chat-online-success)](https://gitter.im/Scikit-HEP/uproot)

  Uproot is a library for reading and writing [ROOT files](https://root.cern/) in pure Python and NumPy.

  Unlike the standard C++ ROOT implementation, Uproot is only an I/O library, primarily intended to stream data into machine learning libraries in Python. Unlike PyROOT and root_numpy, Uproot does not depend on C++ ROOT. Instead, it uses Numpy to cast blocks of data from the ROOT file as Numpy arrays.

  <p align="center"><img src="https://raw.githubusercontent.com/scikit-hep/uproot5/main/docs-img/diagrams/abstraction-layers.svg" width="700px"></p>



  Uproot can be installed [from PyPI](https://pypi.org/project/uproot) using pip.

  ```bash
  pip install uproot
  ```

  Uproot is also available using [conda](https://anaconda.org/conda-forge/uproot).

  ```bash
  conda install -c conda-forge uproot
  ```

  If you have already added `conda-forge` as a channel, the `-c conda-forge` is unnecessary. Adding the channel is recommended because it ensures that all of your packages use compatible versions (see [conda-forge docs](https://conda-forge.org/docs/user/introduction.html#how-can-i-install-packages-from-conda-forge)):

  ```bash
  conda config --add channels conda-forge
  conda update --all
  ```



  **Start with the [tutorials and reference documentation](https://uproot.readthedocs.io/).**

     * Report bugs, request features, and ask for additional documentation on [GitHub Issues](https://github.com/scikit-hep/uproot5/issues).
     * If you have a "How do I...?" question, start a [GitHub Discussion](https://github.com/scikit-hep/uproot5/discussions) with category "Q&A".
     * Alternatively, ask about it on [StackOverflow with the [uproot] tag](https://stackoverflow.com/questions/tagged/uproot). Be sure to include tags for any other libraries that you use, such as Pandas or PyTorch.
     * To ask questions in real time, try the Gitter [Scikit-HEP/uproot](https://gitter.im/Scikit-HEP/uproot) chat room.



  Uproot is an ordinary Python library; you can get a copy of the code with

  ```bash
  git clone https://github.com/scikit-hep/uproot5.git
  ```

  and install it locally by calling `pip install -e .` in the repository directory.

  If you need to develop Awkward Array as well, see its [installation for developers](https://github.com/scikit-hep/awkward-1.0#installation-for-developers).



  **Uproot's only strict dependencies are NumPy and packaging.** Strict dependencies are automatically installed by pip (or conda).

  **[Awkward Array](https://anaconda.org/conda-forge/awkward) is highly recommended** and is automatically installed by pip (or conda), though it is _possible_ to use Uproot without it. If you need a minimal installation, pass `--no-deps` to pip and pass `library="np"` to every array-fetching function, or globally set `uproot.default_library` to get NumPy arrays instead of Awkward Arrays.

     * `awkward`: Uproot 5.x requires Awkward 2.x.

  The following libraries are also useful in conjunction with Uproot, but are not necessary. If you call a function that needs one, you'll be prompted to install it. (Conda installs most of these automatically.)

  **For ROOT files, compressed different ways:**

     * `lz4` and `xxhash`: if reading ROOT files that have been LZ4-compressed.
     * `zstandard`: if reading ROOT files that have been ZSTD-compressed.
     * ZLIB and LZMA are built in (Python standard library).

  **For accessing remote files:**

     * `minio`: if reading files with `s3://` URIs.
     * `xrootd`: if reading files with `root://` URIs.
     * HTTP/S access is built in (Python standard library).

  **For distributed computing with [Dask](https://www.dask.org/):**

     * `dask`: see [uproot.dask](https://uproot.readthedocs.io/en/latest/uproot._dask.dask.html).
     * `dask-awkward`: for data with irregular structure ("jagged" arrays), see [dask-awkward](https://github.com/dask-contrib/dask-awkward).

  **For exporting TTrees to [Pandas](https://pandas.pydata.org/):**

     * `pandas`: if `library="pd"`.
     * `awkward-pandas`: if `library="pd"` and the data have irregular structure ("jagged" arrays), see [awkward-pandas](https://github.com/intake/awkward-pandas).

  **For exporting histograms:**

     * `boost-histogram`: if converting histograms to [boost-histogram](https://github.com/scikit-hep/boost-histogram) with `histogram.to_boost()`.
     * `hist`: if converting histograms to [hist](https://github.com/scikit-hep/hist) with `histogram.to_hist()`.



  Support for this work was provided by NSF cooperative agreements [OAC-1836650](https://www.nsf.gov/awardsearch/showAward?AWD_ID=1836650) and [PHY-2323298](https://www.nsf.gov/awardsearch/showAward?AWD_ID=2323298) (IRIS-HEP), grant [OAC-1450377](https://nsf.gov/awardsearch/showAward?AWD_ID=1450377) (DIANA/HEP), and [PHY-2121686](https://www.nsf.gov/awardsearch/showAward?AWD_ID=2121686) (US-CMS LHC Ops).


  Thanks especially to the gracious help of Uproot contributors (including the [original repository](https://github.com/scikit-hep/uproot)).

  <!-- 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/jpivarski"><img src="https://avatars0.githubusercontent.com/u/1852447?v=4?s=100" width="100px;" alt="Jim Pivarski"/><br /><sub><b>Jim Pivarski</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=jpivarski" title="Code">💻</a> <a href="https://github.com/scikit-hep/uproot5/commits?author=jpivarski" title="Documentation">📖</a> <a href="#infra-jpivarski" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="#maintenance-jpivarski" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/reikdas"><img src="https://avatars0.githubusercontent.com/u/11775615?v=4?s=100" width="100px;" alt="Pratyush Das"/><br /><sub><b>Pratyush Das</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=reikdas" title="Code">💻</a> <a href="#infra-reikdas" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/chrisburr"><img src="https://avatars3.githubusercontent.com/u/5220533?v=4?s=100" width="100px;" alt="Chris Burr"/><br /><sub><b>Chris Burr</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=chrisburr" title="Code">💻</a> <a href="#infra-chrisburr" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/plexoos"><img src="https://avatars0.githubusercontent.com/u/5005079?v=4?s=100" width="100px;" alt="Dmitri Smirnov"/><br /><sub><b>Dmitri Smirnov</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=plexoos" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.matthewfeickert.com/"><img src="https://avatars3.githubusercontent.com/u/5142394?v=4?s=100" width="100px;" alt="Matthew Feickert"/><br /><sub><b>Matthew Feickert</b></sub></a><br /><a href="#infra-matthewfeickert" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.tamasgal.com"><img src="https://avatars1.githubusercontent.com/u/1730350?v=4?s=100" width="100px;" alt="Tamas Gal"/><br /><sub><b>Tamas Gal</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=tamasgal" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kreczko"><img src="https://avatars3.githubusercontent.com/u/1213276?v=4?s=100" width="100px;" alt="Luke Kreczko"/><br /><sub><b>Luke Kreczko</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=kreczko" title="Code">💻</a> <a href="https://github.com/scikit-hep/uproot5/commits?author=kreczko" title="Tests">⚠️</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nsmith-"><img src="https://avatars2.githubusercontent.com/u/6587412?v=4?s=100" width="100px;" alt="Nicholas Smith"/><br /><sub><b>Nicholas Smith</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=nsmith-" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nbiederbeck"><img src="https://avatars1.githubusercontent.com/u/15156697?v=4?s=100" width="100px;" alt="Noah Biederbeck"/><br /><sub><b>Noah Biederbeck</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=nbiederbeck" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/oshadura"><img src="https://avatars2.githubusercontent.com/u/7012420?v=4?s=100" width="100px;" alt="Oksana Shadura"/><br /><sub><b>Oksana Shadura</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=oshadura" title="Code">💻</a> <a href="#infra-oshadura" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://iscinumpy.gitlab.io"><img src="https://avatars1.githubusercontent.com/u/4616906?v=4?s=100" width="100px;" alt="Henry Schreiner"/><br /><sub><b>Henry Schreiner</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=henryiii" title="Code">💻</a> <a href="#infra-henryiii" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a> <a href="https://github.com/scikit-hep/uproot5/commits?author=henryiii" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/masonproffitt"><img src="https://avatars3.githubusercontent.com/u/32773304?v=4?s=100" width="100px;" alt="Mason Proffitt"/><br /><sub><b>Mason Proffitt</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=masonproffitt" title="Code">💻</a> <a href="https://github.com/scikit-hep/uproot5/commits?author=masonproffitt" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.linkedin.com/in/jonas-rembser/"><img src="https://avatars2.githubusercontent.com/u/6578603?v=4?s=100" width="100px;" alt="Jonas Rembser"/><br /><sub><b>Jonas Rembser</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=guitargeek" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/benkrikler"><img src="https://avatars0.githubusercontent.com/u/4083697?v=4?s=100" width="100px;" alt="benkrikler"/><br /><sub><b>benkrikler</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=benkrikler" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/HDembinski"><img src="https://avatars0.githubusercontent.com/u/2631586?v=4?s=100" width="100px;" alt="Hans Dembinski"/><br /><sub><b>Hans Dembinski</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=HDembinski" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://marcelrieger.com"><img src="https://avatars0.githubusercontent.com/u/1908734?v=4?s=100" width="100px;" alt="Marcel R."/><br /><sub><b>Marcel R.</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=riga" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://turra.web.cern.ch/turra/"><img src="https://avatars3.githubusercontent.com/u/143389?v=4?s=100" width="100px;" alt="Ruggero Turra"/><br /><sub><b>Ruggero Turra</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=wiso" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jrueb"><img src="https://avatars2.githubusercontent.com/u/30041073?v=4?s=100" width="100px;" alt="Jonas Rübenach"/><br /><sub><b>Jonas Rübenach</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=jrueb" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bfis"><img src="https://avatars0.githubusercontent.com/u/15651150?v=4?s=100" width="100px;" alt="bfis"/><br /><sub><b>bfis</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=bfis" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/raymondEhlers"><img src="https://avatars0.githubusercontent.com/u/1571927?v=4?s=100" width="100px;" alt="Raymond Ehlers"/><br /><sub><b>Raymond Ehlers</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=raymondEhlers" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://andrzejnovak.github.io/"><img src="https://avatars1.githubusercontent.com/u/13226500?v=4?s=100" width="100px;" alt="Andrzej Novak"/><br /><sub><b>Andrzej Novak</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=andrzejnovak" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bendavid"><img src="https://avatars2.githubusercontent.com/u/4920798?v=4?s=100" width="100px;" alt="Josh Bendavid"/><br /><sub><b>Josh Bendavid</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=bendavid" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://ddavis.io/"><img src="https://avatars2.githubusercontent.com/u/3202090?v=4?s=100" width="100px;" alt="Doug Davis"/><br /><sub><b>Doug Davis</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=douglasdavis" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/asymmetry"><img src="https://avatars3.githubusercontent.com/u/679529?v=4?s=100" width="100px;" alt="Chao Gu"/><br /><sub><b>Chao Gu</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=asymmetry" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ast0815"><img src="https://avatars2.githubusercontent.com/u/5884065?v=4?s=100" width="100px;" alt="Lukas Koch"/><br /><sub><b>Lukas Koch</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=ast0815" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://irfu.cea.fr/dap/"><img src="https://avatars1.githubusercontent.com/u/17836610?v=4?s=100" width="100px;" alt="Michele Peresano"/><br /><sub><b>Michele Peresano</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=HealthyPear" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/EdoPro98"><img src="https://avatars1.githubusercontent.com/u/57357892?v=4?s=100" width="100px;" alt="Edoardo"/><br /><sub><b>Edoardo</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=EdoPro98" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JMSchoeffmann"><img src="https://avatars1.githubusercontent.com/u/26558330?v=4?s=100" width="100px;" alt="JMSchoeffmann"/><br /><sub><b>JMSchoeffmann</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=JMSchoeffmann" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/alexander-held"><img src="https://avatars1.githubusercontent.com/u/45009355?v=4?s=100" width="100px;" alt="alexander-held"/><br /><sub><b>alexander-held</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=alexander-held" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://giordonstark.com/"><img src="https://avatars0.githubusercontent.com/u/761483?v=4?s=100" width="100px;" alt="Giordon Stark"/><br /><sub><b>Giordon Stark</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=kratsg" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://roneil.xyz"><img src="https://avatars.githubusercontent.com/u/56410978?v=4?s=100" width="100px;" alt="Ryunosuke O'Neil"/><br /><sub><b>Ryunosuke O'Neil</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=ryuwd" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://christopherappold.netlify.app/index.html"><img src="https://avatars.githubusercontent.com/u/28101201?v=4?s=100" width="100px;" alt="ChristopheRappold"/><br /><sub><b>ChristopheRappold</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=ChristopheRappold" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://cozzyd.net"><img src="https://avatars.githubusercontent.com/u/9206569?v=4?s=100" width="100px;" alt="Cosmin Deaconu"/><br /><sub><b>Cosmin Deaconu</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=cozzyd" title="Tests">⚠️</a> <a href="https://github.com/scikit-hep/uproot5/commits?author=cozzyd" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://peguerosdc.github.io/"><img src="https://avatars.githubusercontent.com/u/7889726?v=4?s=100" width="100px;" alt="Carlos Pegueros"/><br /><sub><b>Carlos Pegueros</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=peguerosdc" title="Documentation">📖</a> <a href="#example-peguerosdc" title="Examples">💡</a> <a href="https://github.com/scikit-hep/uproot5/commits?author=peguerosdc" title="Tests">⚠️</a> <a href="#tutorial-peguerosdc" title="Tutorials">✅</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/btovar"><img src="https://avatars.githubusercontent.com/u/3081826?v=4?s=100" width="100px;" alt="Benjamin Tovar"/><br /><sub><b>Benjamin Tovar</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=btovar" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://duncanmmacleod.github.io"><img src="https://avatars.githubusercontent.com/u/1618530?v=4?s=100" width="100px;" alt="Duncan Macleod"/><br /><sub><b>Duncan Macleod</b></sub></a><br /><a href="#infra-duncanmmacleod" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mpad"><img src="https://avatars.githubusercontent.com/u/1219868?v=4?s=100" width="100px;" alt="mpad"/><br /><sub><b>mpad</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=mpad" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/pfackeldey"><img src="https://avatars.githubusercontent.com/u/18463582?v=4?s=100" width="100px;" alt="Peter Fackeldey"/><br /><sub><b>Peter Fackeldey</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=pfackeldey" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://blog.kushkothari.in"><img src="https://avatars.githubusercontent.com/u/53650538?v=4?s=100" width="100px;" alt="Kush Kothari"/><br /><sub><b>Kush Kothari</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=kkothari2001" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aryan26roy"><img src="https://avatars.githubusercontent.com/u/50577809?v=4?s=100" width="100px;" alt="Aryan Roy"/><br /><sub><b>Aryan Roy</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=aryan26roy" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://blog.jling.dev"><img src="https://avatars.githubusercontent.com/u/5306213?v=4?s=100" width="100px;" alt="Jerry Ling"/><br /><sub><b>Jerry Ling</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=Moelf" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kakwok"><img src="https://avatars.githubusercontent.com/u/12798013?v=4?s=100" width="100px;" alt="kakwok"/><br /><sub><b>kakwok</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=kakwok" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/veprbl"><img src="https://avatars.githubusercontent.com/u/245573?v=4?s=100" width="100px;" alt="Dmitry Kalinkin"/><br /><sub><b>Dmitry Kalinkin</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=veprbl" title="Code">💻</a> <a href="#infra-veprbl" title="Infrastructure (Hosting, Build-Tools, etc)">🚇</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nikoladze"><img src="https://avatars.githubusercontent.com/u/3707225?v=4?s=100" width="100px;" alt="Nikolai Hartmann"/><br /><sub><b>Nikolai Hartmann</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=nikoladze" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.lieret.net"><img src="https://avatars.githubusercontent.com/u/13602468?v=4?s=100" width="100px;" alt="Kilian Lieret"/><br /><sub><b>Kilian Lieret</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=klieret" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dcervenkov"><img src="https://avatars.githubusercontent.com/u/23052054?v=4?s=100" width="100px;" alt="Daniel Cervenkov"/><br /><sub><b>Daniel Cervenkov</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=dcervenkov" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/beojan"><img src="https://avatars.githubusercontent.com/u/3727925?v=4?s=100" width="100px;" alt="Beojan Stanislaus"/><br /><sub><b>Beojan Stanislaus</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=beojan" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/agoose77"><img src="https://avatars.githubusercontent.com/u/1248413?v=4?s=100" width="100px;" alt="Angus Hollands"/><br /><sub><b>Angus Hollands</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=agoose77" title="Code">💻</a> <a href="#maintenance-agoose77" title="Maintenance">🚧</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lobis"><img src="https://avatars.githubusercontent.com/u/35803280?v=4?s=100" width="100px;" alt="Luis Antonio Obis Aparicio"/><br /><sub><b>Luis Antonio Obis Aparicio</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=lobis" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/renyhp"><img src="https://avatars.githubusercontent.com/u/20142663?v=4?s=100" width="100px;" alt="renyhp"/><br /><sub><b>renyhp</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=renyhp" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lgray"><img src="https://avatars.githubusercontent.com/u/1068089?v=4?s=100" width="100px;" alt="Lindsey Gray"/><br /><sub><b>Lindsey Gray</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=lgray" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ioanaif"><img src="https://avatars.githubusercontent.com/u/9751871?v=4?s=100" width="100px;" alt="ioanaif"/><br /><sub><b>ioanaif</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=ioanaif" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/natsukium"><img src="https://avatars.githubusercontent.com/u/25083790?v=4?s=100" width="100px;" alt="OTABI Tomoya"/><br /><sub><b>OTABI Tomoya</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=natsukium" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JostMigenda"><img src="https://avatars.githubusercontent.com/u/16189747?v=4?s=100" width="100px;" alt="Jost Migenda"/><br /><sub><b>Jost Migenda</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=JostMigenda" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://glepage.com"><img src="https://avatars.githubusercontent.com/u/33058747?v=4?s=100" width="100px;" alt="Gaétan Lepage"/><br /><sub><b>Gaétan Lepage</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=GaetanLepage" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/HaarigerHarald"><img src="https://avatars.githubusercontent.com/u/8050292?v=4?s=100" width="100px;" alt="HaarigerHarald"/><br /><sub><b>HaarigerHarald</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=HaarigerHarald" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bnavigator"><img src="https://avatars.githubusercontent.com/u/4623504?v=4?s=100" width="100px;" alt="Ben Greiner"/><br /><sub><b>Ben Greiner</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=bnavigator" title="Tests">⚠️</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://tooldev.de"><img src="https://avatars.githubusercontent.com/u/1640386?v=4?s=100" width="100px;" alt="Robin Sonnabend"/><br /><sub><b>Robin Sonnabend</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=YSelfTool" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bojohnson5"><img src="https://avatars.githubusercontent.com/u/20647190?v=4?s=100" width="100px;" alt="Bo Johnson"/><br /><sub><b>Bo Johnson</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=bojohnson5" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/milesgranger"><img src="https://avatars.githubusercontent.com/u/13764397?v=4?s=100" width="100px;" alt="Miles"/><br /><sub><b>Miles</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=milesgranger" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/djw9497"><img src="https://avatars.githubusercontent.com/u/51672890?v=4?s=100" width="100px;" alt="djw9497"/><br /><sub><b>djw9497</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=djw9497" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Pepesob"><img src="https://avatars.githubusercontent.com/u/113636251?v=4?s=100" width="100px;" alt="Piotr Sobczyński"/><br /><sub><b>Piotr Sobczyński</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=Pepesob" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/giedrius2020"><img src="https://avatars.githubusercontent.com/u/71819123?v=4?s=100" width="100px;" alt="Giedrius Juškevičius"/><br /><sub><b>Giedrius Juškevičius</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=giedrius2020" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/MatousVozak"><img src="https://avatars.githubusercontent.com/u/33348191?v=4?s=100" width="100px;" alt="MatousVozak"/><br /><sub><b>MatousVozak</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=MatousVozak" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/rossodisera"><img src="https://avatars.githubusercontent.com/u/46961664?v=4?s=100" width="100px;" alt="Andrea Serafini"/><br /><sub><b>Andrea Serafini</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=rossodisera" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.ariostas.com"><img src="https://avatars.githubusercontent.com/u/7596837?v=4?s=100" width="100px;" alt="Andres Rios Tascon"/><br /><sub><b>Andres Rios Tascon</b></sub></a><br /><a href="https://github.com/scikit-hep/uproot5/commits?author=ariostas" title="Code">💻</a></td>
      </tr>
    </tbody>
  </table>

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

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

  💻: code, 📖: documentation, 🚇: infrastructure, 🚧: maintainance, ⚠: tests/feedback, 🤔: foundational ideas.


pkgId: 8fd4519aeb6604496e8da7deb7c35453e48d705d296ceff2b7eff8bf58c8aba4
name: python-upset-alttxt-help
arch: noarch
version: 0.4.7
epoch: 0
release: 1
summary: Development documents and examples for upset-alttxt
url: https://pypi.org/project/upset-alttxt/
rpm_license: BSD3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-upset-alttxt-0.4.7-1.src.rpm
location_href: Packages/python-upset-alttxt-help-0.4.7-1.noarch.rpm
checksum_type: sha256
description:
  Design experiments for generating semantically meaningful alt-text for UpSet Plots.



  1. Clone the repository using `git clone` or download and extract the zip file.
  2. Ensure you have python version >= 3.8.10 installed.
  3. Open a terminal in the repository directory and create and activate a python virtual environment running at least Python 3.8.10. For information on how to do this, navigate [here](https://docs.python.org/3/library/venv.html).
  4. Install the required dependencies using `pip install -r requirements.txt`.
  5. (Optional) Install the required development dependencies using `pip install -r requirements_dev.txt`. These are only required if you plan on running the tests or linting.
  6. Install the alttxt module in development mode with `pip install -e .`


  To run the program with the example data, run `python [path/to/alttxt directory] --data ../../data/movie_data_card_sort.json`
  Level and granularity can be changed to any of the options listed in [Command Line Options](#command-line-options).
  Here is an example command:
      For unix/macOS: `python3 src/alttxt --data data/movie_data_dev_sort.json`
      For Windows: `python src/alttxt --data data/movie_data_dev_sort.json`



  Local testing can be done using the `tox` command. Tests have not been updated to match the latest updates to the repository, and updating them is currently on hold, as deployment is a priority over robustness.

  - Linting: To run the linting tests, run `tox -e lint`
  - Type: To run the type tests, run `tox -e type`
  - Tests: To run the python tests, run `tox -e test`
  - Formatting: To automatically format the files to match the `flake8-black` standards, run `tox -e format`

  To run the entire suite of tests at once, use `tox`.



  | Command                | Description                                                                                     |
  |------------------------|-------------------------------------------------------------------------------------------------|
  | `-h`, `--help`         | Show information on each command and exit.                                                      |
  | `-V`, `--version`      | Show the program version number and exit.                                                       |
  | `-D`, `--data`         | (Required) Relative path to data file.                                                          |
  | `-l`, `--level`        | Semantic level. Defaults to a combination of all levels. Options are: `1`, `2`.                 |
  | `-st`, `--structured`  | Returns information in JSON format that contains structured text (long description), alt-txt (short description), and technical description of the plot making strategy                                                 |
  | `-t`, `--title`        | A title for the plot; used in some generations. Defaults to `has no title`.                     |
  |------------------------|     -------------------------------------------------------------------------------------------------|


pkgId: 0093340c3fca81c541e7b82fd0890962e8def7fb1b1263fc8d9476d4189d93ca
name: python-uptainer-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for uptainer
url: https://pypi.org/project/uptainer/
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uptainer-0.1.5-1.src.rpm
location_href: Packages/python-uptainer-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  Uptainer is a Python CLI that automates tool updates, ensuring consistency and reliability in your GitOps-driven infrastructure.
  The tool offers a straightforward interface for specifying the repository from which to read and write, as well as the regular expression to constrain version increments. The tool will then handle the remaining automation tasks.


pkgId: a426277b133f94605f9203faff2b612ec4d42ef4403ed8f03f76b3d70f1cb2f6
name: python-urljsf-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for urljsf
url: https://pypi.org/project/urljsf/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-urljsf-0.1.4-1.src.rpm
location_href: Packages/python-urljsf-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  |            docs             |                                          install                                           |                build                 |
  | :-------------------------: | :----------------------------------------------------------------------------------------: | :----------------------------------: |
  | [![docs][docs-badge]][docs] | [![install from pypi][pypi-badge]][pypi] [![install from conda-forge][conda-badge]][conda] | [![build][workflow-badge]][workflow] |

  > Build statically-hostable, interactive HTML forms for making web requests
  >
  > _Powered by [`react-json-schema-form`][rjsf] and
  > [`react-`][react-bootstrap][`bootstrap`][bootstrap]._

  [bootstrap]: https://github.com/twbs/bootstrap
  [json-schema]: https://json-schema.org
  [rjsf]: https://github.com/rjsf-team/react-jsonschema-form
  [react-bootstrap]: https://github.com/react-bootstrap/react-bootstrap
  [ui-schema]:
    https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/
  [docs]: https://urljsf.rtfd.org
  [docs-badge]: https://readthedocs.org/projects/urljsf/badge/?version=latest
  [conda-badge]: https://img.shields.io/conda/vn/conda-forge/urljsf
  [conda]: https://anaconda.org/conda-forge/urljsf
  [pypi-badge]: https://img.shields.io/pypi/v/urljsf
  [pypi]: https://pypi.org/project/urljsf
  [workflow-badge]:
    https://github.com/deathbeds/urljsf/actions/workflows/ci.yml/badge.svg?branch=main
  [workflow]:
    https://github.com/deathbeds/urljsf/actions/workflows/ci.yml?query=branch%3Amain

  **Visitors** to a `urljsf`-built page see:

  - one or more interactive HTML forms...
    - defined by and validated against a JSON [Schema][json-schema], optionally with...
    - deep customizable [user interface][ui-schema]
    - pre-filled data
    - custom validation checks

  Once the data is _validated_, the user sees a button which gets a URL, which can be:

  - downloaded as a file
  - opened in a new browser window
  - copy and pasted
  - submitted to an HTTP endpoint, either by opening a new window, or directly.
  - open native applications like email

  `urljsf` **doesn't** ship a server, so that part is up to you!

  **Site builders** write TOML, JSON, YAML or python, then can use `urljsf` as:

  - a drop-in-and-pray [`script`](#js-script)
  - a standalone [CLI tool](#command-line)
  - a [`sphinx`](#sphinx) or [`mkdocs`](#mkdocs) extension

  ... to create JavaScript/HTML forms that helps **visitors** provide good data for:

  - pull requests
  - issues
  - galleries
  - surveys
  - on-demand build services
  - precise test descriptions
  - linter rules



  [contrib]: https://github.com/deathbeds/urljsf/blob/main/CONTRIBUTING.md



  `urljsf` is distributed on [PyPI][pypi], with several optional extras to help ensure
  tested versions are available:

  ```bash
  pip install urljsf





  uv install urljsf

  ```



  `urljsf` is also distributed on [`conda-forge`][conda], with similar extras:

  ```bash
  pixi add urljsf





  micromamba install -c conda-forge urljsf

  mamba install -c conda-forge urljsf

  conda install -c conda-forge urljsf

  ```



  See the [contributing guide][contrib] for a development install.



  `urljsf` work with some [JSON schema](#json-schema) constrained files as a:

  - (not-recommended) hot-linked [`script`](#js-script)
  - a standalone [site generator](#command-line) for simple sites
  - a plugin for the [`sphinx`](#sphinx) and [`mkdocs`](#mkdocs) documentation systems



  A `urljsf` is built from a number of JSON schema-constrained files. Writing these in
  plain JSON is tedious, so TOML and YAML are also supported inputs for any of the methods
  below. Learn more on the [schema documentation][schema-docs].

  [schema-docs]: https://urljsf.rtfd.org/en/latest/use/schema.html



  A very simple, but limited, usage is an `.html` file that links to `urljsf` and
  `bootstrap` resources on the internet.

  ```html
  <script type="application/vnd.deathbeds.urljsf.v0+toml">
    [forms.url.schema]
    title = "pick an xkcd"
    description = "this will redirect to `xkcd.com`"
    type = "object"
    required = ["xkcd"]
    properties.xkcd = {type="integer", minimum=1, maximum=2997}

    [forms.url.ui_schema.xkcd."ui:options"]
    widget = "range"

    [templates]
    url = "https://xkcd.com/{{ data.url.xkcd }}"
    submit_button = "see xkcd #{{ data.url.xkcd }}"
  </script>
  <script
    type="module"
    src="https://deathbeds.github.io/urljsf/_static/index.js"
  ></script>
  ```

  This technique has _many_ limitations, and is **not recommended**.

  Some ways to improve:

  - download a GitHub release and unpack it, serving the files next to it
  - ensure bootstrap is loaded _before_ the script, with a `link` tag in a `head`.
  - on the `script` element, use a `src` to point to a valid `urljsf` definition
  - use the [CLI](#command-line) or a documentation extension for [`sphinx`](#sphinx) or
    [`mkdocs`](#mkdocs)



  The `urljsf` command line generates a ready-to-serve, standalone site with all required
  static assets. Written in `python`, it can reuse the extensive JSON schema support in
  the python ecosystem, such as `msgspec` or `pydantic`.

  ```bash
  prsf --help
  ```

  `urljsf` requires at least a definition file, but offers many command line options: see
  the [documentation][cli-docs] for more.

  [cli-docs]: https://urljsf.rtfd.org/en/latest/use/cli.html



  After [installing](#install) with the `[sphinx]` extra, add `urljsf.sphinxext` to
  `conf.py`:

  ```py

  extensions = [
    
    "urljsf.sphinxext",
  ]
  ```

  Then use the `urljsf` directive in source files:

  ```rst
  .. urljsf:  # a relative path to a description as a TOML, YAML, or JSON file or python
    :toml:
    
  ```

  See the [documentation][sphinx-docs] for more about configuring `urljsf.sphinxext`, the
  `urljsf` directive, and more advanced use cases.

  [sphinx-docs]: https://urljsf.rtfd.org/en/latest/use/sphinx.html



  After [installing](#install) with the `[mkdocs]` extra, add `urljsf` to `mkdocs.yml`:

  ```yaml

  plugins:
    - urljsf
  ```

  Then use the `urljsf` fenced code block in source files:

  ````markdown
  ```urljsf {path=path/to/defnition.toml}

  ```
  ````

  See the [documentation][mkdocs-docs] for more about configuring `urljsf`, the `urljsf`
  fence, and more advanced use cases.

  [mkdocs-docs]: https://urljsf.rtfd.org/en/latest/use/mkdocs.html



  - `react-json-schema-form` cannot represent all possible data structures, such as
    writing a _new_ JSON schema _in_ JSON schema, or many features added after Draft 7
  - the generated scripts _won't_ work when served from `file://` due to browser CORS
    headers requirements for `type="module"` scripts
  - the [`sphinx`](#sphinx) integration is only tested with the `html` builder, the basic
    `alabaster` theme, and [`pydata-sphinx-theme`][pdst] (by way of `urljsf`'s own
    [documentation][sphinx-docs])
  - the [`mkdocs`](#mkdocs) integration is only tested with the default theme

  [pdst]: https://github.com/pydata/pydata-sphinx-theme



  `urljsf` itself is licensed under the `BSD-3-Clause` license. You can do whatever you
  want with it, but if you change it a lot, it's not the maintainers' problem.

  `urljsf` distributes third-party JavaScript and CSS in various forms, licensed under the
  `MIT`, `BSD-3-Clause`, and `ISC` licenses.


pkgId: 71e134c28e7de4af3ac3840151540a38f03b283fc9525fec14beb355939a09cd
name: python-usports-basketball-help
arch: noarch
version: 2.0.3
epoch: 0
release: 1
summary: Development documents and examples for usports-basketball
url: https://pypi.org/project/usports-basketball/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-usports-basketball-2.0.3-1.src.rpm
location_href: Packages/python-usports-basketball-help-2.0.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/usports-basketball?color=orange)](https://pypi.org/project/usports-basketball/)
  [![License](https://img.shields.io/pypi/l/usports-basketball.svg)](https://github.com/ojadeyemi/usports-basketball/blob/main/LICENSE)
  [![Downloads](https://static.pepy.tech/badge/usports-basketball)](https://pepy.tech/project/usports-basketball)
  [![Package Status](https://img.shields.io/pypi/status/usports-basketball.svg)](https://pypi.org/project/usports-basketball/)

  **usports-basketball** is a Python package that fetches and analyzes current basketball stats from the [U Sports website](https://usports.ca/en).

  With two simple functions you can easily retrieve detailed data for either the men's or women's league.

  - `usport_team_stats`: Fetch team stats.
  - `usport_players_stats`: Fetch player stats.

  Each function returns a pandas DataFrame with the relevant statistics, allowing users to gather data for analysis and insights.



  You can install the package via pip:

  ```bash
  pip install usports-basketball
  ```



  This package relies on the following dependencies:

  - pandas
  - BeautifulSoup (bs4)
  - requests
  - pytest
  - playwright



  After installing the package, you'll need to install Playwright's Chromium browser. Run the following command:

  ```bash
  playwright install chromium
  ```





  This function fetches and processes team statistics data, including standings, win-loss totals, shooting percentages, and other relevant team metrics for the current U Sports basketball season.



  - `arg` (str): The league for which you want to retrieve team statistics. Valid values are `'men'` and `'women'` or `'m'` and `'w'` (case-insensitive).
  - `season_option` (str, optional): The season type to fetch data for. Options are:
    - `'regular'` (default): Regular season statistics.
    - `'playoffs'`: Playoff season statistics.
    - `'championship'`: Championship season statistics.



  - `DataFrame`: A pandas DataFrame containing the team statistics data.



  This function fetches and processes player statistics data, including total games played, points scored, shooting percentages, rebounds, assists, turnovers, steals, blocks, and other individual player metrics for the current U Sports basketball season.



  - `arg` (str): The league for which you want to retrieve team statistics. Valid values are `'men'` and `'women'` or `'m'` and `'w'` (case-insensitive).
  - `season_option` (str, optional): The season type to fetch data for. Options are:
    - `'regular'` (default): Regular season statistics.
    - `'playoffs'`: Playoff season statistics.
    - `'championship'`: Championship season statistics.



  - `DataFrame`: A pandas DataFrame containing the player statistics data.



  - ### Fetching current stats from the league

  ```python
  from usports_basketball import usport_team_stats, usports_player_stats


  men_team_stats_df = usport_team_stats('m')


  men_player_stats_df = usport_players_stats('m')


  women_team_stats_df = usport_team_stats('w', 'playoffs')


  women_player_stats_df = usport_players_stats('w', 'championship')
  ```

  - ### Viewing Column Names

  ```python


  print("Column names in men's player statistics DataFrame:")
  print(men_player_stats_df.columns.tolist())


  print("\nColumn names in men's player statistics DataFrame:")
  print(men_player_stats_df.columns.tolist())
  ```

  - ### Exporting DataFrame to different files

  ```python

  men_team_stats_df.to_csv('men_team_stats.csv', index=False)  # Export without row index


  men_team_stats_df.to_html('table.html')


  men_team_stats_df.to_json('men_team_stats.json', orient='records') # Export in 'records' format


  from sqlalchemy import create_engine

  engine = create_engine('sqlite:///usports_stats.db') #Export to SQLite database
  women_team_stats_df.to_sql('team_stats', con=engine, index=False) # Export without row index
  women_player_stats_df.to_sql('player_stats', con=engine, index=False) # Export without row index
  ```





  This package was developed by OJ Adeyemi.



  Contributions, bug reports, and feature requests are welcome! Please feel free to open an issue or submit a pull request on [GitHub](https://github.com/ojadeyemi/usports-basketball).



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

rpm_license:
  MIT License  Copyright (c) 2024 OJ Adeyemi  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: e1b3423be1b581683956bb687c6fbe8ff9813f57d7eef4d149b75973e026364a
name: python-usps-cli-help
arch: noarch
version: 0.9.3
epoch: 0
release: 1
summary: Development documents and examples for usps-cli
url: https://github.com/iiPythonx/usps
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-usps-cli-0.9.3-1.src.rpm
location_href: Packages/python-usps-cli-help-0.9.3-1.noarch.rpm
checksum_type: sha256
description:
  A CLI for tracking packages from USPS (with crude support for UPS packages).



  ```sh
  uv pip install usps-cli


  uv pip install git+https://github.com/iiPythonx/usps
  ```



  > [!IMPORTANT]
  > For UPS packages, USPS-cli only support the `1Z` version of UPS tracking numbers right now.

  Get the tracking information for a package:
  ```sh
  usps track 9400100000000000000000
  ```

  Add a tracking number to your package list:
  ```sh
  usps add 9400100000000000000000
  ```

  Remove a tracking number from your package list:
  ```sh
  usps remove 9400100000000000000000
  ```

  Show all your current packages:
  ```sh
  usps track
  ```

  Add a name to a package:
  ```sh
  $ usps name 9400100000000000000000 "Amazon Package"


  $ usps name 9400100000000000000000
  Choose a package name: Amazon Package
  ```

  Remove the name from a package:
  ```sh
  usps name --erase 9400100000000000000000
  ```

  For more details, run `usps --help`.



  > [!NOTE]
  > If you **only** plan to track **UPS** packages, you can skip installing a selenium driver.

  Since this package uses selenium for challenge solving, you'll need to install a [Gecko-based browser](https://www.mozilla.org/en-US/firefox) and [geckodriver](https://github.com/mozilla/geckodriver/releases).
  Feel free to modify the code to use Chromium instead if you prefer it.

  If you're on Arch: `sudo pacman -S firefox geckodriver`,



  - Selenium goes to the USPS tracking website, completing the JS challenge and saving the cookies.
  - This client saves that request data to a JSON file for reuse (speeds up the client dramatically).
  - Next, requests pulls the page from USPS using our saved cookies and parses it with BeautifulSoup.
  - Apply some basic scraping and there you go, a USPS tracking client.

  It's worth noting I scrape USPS because their APIs [get basically no support](https://github.com/USPS/api-examples/issues/28), [require the creation of business accounts](https://developer.usps.com/getting-started) and filling out every piece of information about yourself, and even then you have to [request explicit access to the tracking API](https://developer.usps.com/quotaform).



  If you're a USPS web tools representative or something and have a problem with this repository, shoot me an email: [ben@iipython.dev](mailto:ben@iipython.dev).


pkgId: 9e92c8741acecbcff38bbd76d260f261892a5e199eebc4c6779efb9cb34493ef
name: python-usql-bin
arch: noarch
version: 0.19.14
epoch: 0
release: 1
summary: A thin wrapper to distribute https://github.com/xo/usql via pip.
url: https://pypi.org/project/usql-bin/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-usql-bin-0.19.14-1.src.rpm
location_href: Packages/python-usql-bin-0.19.14-1.noarch.rpm
checksum_type: sha256
description:
  This project was inspired by how [Maturin packages rust binaries](https://www.maturin.rs/bindings#bin).  The key observation is that in the wheel format, the [distribution-1.0.data/scripts/ directory is copied to bin](https://packaging.python.org/en/latest/specifications/binary-distribution-format/#installing-a-wheel-distribution-1-0-py32-none-any-whl), which means we can leverage this to seamlessly copy binaries into a user's PATH.

  Combined with Python's platform-specific wheels, this allows us to use pip as a "cross-platform package manager" for distributing single-binary CLI applications.

  This is the [list of tools bundled this way](https://github.com/justin-yan/pybin/tree/main/src/pybin), which can be installed with `pip install $TOOLNAME-bin`.



  The core of the logic lies in the `buildlib.py` module.

  - A mapping from download URL (often github releases) to pypi platform tag is required.
  - For each platform:
      - Download the release & extract the binary.
      - Set file permissions and place into scripts directory within wheel archive.
      - Create the METADATA and WHEEL files within wheel archive.
      - Place wheel into `dist/` folder.
  - Once all wheels are constructed, the distribution is uploaded to PyPI.

  CICD is configured to automatically recognize new *PyPI* releases by looking for a diff on the PYPI_VERSION.  When this happens, a build-and-release cycle is performed for that release version.


pkgId: d8801a5e362fe8db6bd451cadc7d4d88030f9b564625966cca5ca0e2d687f717
name: python-utilmeta-proxy-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for utilmeta-proxy
description: A proxy service that connect API services in a internal network to UtilMeta cluster
url: https://utilmeta.com
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-utilmeta-proxy-0.1.2-1.src.rpm
location_href: Packages/python-utilmeta-proxy-help-0.1.2-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2024 Xulin Zhou (周煦林)  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: e7520b0bd6730077e03f19dacb89ded206335e8c26441101b9a68d5e569ac555
name: python-utinyec-help
arch: noarch
version: 0.4.5
epoch: 0
release: 1
summary: Development documents and examples for utinyec
url: https://github.com/JackLawrenceCRISPR/utinyec
rpm_license: aGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-utinyec-0.4.5-1.src.rpm
location_href: Packages/python-utinyec-help-0.4.5-1.noarch.rpm
checksum_type: sha256
description:
  A tiny library to perform potentially unsafe cryptography with arithmetic operations on elliptic curves in pure micropython. No dependencies.

  **This is not a library suitable for production.** It is useful for security professionals to understand the inner workings of EC, and be able to play with pre-defined curves.
  No really, this module has not been tested for vulnerabilities. It should never be used in production. I am not accountable for what you choose to do with this module.

  utinyec shows the mathematics behind eliptical curve cryptography (ECC) in pure python which is useful for educational purposes. C based solutions with python API can be compiled from these two libraries: [ucryptography](https://github.com/dmazzella/ucryptography) or [ucrypto](https://github.com/dmazzella/ucrypto), they use C for the cryptography which is MUCH faster than pure python.

  If you want to convert this from micropython to regular python then change "from uos import urandom" to "from os import urandom" in both ec.py AND cryptography.py, then change 'from ucryptolib import aes' to 'from cryptolib import aes' in cryptography.py.
  This package is very slow, and possibly unsafe as it has not been audited; if you need a cryptography solution in regular python please use pip install cryptography, or if you are using android you need to use 'apt install python-cryptography' as the rust dependency is dropped for functionality in Termux.


  `pip install utinyec`
  In Thonny you can find it in Tools -> Manage Packages, then search for utinyec.


  ```python

  print('please be patient, this may take a while...')


  from utinyec.cryptography import uECcrypto
  specified_private_key_int = None  #use a previous alices_session.get_private_key_int() in here to use the same key pair
  curve_name = 'secp256r1'  #see registry.py for a list of curve names
  alices_session = uECcrypto(curve_name, specified_private_key_int) # derive_shared_secret AES256 keys are
  print('alices_session is ready...')


  bobs_session = uECcrypto(curve_name)
  print('bobs_session is ready...')


  alices_public_key = alices_session.get_public_key()
  bobs_public_key = bobs_session.get_public_key()
  print("bob and alice exchange public keys...")



























  plaintext = 'This is AES cryptographic'.strip() #secret message that alice will send to bob, note that blank spaces will be trimmed due to block padding
  print('alice is encrypting her message...')
  encrypted_message = alices_session.encrypt(plaintext, bobs_public_key, "CBC")	#alices_session will encrypt using the derived shared secret
  print('alice has encrypted her message and sends it to bob...')
  decrypted_message = bobs_session.decrypt(encrypted_message, alices_public_key, "CBC")	#the second alices_session will derive the same shared secret with the other key combination, then decrypt the data
  print('bob has decrypted alices message...')


  print("")
  print("RESULT:")

  print("")
  print("alices_session private",alices_session.keypair.priv) #alice shouldn't share this with anyone!
  print('bobs_session public:',bobs_public_key)
  alices_shared_secret = alices_session.derive_shared_secret(bobs_public_key)
  print('alices shared secret:', alices_shared_secret) #this is faster with caching enabled, also alice shouldn't share this with anyone!


  print("")
  print("bobs_session private",bobs_session.keypair.priv) #bob shouldn't share this with anyone!
  print('alices_session public:',alices_public_key)
  bobs_shared_secret = bobs_session.derive_shared_secret(alices_public_key)
  print('bobs shared secret:',bobs_session.derive_shared_secret(alices_public_key) ) #this is faster with caching enabled, also bob shouldn't share this with anyone!




  print("")
  print('Alices original message:',plaintext)
  print('Encrypted message:', encrypted_message)
  print('Alices message decrypted by Bob:', decrypted_message.strip())

  assert bobs_shared_secret == alices_shared_secret, "Error: alice and bob derived different shared secrets!"
  print("bob and alice have correctly derived the same shared secret")
  assert plaintext == decrypted_message.decode('utf-8').strip(), "Error: bob's decrypted message is not the same as what alice sent!"
  print("bob has correctly read alice's message")
  print("Demonstration complete.")





  print("")
  print("Demonstrating caching...")
  import utime
  print("3")
  utime.sleep(1)
  print("2")
  utime.sleep(1)
  print("1")
  utime.sleep(1)
  print("GO")

  plaintext2 = 'Alice likes eating apples.'.strip() #secret message that alice will send to bob, note that blank spaces will be trimmed due to block padding
  print('alice is encrypting her second message...')
  encrypted_message2 = alices_session.encrypt(plaintext2, bobs_public_key, "CBC")	#if caching is enabled this will be FAST
  print('alice has encrypted her second message and sends it to bob...')
  decrypted_message2 = bobs_session.decrypt(encrypted_message2, alices_public_key, "CBC")	#if caching is enabled this will be FAST
  print('bob has decrypted alices second message...')
  assert plaintext2 == decrypted_message2.decode('utf-8').strip(), "Error: bob's decrypted message is not the same as what alice sent!"
  print("bob has correctly read alice's second message")
  print("Caching demonstration complete.")
  ```



  Using regular python (not micropython) you can use the cryptography module to convert from coordinate to standard PEM, or reverse.
  Conversion may be useful when communicating with non-microcontroller devices, as devices using regular python can convert public keys to coordinates before sending them.
  I do not know of a method to convert formats within micropython, and such a method is outside my personal use case for this project. Send the github repository a pull request if you write one!


  ```python


  public_key_coordinates = (27080695663519936575286139140947921079432612852248858477930157300769994068404, 89650813448058425836500999002714743992773189021923677962194438343503940101997)




  from cryptography.hazmat.primitives import serialization
  from cryptography.hazmat.primitives.asymmetric import ec

  def get_pem_from_ecc_coordinates(public_key_coordinates):
      
      curve = ec.SECP256R1()
      x_coordinate, y_coordinate = public_key_coordinates

      
      ec_public_key = ec.EllipticCurvePublicNumbers(x_coordinate, y_coordinate, curve).public_key()

      
      return ec_public_key.public_bytes(
          encoding=serialization.Encoding.PEM,
          format=serialization.PublicFormat.SubjectPublicKeyInfo
      )

  def get_ecc_coordinates_from_pem(pem_data):
      
      ec_public_key = serialization.load_pem_public_key(pem_data)

      
      public_numbers = ec_public_key.public_numbers()

      
      return (public_numbers.x, public_numbers.y)




  print("original coordinates:", public_key_coordinates)


  pem = get_pem_from_ecc_coordinates(public_key_coordinates)
  print("derived PEM:", pem.decode('utf-8'))   #decode bytes to string format


  processed_public_key_coordinates = get_ecc_coordinates_from_pem(pem)    #pem is given as bytes by the way, not a string!
  print("derived coordinates:", public_key_coordinates)
  ```


pkgId: ecc070151a8c52cf0b255a7d1901b4cf9784f07137fa51d81fe5d655c704f60c
name: python-utitools-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for utitools
url: https://pypi.org/project/utitools/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-utitools-0.3.0-1.src.rpm
location_href: Packages/python-utitools-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Feel free to contribute or submit issues via [GitHub issues](https://github.com/rhettbull/utitools/issues).


pkgId: d600bb1127c6acc64962ab606dee6b3544a9f05f3ab1a8ec4e3deb524bdcd0be
name: python-uv2conda-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for uv2conda
url: https://github.com/fepegar/uv2conda
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uv2conda-0.1.8-1.src.rpm
location_href: Packages/python-uv2conda-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/uv2conda)

  Tiny Python package to create a [`conda`](https://docs.anaconda.com/miniconda/) environment file from a Python project using [`uv`](https://docs.astral.sh/uv/).

  ```shell
  pip install uv2conda
  uv2conda \
      --project-dir "/path/to/my/project/" \
      --name "my_conda_env_name" \
      --python "3.12.7" \
      --conda-env-path "my_conda_env.yaml" \
      --requirements-path "requirements.txt" \
      --uv-args "--prerelease=allow"
  ```

  Or, in Python:

  ```python
  import uv2conda

  uv2conda.make_conda_env_from_project_dir(
      "/path/to/my/project/",
      name="my_conda_env_name",
      python_version="3.12.7",
      out_path="environment.yaml",
      requirements_path="requirements.txt",
      uv_args=["--prerelease=allow"],
  )
  ```

  Example for this library:

  ```shell
  uv2conda --python 3.12.7 --show
  ```

  Output (printed on screen as we used `--show`):

  ```yaml
  name: uv2conda
  dependencies:
  - python=3.12.7
  - pip
  - pip:
    - click==8.1.7
    - colorama==0.4.6 ; sys_platform == 'win32' or platform_system == 'Windows'
    - loguru==0.7.2
    - markdown-it-py==3.0.0
    - mdurl==0.1.2
    - packaging==24.2
    - pygments==2.18.0
    - pyyaml==6.0.2
    - rich==13.9.4
    - shellingham==1.5.4
    - typer==0.13.1
    - typing-extensions==4.12.2
    - win32-setctime==1.1.0 ; sys_platform == 'win32'
  ```



  - [`pyproject2conda`](https://pypi.org/project/pyproject2conda/)


pkgId: 17246d331445f46cc58a9a49c6885b25323337237913be2075535109d37afccc
name: python-uvicorn-help
arch: noarch
version: 0.33.0
epoch: 0
release: 1
summary: Development documents and examples for uvicorn
url: https://www.uvicorn.org/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uvicorn-0.33.0-1.src.rpm
location_href: Packages/python-uvicorn-help-0.33.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/encode/uvicorn/workflows/Test%20Suite/badge.svg)](https://github.com/encode/uvicorn/actions)
  [![Package version](https://badge.fury.io/py/uvicorn.svg)](https://pypi.python.org/pypi/uvicorn)
  [![Supported Python Version](https://img.shields.io/pypi/pyversions/uvicorn.svg?color=%2334D058)](https://pypi.org/project/uvicorn)


pkgId: 1506c558883191d69b7c7a48c7fb33d1afe6a3f251699c635af044cde201b240
name: python-uwifi-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for uwifi
url: https://github.com/armanghobadi/uwifi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-uwifi-1.0.0-1.src.rpm
location_href: Packages/python-uwifi-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  `uwifi` is a Wi-Fi management library for MicroPython that allows easy connection, disconnection, and configuration of Wi-Fi interfaces. It supports both **Station (STA)** and **Access Point (AP)** modes and provides useful features like static IP configuration, ping testing, network scanning, and retry logic for connectivity issues. The library is specifically designed for use with microcontrollers and embedded systems, such as **ESP32** and **ESP8266**, making it an ideal choice for IoT projects and embedded Wi-Fi applications.



  - **Connect**: Connect to a Wi-Fi network using SSID and password.
  - **Disconnect**: Disconnect from the current Wi-Fi network.
  - **Check Connection**: Check if the device is connected to a network.
  - **Static IP Setup**: Set a static IP address, subnet mask, gateway, and DNS.
  - **Ping Test**: Ping an external server to check for internet access.
  - **Reconnect**: Automatically retry connecting to a network multiple times if initial attempts fail.
  - **List Available Networks**: Scan and list available Wi-Fi networks (SSIDs).
  - **Access Point Mode**: Set the device as an Access Point with configurable SSID, password, and authentication mode.
  - **Disable AP Mode**: Disable Access Point mode when not in use.
  - **Wi-Fi Status**: Display the current connection status (either connected or disconnected).



  To use `uwifi`, simply copy the `uwifi.py` file to your MicroPython project. There are no external dependencies required.



  ```python
  import time
  from uwifi.core import uwifi


  wifi = uwifi()


  ssid = "YourWiFiSSID"  # Replace with your SSID
  password = "YourWiFiPassword"  # Replace with your Wi-Fi password
  if wifi.connect(ssid, password, timeout=10):
      print("Connected successfully!")
  else:
      print("Connection failed. Please check your credentials.")


  status = wifi.check_wifi_status()
  print("Wi-Fi Status:", status)


  wifi.set_static_ip("192.168.1.100", "255.255.255.0", "192.168.1.1", "8.8.8.8")


  print("Current IP configuration:", wifi.get_ip_config())


  if wifi.ping("8.8.8.8"):
      print("Ping successful!")
  else:
      print("Ping failed!")


  networks = wifi.list_available_networks()
  print("Available Networks:", networks)


  if not wifi.connect(ssid, password, timeout=10):
      print("Attempting to reconnect...")
      if wifi.reconnect(ssid, password, timeout=10, retry_count=3):
          print("Reconnected successfully!")
      else:
          print("Failed to reconnect.")


  wifi.create_access_point("MyAP", "myAPpassword")


  wifi.disable_access_point()


  wifi.disconnect()
  ```




  **Description**: Connects to a Wi-Fi network with the given SSID and password.
  **Parameters**:
  - `ssid`: The SSID of the Wi-Fi network.
  - `password`: The password of the Wi-Fi network.
  - `timeout`: The maximum time (in seconds) to attempt the connection.
  **Returns**: `True` if the connection is successful, `False` otherwise.


  **Description**: Disconnects from the currently connected Wi-Fi network.
  **Returns**: None.


  **Description**: Checks if the device is connected to a Wi-Fi network.
  **Returns**: `True` if connected, `False` otherwise.


  **Description**: Configures a static IP address, subnet mask, gateway, and DNS.
  **Parameters**:
  - `ip`: The static IP address.
  - `subnet`: The subnet mask.
  - `gateway`: The gateway address.
  - `dns`: (Optional) The DNS server address. Defaults to gateway if not provided.
  **Returns**: None.


  **Description**: Retrieves the current IP configuration (IP, Subnet Mask, Gateway, DNS).
  **Returns**: A tuple containing the IP address, subnet mask, gateway, and DNS.


  **Description**: Pings a server to check internet connectivity.
  **Parameters**:
  - `host`: The server to ping (default is 8.8.8.8).
  - `count`: The number of ping attempts to make.
  **Returns**: `True` if any ping is successful, `False` otherwise.


  **Description**: Attempts to reconnect to a Wi-Fi network multiple times in case of failure.
  **Parameters**:
  - `ssid`: The SSID of the network.
  - `password`: The password of the network.
  - `timeout`: The timeout duration in seconds for each attempt.
  - `retry_count`: The number of retry attempts.
  **Returns**: `True` if connected successfully after retries, `False` otherwise.


  **Description**: Scans for available Wi-Fi networks and returns a list of their SSIDs.
  **Returns**: A list of SSIDs.


  **Description**: Configures the device as an Access Point (AP).
  **Parameters**:
  - `ssid`: The SSID of the AP.
  - `password`: (Optional) The password for the AP.
  - `authmode`: The authentication mode (default is WPA2).
  - `channel`: The channel for the AP (default is 1).
  - `max_clients`: Maximum number of clients (default is 4).
  **Returns**: None.


  **Description**: Disables the Access Point mode.
  **Returns**: None.


  **Description**: Checks the current Wi-Fi status.
  **Returns**: A string indicating the connection status (e.g., "Connected" or "Not connected").


  - **MicroPython**: This library is designed for use with MicroPython on ESP32, ESP8266, or other compatible boards.
  - **Network Interface**: The device must have a Wi-Fi interface (e.g., ESP32 or ESP8266).


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





  ![uwifi in Test-file](./tests/test.png)


