# packages

pkgId: d31309098191585a5ec9c73f6c1a5dc8a56da86f5feebc5e03e81d248cd143c3
name: python-cuenca-validations
arch: src
version: 0.11.33
epoch: 0
release: 1
summary: Cuenca common validations
url: https://github.com/cuenca-mx/cuenca-validations
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuenca-validations-0.11.33-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/cuenca-mx/cuenca-validations/workflows/test/badge.svg)](https://github.com/cuenca-mx/cuenca-validations/actions?query=workflow%3Atest)
  [![codecov](https://codecov.io/gh/cuenca-mx/cuenca-validations/branch/master/graph/badge.svg)](https://codecov.io/gh/cuenca-mx/cuenca-validations)
  [![PyPI](https://img.shields.io/pypi/v/cuenca-validations.svg)](https://pypi.org/project/cuenca-validations/)

  Shared validations library across multiple Cuenca projects


pkgId: a84ccda63fdd1853187baed6ad527122be4f8e7757b3ec5a6630c62d45fbf623
name: python-cuid
arch: src
version: 0.4
epoch: 0
release: 1
summary: Fast, scalable unique ID generation
url: http://github.com/necaris/cuid.py
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuid-0.4-1.src.rpm
checksum_type: sha256
description:
  Implementation of https://github.com/ericelliott/cuid in Python.

  A `cuid` is a portable and sequentially-ordered unique identifier designed for
  horizontal scalability and speed -- this version is ported from the reference
  implementation in Javascript.

  **NOTE**: Particularly if you have security concerns, the [`cuid` standard has been deprecated in favor of `cuid2`](https://github.com/paralleldrive/cuid2)!

  Tested on CPython 2.7, 3.6-3.11 as well as PyPy & PyPy3.

  Rough benchmarks on my machine (i7-8750H CPU @ 2.20GHz) using `setup.py bench`
  (which times the creation of 1 million `cuid`s):

  | Version                    | ns / cuid |
  | -------------------------- | --------- |
  | CPython 3.7.3              | 6095.257  |
  | CPython 3.6.8              | 6846.050  |
  | CPython 3.5.6              | 6604.012  |
  | CPython 2.7.16             | 6913.681  |
  | PyPy 7.1.1 (Python 2.7.13) | 326.344   |
  | PyPy3 7.1.1 (Python 3.6.1) | 562.673   |

  _(Note that timing the creation of fewer IDs changes the way PyPy runs the code, because of JIT warmup --
  obviously creating this many IDs takes advantage of the warmed JIT)_

  For now, this has no dependencies outside the standard library -- in time this may change,
  to provide better random numbers and / or performance.


pkgId: c3b0467acfd3d3d37f7c68e882fc0f695b8459dd078c106d8b73eef6c952c965
name: python-culligan
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Python API for Culligan products
url: https://github.com/rewardone/culligan
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-culligan-1.1.1-1.src.rpm
checksum_type: sha256
description:
  A discovery for Culligan smart water products


  The Excel sheet contains a listing of endpoints and what is needed for interaction with the Aylanetworks API. This data was gathered from proxy traffic.

  The powershell module is a way to interact with the endpoints via Powershell.

  The python code is for packageability and publishing to PyPi as a module.

  The softener does have an http webpage for wifi status and connect/disconnect.
  Local control of the device does not seem possible without understanding how Ayla sends commands to the device.


  This device is integrated by/with Ayla Networks and (generally) uses their documentation.

  See [Ayla-iot-unofficial](https://github.com/rewardone/ayla-iot-unofficial)


  Direct doc linked from the reference above: [salesforce doc](https://ayla.my.salesforce.com/sfc/p/#F00000005wvT/a/2A000000ZKSc/k2aXubMGof8Gooqm.nGLRqd.vyluxZLK9Qwe9xWUphQ)



  From PyPi
  ```bash
  pip install culligan
  ```

  Build from source
  ```bash
  pip install build
  pip build
  pip install culligan
  ```


  Requires typical http interaction and datatype packages like requests, aiohttp, ujson, and the ayla-iot-unofficial module to handle devices and communication.


  Reqiures a username and password (typically a smart device's app login credentials).
  The Culligan specific app_id is included in the package (obtained from the Culligan app).



  Instantiate a new class object through new_culligan_api() or Culligan() directly.



  The Culligan() object will call sign_in() automatically to obtain Culligan IoT and Ayla access_tokens.
  Then, it will instantiate an AylaApi() object with the Ayla access_token (no sign_in() required).

  Use Culligan for communication with the Culligan IoT domain.
  Use the Ayla property of the Culligan object for direct communication with Ayla Networks.


  Gather devices by calling the Ayla.get_devices().

  By default, calling get_devices() will return a list of class specific device objects with updated properties for use.

  See ayla-iot-unofficial/device.py for implemented device classes.


  ```python
  python3 -m pip install Culligan
  ```

  ```python
  import Culligan

  USERNAME = 'me@email.com'
  PASSWORD = '$7r0nkP@s$w0rD'

  CulliganApi = new_culligan_api(username, password)
  CulliganApi.sign_in()
  CulliganApi.Ayla = CulliganApi.get_ayla_api()

  device_list = CulliganApi.Ayla.list_devices()
  devices = CulliganApi.Ayla.get_devices()


  softener = devices[0]

  softener.capacity_remaining_gallons
  softener.set_vacation_mode()
  ```


  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: aee31fa7da0d73bd1c370662fd7fc99ca30cb2f4f861367be5886b3aa426cc56
name: python-culsans
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Thread-safe async-aware queue for Python
url: https://pypi.org/project/culsans/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-culsans-0.4.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright 2024 Ilya Egorov <0x42005e1f@gmail.com>.  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 35eb6bb5fd959ddc35c9ccbdfcc6e3bb5569923bda2dbd31211d0c59406c533e
name: python-cult-cargo
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Curated cargo of standard radio astronomy packages for stimela 2.0
url: https://pypi.org/project/cult-cargo/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cult-cargo-0.1.3-1.src.rpm
checksum_type: sha256
description:
  Curated Stimela2 cargo for popular radio astronomy software.



  ```
  pip install cult-cargo
  ```

  This installs both cult-cargo and the required version of stimela.



  To work off the repo versions:

  ```

  $ pip install -U pip
  $ gh repo clone caracal-pipeline/stimela
  $ gh repo clone caracal-pipeline/cult-cargo
  $ pip install -e stimela
  $ pip install -e cult-cargo
  ```



  ```yml

  _include:
    - (cultcargo)wsclean.yml

  dummy-recipe:
    info: a dummy recipe
    steps:
      image:
        cab: wsclean
  ```



  ```
  $ poetry install --with builder
  ```

  This makes the ``build-cargo.py`` script available. The script is preconfigured to read ``cultcargo/builder/cargo-manifest.yml``, which describes the images that must be built.

  ``build-cargo.py -a`` will build and push all images, or specify an image name to build a particular one. Use ``-b`` to build but not push, or ``-p`` for push-only. Use ``-l`` to list available images.

  The ``cultcargo`` folder contains YaML files with cab definitions.

  If you would like to maintain your own image collection, write your own manifest and Dockerfiles following the cult-cargo example, and use the ``build-cargo.py`` script to build your images.



  You don't even need to run stimela (or indeed install anything) to take advantage of the images packaged with cult-cargo. Take a look at the image repository on https://quay.io/organization/stimela2 to see what's available.

  For example, if you want to run a wsclean image, just do:

  ```
  $ singularity build wsclean-3.3.sif docker:quay.io/stimela2/wsclean:3.3-cc0.1.2
  $ singularity exec wsclean-3.3.sif wsclean
  ```


pkgId: 3e577a439adccb8e23c0e6815262c81b92da5db0c94d3ff60bef405675ac3d1a
name: python-cumo
arch: src
version: 0.33.7
epoch: 0
release: 1
summary: Webブラウザ上に点群を描画する python ライブラリ
url: https://github.com/kurusugawa-computer/cumo
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumo-0.33.7-1.src.rpm
checksum_type: sha256
description:
  cumoは、Pythonから3D点群をブラウザ上で表示するためのライブラリです。



  ```console
  $ pip install cumo
  ```



  sphinxでドキュメントの生成が可能です。
  devcontainer環境を使用することで、ビルド環境を構築することができます。
  その中で以下のようにすると、`lib/docs/`以下にドキュメントが生成されます。

  ```console
  $ cd lib
  $ poetry install
  $ poetry run sphinx-apidoc --append-syspath -F -o ./docs .
  ```



  `lib/cumo/__main__.py`は3面図を撮る例です。
  `lib/`以下に適当なPCDファイル(以下の例では`pcl_logo.pcd`)を用意して、以下のようにするとpcdファイルを閲覧できます。

  ```console
  $ cd lib
  $ poetry run python -m cumo pcl_logo.pcd
  open: http://127.0.0.1:8082
  setup...
  resize window and press custom control button "start"
  saved: screenshot_x.png
  saved: screenshot_y.png
  saved: screenshot_z.png
  ```

  REPLでの使用も可能です。

  ```console
  $ poetry run python
  Python 3.8.7 (default, Apr  9 2022, 21:34:33)
  [GCC 9.4.0] on linux
  Type "help", "copyright", "credits" or "license" for more information.
  >>> from cumo import PointCloudViewer
  >>> viewer = PointCloudViewer()
  >>> viewer.start()
  >>> # open localhost:8082 on your browser
  >>> with open(filename, "rb") as f:
  >>>     b = f.read()
  >>>     viewer.send_pointcloud_pcd(b)
  ```





  cumoは以下のように、大まかに2つの要素からなります。

  - `lib/` : Pythonライブラリ。PointCloudViewerクラスを提供する。クライアントのHTMLを配信し、クライアントとWebSocket通信を行う。
  - `client/` : クライアントページ。ライブラリとWebSocket通信を行い、ライブラリからの操作を受け付ける。

  これら2つの通信はWebSocketを使用しています。
  通信データはProtocol Buffersにより定義されており、それぞれで使われている言語のライブラリが自動で生成されます。

  - `protobuf/server.proto`: ライブラリからクライアントへ送信されるデータ
  - `protobuf/client.proto`: クライアントからライブラリへ送信されるデータ



  devcontainerを使用することで、ビルド環境を構築することができます。
  devcontainer環境に入り、下のようにすると`lib/dist/`以下にtar.gzとwhlファイルが生成されます。
  クライアントのHTML等はライブラリに含まれ、tar.gzやwhlファイルの中に格納されます。

  ```console
  $ ./build.sh
  ```



  以下のようにするとテスト用のモードでクライアントページを配信することができます。

  ```console
  $ cd client
  $ yarn serve
  ```

  上のようにしてクライアントを配信するサーバを起動した後、ブラウザでクライアントを開きます(大抵の場合自動で開かれます)。
  クライアントを開いた後、ライブラリ側を起動するとクライアント側に接続されます。

  ```console
  $ cd lib
  $ poetry run python -m cumo pcl_logo.pcd
  ```


pkgId: afa5693bfa2e8e76a47942e4568648964e08347984e7b4b88bb34067c3b3d1f4
name: python-cumo
arch: src
version: 0.34.1
epoch: 0
release: 1
summary: Webブラウザ上に点群を描画する python ライブラリ
url: https://github.com/kurusugawa-computer/cumo
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumo-0.34.1-1.src.rpm
checksum_type: sha256
description:
  cumoは、Pythonから3D点群をブラウザ上で表示するためのライブラリです。



  ```console
  $ pip install cumo
  ```



  sphinxでドキュメントの生成が可能です。
  devcontainer環境を使用することで、ビルド環境を構築することができます。
  その中で以下のようにすると、`lib/docs/`以下にドキュメントが生成されます。

  ```console
  $ make docs
  ```

  また、`serve-docs`ターゲットを実行するとPythonのサーバーが起動し、`http://localhost:8000`でドキュメントを閲覧できます。

  ```console
  $ make serve-docs
  ```



  `lib/cumo/__main__.py`は3面図を撮る例です。
  `lib/`以下に適当なPCDファイル(以下の例では`sample_data.pcd`)を用意して、以下のようにするとpcdファイルを閲覧できます。

  ```console
  $ cd lib
  $ poetry run python -m cumo sample_data.pcd
  open: http://127.0.0.1:8082
  setup...
  resize window and press custom control button "start"
  saved: screenshot_x.png
  saved: screenshot_y.png
  saved: screenshot_z.png
  ```

  REPLでの使用も可能です。

  ```console
  $ poetry run python
  Python 3.8.7 (default, Apr  9 2022, 21:34:33)
  [GCC 9.4.0] on linux
  Type "help", "copyright", "credits" or "license" for more information.
  >>> from cumo import PointCloudViewer
  >>> viewer = PointCloudViewer()
  >>> viewer.start()
  >>> # open localhost:8082 on your browser
  >>> with open("sample_data.pcd", "rb") as f:
  >>>     b = f.read()
  >>>     viewer.send_pointcloud_pcd(b)
  ```





  cumoは以下のように、大まかに2つの要素からなります。

  - `lib/` : Pythonライブラリ。PointCloudViewerクラスを提供する。クライアントのHTMLを配信し、クライアントとWebSocket通信を行う。
  - `client/` : クライアントページ。ライブラリとWebSocket通信を行い、ライブラリからの操作を受け付ける。

  これら2つの通信はWebSocketを使用しています。
  通信データはProtocol Buffersにより定義されており、それぞれで使われている言語のライブラリが自動で生成されます。

  - `protobuf/server.proto`: ライブラリからクライアントへ送信されるデータ
  - `protobuf/client.proto`: クライアントからライブラリへ送信されるデータ



  devcontainerを使用することで、ビルド環境を構築することができます。
  devcontainer環境に入り、下のようにすると`lib/dist/`以下にtar.gzとwhlファイルが生成されます。
  クライアントのHTML等はライブラリに含まれ、tar.gzやwhlファイルの中に格納されます。

  ```console
  $ make
  ```



  `make` (または`make all`)を実行していれば、サンプル用のpcdファイル`sample_data.pcd`が`lib/`以下に生成されています。

  以下のようにするとテスト用のモードでクライアントページを配信することができます。

  ```console
  $ make serve
  ```

  上のようにしてクライアントを配信するサーバを起動した後、ブラウザでクライアントを開きます(大抵の場合自動で開かれます)。
  別のターミナルでライブラリ側を起動するとクライアント側に接続されます。

  ```console
  $ cd lib
  $ poetry run python -m cumo sample_data.pcd
  ```


pkgId: 90103d32cb0843c2dfcbe2c76c1d15f5f13fb592d00d6343feb81eb3dfc70523
name: python-cumulio
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: [DEPRECATED - use luzmo-sdk instead] Cumulio Python SDK for the Core API
url: https://github.com/luzmo-official/luzmo-sdk-python/blob/deprecate-cumulio/README.md
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulio-0.2.5-1.src.rpm
checksum_type: sha256
description:
  The library had been replaced by `luzmo-sdk`. You can find the new package on the GitHub repo [luzmo-official/luzmo-sdk-python](https://github.com/luzmo-official/luzmo-sdk-python).



  You will need `Python Version >= 3.6`

  ```console
  pip install cumulio
  ```



  For detailed documentation, please visit the [Cumul.io Developer Docs](https://developer.cumul.io/)



  Create a Cumul.io dataset:

  ```console
  from cumulio.cumulio import Cumulio

  key = "Your Cumul.io key"
  token = "Your Cumul.io token"

  client = Cumulio(key, token)
  dataset = client.create("securable", {"type": "dataset", "name" : {"en":"Example with python sdk"}})
  client.update("securable", dataset[" "], {"description":{"en":"This is an example description"}})
  ```

  Optionally for people working with VPC or on our US multitenant environment, you can also define an api_host while creating the client. If not it will default to "https://api.cumul.io"

  E.g.:

  ```console
  client = Cumulio(key, token, "https://api.us.cumul.io")
  ```

  There is also the option of adding a dictionary of proxies while creating the API client.

  Update description of dataset:

  ```console
  client.update("securable", dataset["id"], {"description":{"en":"Joost edited"}})
  ```

  Create a column in the dataset:

  ```console
  burrito_column = client.create('column', { "type": 'hierarchy', "format": '',"informat": 'hierarchy', "order": 0,"name": {"nl": 'Type burrito'}})
  client.associate("securable", dataset["id"], "Columns", burrito_column["id"])
  ```

  Add Values to the column:

  ```console
  client.create("data", dataset["id"], {"securable_id": dataset["id"],"type": "append", "data": [["sweet"], ["sour"]]})
  ```

  Replace Values in the column:

  ```console
  client.create("data", {"securable_id": dataset["id"],"type": "replace", "data": [["bitter"], ["salty"]]})
  ```



  The API documentation (available services and methods) can be found at https://developer.cumul.io


pkgId: 4a7fcbcd274dfce22ef64479b08d918c18f4780ba613dcae5e6300b3643ffdbe
name: python-cumulus-library
arch: src
version: 3.0.0
epoch: 0
release: 1
summary: Clinical study SQL generation for data derived from bulk FHIR
url: https://pypi.org/project/cumulus-library/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulus-library-3.0.0-1.src.rpm
checksum_type: sha256
description:
  A framework for designing, executing, and distributing SQL queries packaged as "studies", e.g., for quality monitoring, clinical research, or public health. Part of the [SMART on FHIR Cumulus Project](https://smarthealthit.org/cumulus-a-universal-sidecar-for-a-smart-learning-healthcare-system/)



  For end users, just run `pip install cumulus-library`.
  For running from source, checkout the repo, and at the project root run `pip install -e .`. If you're not working on new features, you should check out the tag associated with the latest release.

  For more information, [browse the documentation](https://docs.smarthealthit.org/cumulus/library).


pkgId: 1d106e631aefe84c58adfea21ce99e32ea8348b76b327b9e156bf290333ec339
name: python-cumulus-library
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Clinical study SQL generation for data derived from bulk FHIR
url: https://pypi.org/project/cumulus-library/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulus-library-4.0.0-1.src.rpm
checksum_type: sha256
description:
  A framework for designing, executing, and distributing SQL queries packaged as "studies", e.g., for quality monitoring, clinical research, or public health. Part of the [SMART on FHIR Cumulus Project](https://smarthealthit.org/cumulus/)



  For end users, just run `pip install cumulus-library`.
  For running from source, checkout the repo, and at the project root run `pip install -e .`. If you're not working on new features, you should check out the tag associated with the latest release.

  For more information, [browse the documentation](https://docs.smarthealthit.org/cumulus/library).


pkgId: 01f171333d46c8ed75f352b8e7d5e59c932e7e242d57ebea5646f420cca600cc
name: python-cumulus-library-data-metrics
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Data quality and characterization metrics for Cumulus
url: https://pypi.org/project/cumulus-library-data-metrics/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulus-library-data-metrics-6.0.0-1.src.rpm
checksum_type: sha256
description:
  A Cumulus-based implementation of the [qualifier metrics](https://github.com/sync-for-science/qualifier/blob/master/metrics.md).



  The following qualifier metrics are implemented (per June 2024 qualifer definitions).

  - [c_pt_count](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#c_pt_count)
  - [c_pt_deceased_count](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#c_pt_deceased_count)
  - [c_resource_count](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#c_resource_count)
  - [c_resources_per_pt](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#c_resources_per_pt)
  - [c_system_use](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#c_system_use)
  - [c_us_core_v4_count](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#c_us_core_v4_count) *
  - [q_date_recent](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#q_date_recent)
  - [q_ref_target_pop](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#q_ref_target_pop)
  - [q_ref_target_valid](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#q_ref_target_valid)
  - [q_system_use](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#q_system_use)
  - [q_valid_us_core_v4](https://github.com/sync-for-science/qualifier/blob/master/metrics.md#q_valid_us_core_v4) *

  \* These are US Core profile-based metrics, and the following profiles are not yet implemented:
    - Implantable Device (due to the difficulty in identify implantable records)
    - The various Vital Signs sub-profiles like Blood Pressure (just haven't gotten around to them yet)



  ```sh
  pip install cumulus-library-data-metrics
  ```



  These metrics are designed as a
  [Cumulus Library](https://docs.smarthealthit.org/cumulus/library/)
  study and are run using the `cumulus-library` command.


  First, you'll want to organize your ndjson into the following file tree format:
  ```
  root/
    condition/
      my-conditions.ndjson
    medicationrequest/
      1.ndjson
      2.ndjson
    patient/
      Patient.ndjson
  ```
  (This is the same format that Cumulus ETL writes out when using `--output-format=ndjson`.)

  Here's a sample command to run against that pile of ndjson data:
  ```sh
  cumulus-library build \
    --db-type duckdb \
    --database output-tables.db \
    --load-ndjson-dir path/to/ndjson/root \
    --target data_metrics
  ```

  And then you can load `output-tables.db` in a DuckDB session and see the results.
  Or read below to export the counts tables.


  Here's a sample command to run against your Cumulus data in Athena:
  ```sh
  cumulus-library build \
    --database your-glue-database \
    --workgroup your-athena-workgroup \
    --profile your-aws-credentials-profile \
    --target data_metrics
  ```

  And then you can see the resulting tables in Athena.
  Or read below to export the counts tables.



  For the metrics that have exportable counts (the characterization metrics mostly),
  you can easily export those using Cumulus Library,
  by replacing `build` in the above commands with `export ./output-folder`.
  Like so:

  ```sh
  cumulus-library export \
    ./output-folder \
    --db-type duckdb \
    --database output-tables.db \
    --target data_metrics
  ```



  This study generates `CUBE` output by default.
  If it's easier to work with simple aggregate counts of every value combination
  (that is, without the partial value combinations that `CUBE()` generates),
  run the build step with `--option output-mode:aggregate`.

  That is, run it like:
  ```sh
  cumulus-library build --option output-mode:aggregate ...
  ```


pkgId: ee856df8fef8592833df2e72ec89862f07bf6383cca389bcbd3585c760e91d84
name: python-cumulus-message-adapter
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A command-line interface for preparing and outputting Cumulus Messages for Cumulus Tasks
url: https://github.com/nasa/cumulus-message-adapter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulus-message-adapter-2.0.4-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI](https://circleci.com/gh/nasa/cumulus-message-adapter.svg?style=svg)](https://circleci.com/gh/nasa/cumulus-message-adapter)

  `cumulus-message-adapter` is a command-line interface for preparing and outputting Cumulus Messages for Cumulus Tasks. `cumulus-message-adapter` helps Cumulus developers integrate a task into a Cumulus Workflow.

  Read more about how the `cumulus-message-adapter` works in the [CONTRACT.md](./CONTRACT.md).





  Please note the following convention for release versions:

  X.Y.Z: where:

  * X is an organizational release that signifies the completion of a core set of functionality
  * Y is a major version release that may include incompatible API changes and/or other breaking changes
  * Z is a minor version that includes bugfixes and backwards compatible improvements



  [CircleCI](https://circleci.com/gh/nasa/cumulus-message-adapter) manages releases and release assets.

  Whenever CircleCI passes on the master branch of cumulus-message-adapter and `message_adapter/version.py` has been updated with a version that doesn't match an existing tag, CircleCI will:

  * Create a new tag with `tag_name` of the string in `message_adapter/version.py`
  * Create a new release using the new tag, with a name equal to `tag_name` (equal to version).
  * Build a `cumulus-message-adapter.zip` file and attach it as a release asset to the newly created release. The zip file is created using the [`Makefile`](./Makefile) in the root of this repository.

  These steps are fully detailed in the [`.circleci/config.yml`](./.circleci/config.yml) file.





  ```shell
  pip install -r requirements-dev.txt
  pip install -r requirements.txt
  ```



  Running tests requires [localstack](https://github.com/localstack/localstack).

  Tests only require localstack running S3, which can be initiated with the following command:

  ```shell
  EAGER_SERVICE_LOADING=1 SERVICES=s3 localstack start
  ```

  And then you can check tests pass with the following nosetests command:

  ```shell
  CUMULUS_ENV=testing nose2 -v
  ```



  ```shell
  pylint message_adapter
  ```



  If changes are made to the codebase, you can create the cumulus-message-adapter zip archive for testing libraries that require it:

  ```shell
  make clean
  make cumulus-message-adapter.zip
  ```

  Then you can run some integration tests:

  ```shell
  ./examples/example-node-message-adapter-lib.js
  ```

  Before any changes are finalized and released, they should be tested by packaging the cumulus-message-adapter zip archive and testing it in a lambda environment, as that is where it will be utilized.



  Packaging the zip file is probably best done in an environment that closely matches the lambda environment in which it will be run and contains the current Python version, so we are using an AWS Python Lambda image. Certain packages need to be installed, and using a virtual environment is important due to Python pathing.

  ```shell
  docker run -v ~/projects/cumulus-message-adapter/:/cma/ -v ~/tmp/:/tmp/ -v ~/amazon/:/home/amazon/ -it --entrypoint /bin/bash amazon/aws-lambda-python:3.10
  yum install -y make binutils zip
  cd /cma
  pip install --user virtualenv
  ~/.local/bin/virtualenv ~/venv310
  . ~/venv310/bin/activate
  pip install .
  make clean
  make cumulus-message-adapter.zip
  ```



  Once the package is created, it should be tested in a Lambda environment. Before doing so, it may be helpful to run the package in the container it was packaged in, immediately after the above commands to see if any errors occur, which will indicate an issue in creating the package `./dist/cma stream`.

  If no errors occur immediately, you can optionally test the zip in an AWS Lambda NodeJS image, as that is the target environment. Running in an image may allow for quicker testing and development, but testing in AWS should still be the final test.

  ```shell
  docker run -v ~/projects/cumulus-message-adapter:/zipfile --entrypoint /
  bin/bash -it amazon/aws-lambda-nodejs:16
  cd /zipfile
  cp -r dist /opt/
  cd /opt/dist
  ./cma stream
  ```

  Testing the package in AWS Lambda requires uploading the zip as a layer and then running a Cumulus step function that utilizes that layer. The following instructions are for Cumulus Core team members that have access to a layer specifically set up for this purpose.

  * In the AWS console, go to Lambda > Layers > CMA_Test
  * Create a new version by uploading the cumulus-message-adapater zip file packaged earlier
  * In your /cumulus-tf/terraform.tfvars, replace the `cumulus_message_adapter_lambda_layer_version_arn` value with the newly created Version ARN
  * Apply the change with `terraform apply`
  * Find any recent successfully run Step Function, and run a New Execution. The 'Functions using this version' tab of the CMA_TEST layer should provide some options.



  * Error: "DistutilsOptionError: must supply either home or prefix/exec-prefix — not both" when running `make cumulus-message-adapter.zip`
    * [Solution](https://stackoverflow.com/a/24357384)


pkgId: d434c297fddfdda22f2648c3cd44b52cf458ec36ef8013552a816afdc0d2986b
name: python-cumulus-message-adapter-python
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: A handler library for cumulus tasks written in python
url: https://github.com/cumulus-nasa/cumulus-message-adapter-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulus-message-adapter-python-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![CircleCI]](https://circleci.com/gh/nasa/cumulus-message-adapter-python)
  [![PyPI version]](https://badge.fury.io/py/cumulus-message-adapter-python)



  Cumulus is a cloud-based data ingest, archive, distribution and management
  prototype for NASA's future Earth science data streams.

  Read the [Cumulus Documentation]



  The Cumulus Message Adapter is a library that adapts incoming messages in the
  Cumulus protocol to a format more easily consumable by Cumulus tasks, invokes
  the tasks, and then adapts their response back to the Cumulus message protocol
  to be sent to the next task.



  ```plain
  pip install cumulus-message-adapter-python
  ```



  In order to use the Cumulus Message Adapter, you will need to create two
  methods in your task module: a handler function and a business logic function.

  The handler function is a standard Lambda handler function which takes two
  parameters (as specified by AWS): `event` and `context`.

  The business logic function is where the actual work of your task occurs. It
  should take two parameters: `event` and `context`.

  The `event` object contains two keys:

  * `input` - the task's input, typically the `payload` of the message, produced
    at runtime
  * `config` - the task's configuration, with any templated variables resolved

  The `context` parameter is the standard Lambda context as passed by AWS.

  The return value of the business logic function will be placed in the
  `payload` of the resulting Cumulus message.

  Expectations for input, config, and return values are all defined by the task,
  and should be well documented. Tasks should thoughtfully consider their inputs
  and return values, as breaking changes may have cascading effects on tasks
  throughout a workflow. Configuration changes are slightly less impactful, but
  must be communicated to those using the task.



  The Cumulus Message adapter for python provides one method:
  `run_cumulus_task`. It takes four parameters:

  * `task_function` - the function containing your business logic (as described
    above)
  * `cumulus_message` - the event passed by Lambda, and should be a Cumulus
    Message, *or* a CMA parameter encapsulated message (see [Cumulus Workflow
    Documentation](https://nasa.github.io/cumulus/docs/workflows/input_output)):

    ```json
    {
       "cma": {
          "event": "<cumulus message object>",
          "SomeCMAConfigKey": "CMA configuration object>"
       }
    }
    ```

  * `context` - the Lambda context
  * `schemas` - optional: a dict with `input`, `config`, and `output` properties.
    Each should be a string set to the filepath of the corresponding JSON schema
    file. All three properties of this dict are optional. If ommitted, the message
    adapter will look in `/<task_root>/schemas/<schema_type>.json`, and if not
    found there, will be ignored.
  * `taskargs` - Optional. Additional keyword arguments for the `task_function`



  Simple example of using this package's `run_cumulus_task` function as a wrapper
  around another function:

  ```python
  >>> from run_cumulus_task import run_cumulus_task


  >>> def task(event, context):
  ...     return event


  >>> def handler(event, context):
  ...     return run_cumulus_task(task, event, context)

  ```

  For a full example see the [example folder](./example).



  Tasks that use this library are just standard AWS Lambda tasks. See
  [creating release packages].



  For documenation on how to utilize this package in a Cumulus Deployment, view
  the [Cumulus Workflow Documenation].





  ```plain
  $ pip install -r requirements-dev.txt
  $ pip install -r requirements.txt
  ```



  Included in this package is the `cumulus_logger` which contains a logging class
  `CumulusLogger` that standardizes the log format for Cumulus. Methods are
  provided to log error, fatal, warning, debug, info, and trace.

  **Import the `CumulusLogger` class:**

  ```python
  >>> from cumulus_logger import CumulusLogger

  ```

  **Instantiate the logger inside the task definition (name and level are
  optional):**

  ```python
  >>> import logging
  >>> logger = CumulusLogger("event_name", logging.ERROR)

  ```

  **Use the logging methods for different levels:**

  ```python
  >>> logger.trace('<your message>')

  >>> logger.debug('<your message>')

  >>> logger.info('<your message>')

  >>> logger.warn('<your message>')

  >>> logger.error('<your message>')

  >>> logger.fatal('<your message>')

  ```

  **It can also take additional non-keyword and keyword arguments as in Python
  Logger.**

  The `msg` is the message format string, the `args` and `kwargs` are the
  arguments for string formatting.

  If `exc_info` in `kwargs` is not `False`, the exception information in the
  `exc_info` or `sys.exc_info()` is added to the message.

  ```python
  >>> logger.debug(msg, *args, **kwargs)

  ```

  **Example usage:**

  ```python
  >>> import os
  >>> import sys

  >>> from run_cumulus_task import run_cumulus_task
  >>> from cumulus_logger import CumulusLogger


  >>> logger = CumulusLogger()

  >>> def task(event, context):
  ...     logger.info('task executed')
  ...
  ...     # log error when an exception is caught
  ...     logger.error("task formatted message {} exc_info ", "bar", exc_info=True)
  ...
  ...     # return the output of the task
  ...     return { "example": "output" }

  >>> def handler(event, context):
  ...     # make sure event & context metadata is set in the logger
  ...     logger.setMetadata(event, context)
  ...     return run_cumulus_task(task, event, context)

  ```



  Running tests requires [localstack](https://github.com/localstack/localstack).

  Tests only require localstack running S3, which can be initiated with the
  following command:

  ```plain
  $ SERVICES=s3 localstack start
  ```

  And then you can check tests pass with the following nosetests command:

  ```plain
  $ CUMULUS_ENV=testing nose2
  ```



  ```plain
  $ pylint run_cumulus_task.py
  ```



  This approach has a few major advantages:

  1. It explicitly prevents tasks from making assumptions about data structures
     like `meta` and `cumulus_meta` that are owned internally and may therefore
     be broken in future updates. To gain access to fields in these structures,
     tasks must be passed the data explicitly in the workflow configuration.
  1. It provides clearer ownership of the various data structures. Operators own
     `meta`. Cumulus owns `cumulus_meta`. Tasks define their own `config`,
     `input`, and `output` formats.
  1. The Cumulus Message Adapter greatly simplifies running Lambda functions not
     explicitly created for Cumulus.
  1. The approach greatly simplifies testing for tasks, as tasks don't need to
     set up cumbersome structures to emulate the message protocol and can just
     test their business function.



  [Apache 2.0](LICENSE)

  [circleci]:
    https://circleci.com/gh/nasa/cumulus-message-adapter-python.svg?style=svg
  [pypi version]:
    https://badge.fury.io/py/cumulus-message-adapter-python.svg
  [Cumulus Documentation]:
    https://nasa.github.io/cumulus/
  [creating release packages]:
    https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html
  [cumulus workflow documenation]:
    https://nasa.github.io/cumulus/docs/workflows/input_output


pkgId: d8a7189dea7de910fb5a680ef35b0facb364bf336cde1ad14ffa85bcf4cea31e
name: python-cumulusci
arch: src
version: 3.92.0
epoch: 0
release: 1
summary: Build and release tools for Salesforce developers
url: https://github.com/SFDO-Tooling/CumulusCI
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulusci-3.92.0-1.src.rpm
checksum_type: sha256
description:
  [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
  [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cumulusci)
  ![PyPI - License](https://img.shields.io/pypi/l/cumulusci)
  [![Documentation Status](https://readthedocs.org/projects/cumulusci/badge/?version=latest)](https://cumulusci.readthedocs.io/en/latest/?badge=latest)

  CumulusCI helps build great applications on the Salesforce platform by
  automating org setup, testing, and deployment for everyone --- from
  developers and admins to testers and product managers.

  **Best practices, proven at scale.** CumulusCI provides a complete
  development and release process created by Salesforce.org to build and
  release applications to thousands of users on the Salesforce platform.
  It\'s easy to start new projects with a standard set of tasks (single
  actions) and flows (sequences of tasks), or customize by adding your
  own.

  **Batteries included.** Out-of-the-box features help you quickly:

  -   Build sophisticated orgs with automatic installation of
      dependencies.
  -   Load and capture sample datasets to make your orgs feel real.
  -   Apply transformations to existing metadata to tailor orgs to your
      specific requirements.
  -   Run builds in continuous integration systems.
  -   Create end-to-end browser tests and setup automation using [Robot
      Framework](https://cumulusci.readthedocs.io/en/latest/robotframework.html).
  -   Generate synthetic data on any scale, from a single record to a
      million, using
      [Snowfakery](https://cumulusci.readthedocs.io/en/latest/cookbook.html#large-volume-data-synthesis-with-snowfakery).

  **Build anywhere.** Automation defined using CumulusCI is portable. It
  is stored in a source repository and can be run from your local command
  line, from a continuous integration system, or from a customer-facing
  MetaDeploy installer. CumulusCI can run automation on scratch orgs
  created using the Salesforce CLI, or on persistent orgs like sandboxes,
  production orgs, and Developer Edition orgs.



  For a tutorial introduction to CumulusCI, complete the [Build
  Applications with
  CumulusCI](https://trailhead.salesforce.com/en/content/learn/trails/build-applications-with-cumulusci)
  trail on Trailhead.

  To go in depth, read the [full
  documentation](https://cumulusci.readthedocs.io/en/latest/).

  If you just want a quick intro, watch [these screencast
  demos](https://cumulusci.readthedocs.io/en/latest/demos.html) of using
  CumulusCI to configure a Salesforce project from a GitHub repository.

  For a live demo with voiceover, please see Jason Lantz\'s [PyCon 2020
  presentation](https://www.youtube.com/watch?v=XL77lRTVF3g) from minute
  36 through minute 54.



  Ask in the [CumulusCI (CCI) group in the Trailblazer
  Community](https://success.salesforce.com/_ui/core/chatter/groups/GroupProfilePage?g=0F9300000009M9ZCAU).

  _Please note:_ CumulusCI is distributed under an [open source
  license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
  and is not covered by the Salesforce Master Subscription Agreement.

  <!-- Changelog -->


  <!-- Release notes generated using configuration in .github/release.yml at main -->





  -   fix: Update input handlers with new Salesforce lightning-primitive tags by [@chanyahn-st](https://github.com/chanyahn-st) in [#3822](https://github.com/SFDO-Tooling/CumulusCI/pull/3822)



  -   @chanyahn-st made their first contribution in [#3822](https://github.com/SFDO-Tooling/CumulusCI/pull/3822)

  **Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v3.91.0...v3.92.0


pkgId: cec19abcbbe42411eee36a406f7b101eb5da872f376a9e69c709ff31c2140cbd
name: python-cumulusci
arch: src
version: 3.93.0
epoch: 0
release: 1
summary: Build and release tools for Salesforce developers
url: https://github.com/SFDO-Tooling/CumulusCI
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulusci-3.93.0-1.src.rpm
checksum_type: sha256
description:
  [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
  [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cumulusci)
  ![PyPI - License](https://img.shields.io/pypi/l/cumulusci)
  [![Documentation Status](https://readthedocs.org/projects/cumulusci/badge/?version=latest)](https://cumulusci.readthedocs.io/en/latest/?badge=latest)

  CumulusCI helps build great applications on the Salesforce platform by
  automating org setup, testing, and deployment for everyone --- from
  developers and admins to testers and product managers.

  **Best practices, proven at scale.** CumulusCI provides a complete
  development and release process created by Salesforce.org to build and
  release applications to thousands of users on the Salesforce platform.
  It\'s easy to start new projects with a standard set of tasks (single
  actions) and flows (sequences of tasks), or customize by adding your
  own.

  **Batteries included.** Out-of-the-box features help you quickly:

  -   Build sophisticated orgs with automatic installation of
      dependencies.
  -   Load and capture sample datasets to make your orgs feel real.
  -   Apply transformations to existing metadata to tailor orgs to your
      specific requirements.
  -   Run builds in continuous integration systems.
  -   Create end-to-end browser tests and setup automation using [Robot
      Framework](https://cumulusci.readthedocs.io/en/latest/robotframework.html).
  -   Generate synthetic data on any scale, from a single record to a
      million, using
      [Snowfakery](https://cumulusci.readthedocs.io/en/latest/cookbook.html#large-volume-data-synthesis-with-snowfakery).

  **Build anywhere.** Automation defined using CumulusCI is portable. It
  is stored in a source repository and can be run from your local command
  line, from a continuous integration system, or from a customer-facing
  MetaDeploy installer. CumulusCI can run automation on scratch orgs
  created using the Salesforce CLI, or on persistent orgs like sandboxes,
  production orgs, and Developer Edition orgs.



  For a tutorial introduction to CumulusCI, complete the [Build
  Applications with
  CumulusCI](https://trailhead.salesforce.com/en/content/learn/trails/build-applications-with-cumulusci)
  trail on Trailhead.

  To go in depth, read the [full
  documentation](https://cumulusci.readthedocs.io/en/latest/).

  If you just want a quick intro, watch [these screencast
  demos](https://cumulusci.readthedocs.io/en/latest/demos.html) of using
  CumulusCI to configure a Salesforce project from a GitHub repository.

  For a live demo with voiceover, please see Jason Lantz\'s [PyCon 2020
  presentation](https://www.youtube.com/watch?v=XL77lRTVF3g) from minute
  36 through minute 54.



  Ask in the [CumulusCI (CCI) group in the Trailblazer
  Community](https://success.salesforce.com/_ui/core/chatter/groups/GroupProfilePage?g=0F9300000009M9ZCAU).

  _Please note:_ CumulusCI is distributed under an [open source
  license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
  and is not covered by the Salesforce Master Subscription Agreement.

  <!-- Changelog -->


  <!-- Release notes generated using configuration in .github/release.yml at main  -->





  -   fix: escape stage name when running ensure_record_type task by [@leo-dcfa](https://github.com/leo-dcfa) in [#3827](https://github.com/SFDO-Tooling/CumulusCI/pull/3827)
  -   fix: Upgrade upload-artifact action by [@jstvz](https://github.com/jstvz) in [#3831](https://github.com/SFDO-Tooling/CumulusCI/pull/3831)
  -   Fix `TypeError` when permissionSetGroup has a mutingPermissionSet by [@lakshmi2506](https://github.com/lakshmi2506) in [#3834](https://github.com/SFDO-Tooling/CumulusCI/pull/3834)
  -   Add `check_components` preflight to detect metadata component conflicts (#3837) by [@vsbharath](https://github.com/vsbharath) in [#3837](https://github.com/SFDO-Tooling/CumulusCI/pull/3837)



  -   @leo-dcfa made their first contribution in [#3827](https://github.com/SFDO-Tooling/CumulusCI/pull/3827)

  **Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v3.92.0...v3.93.0


pkgId: 0e5b3d256c88d6cbe17358cc0ab022cf72d358b9b9ceaaff491464e9d2f7de9d
name: python-cumulusci
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Build and release tools for Salesforce developers
url: https://github.com/SFDO-Tooling/CumulusCI
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulusci-4.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
  [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cumulusci)
  ![PyPI - License](https://img.shields.io/pypi/l/cumulusci)
  [![Documentation Status](https://readthedocs.org/projects/cumulusci/badge/?version=latest)](https://cumulusci.readthedocs.io/en/latest/?badge=latest)

  CumulusCI helps build great applications on the Salesforce platform by
  automating org setup, testing, and deployment for everyone --- from
  developers and admins to testers and product managers.

  **Best practices, proven at scale.** CumulusCI provides a complete
  development and release process created by Salesforce.org to build and
  release applications to thousands of users on the Salesforce platform.
  It\'s easy to start new projects with a standard set of tasks (single
  actions) and flows (sequences of tasks), or customize by adding your
  own.

  **Batteries included.** Out-of-the-box features help you quickly:

  -   Build sophisticated orgs with automatic installation of
      dependencies.
  -   Load and capture sample datasets to make your orgs feel real.
  -   Apply transformations to existing metadata to tailor orgs to your
      specific requirements.
  -   Run builds in continuous integration systems.
  -   Create end-to-end browser tests and setup automation using [Robot
      Framework](https://cumulusci.readthedocs.io/en/latest/robotframework.html).
  -   Generate synthetic data on any scale, from a single record to a
      million, using
      [Snowfakery](https://cumulusci.readthedocs.io/en/latest/cookbook.html#large-volume-data-synthesis-with-snowfakery).

  **Build anywhere.** Automation defined using CumulusCI is portable. It
  is stored in a source repository and can be run from your local command
  line, from a continuous integration system, or from a customer-facing
  MetaDeploy installer. CumulusCI can run automation on scratch orgs
  created using the Salesforce CLI, or on persistent orgs like sandboxes,
  production orgs, and Developer Edition orgs.



  For a tutorial introduction to CumulusCI, complete the [Build
  Applications with
  CumulusCI](https://trailhead.salesforce.com/en/content/learn/trails/build-applications-with-cumulusci)
  trail on Trailhead.

  To go in depth, read the [full
  documentation](https://cumulusci.readthedocs.io/en/latest/).

  If you just want a quick intro, watch [these screencast
  demos](https://cumulusci.readthedocs.io/en/latest/demos.html) of using
  CumulusCI to configure a Salesforce project from a GitHub repository.

  For a live demo with voiceover, please see Jason Lantz\'s [PyCon 2020
  presentation](https://www.youtube.com/watch?v=XL77lRTVF3g) from minute
  36 through minute 54.



  Ask in the [CumulusCI (CCI) group in the Trailblazer
  Community](https://success.salesforce.com/_ui/core/chatter/groups/GroupProfilePage?g=0F9300000009M9ZCAU).

  _Please note:_ CumulusCI is distributed under an [open source
  license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
  and is not covered by the Salesforce Master Subscription Agreement.

  <!-- Changelog -->






  -   Python versions 3.8, 3.9, and 3.10 are no longer supported.
  -   Switch to `sf` CLI commands [@lakshmi2506](https://github.com/lakshmi2506) in [#3829](https://github.com/SFDO-Tooling/CumulusCI/pull/3829)
      -   Removed the `dx_pull` and `dx_push` tasks as the underlying commands were removed from `sf`

  **Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v3.92.0...v4.0.0


pkgId: 7ef8243d0879762bdce60004fd4e5f8524c8d675f2ec8a6f5b3ec163f4653a98
name: python-cumulusci
arch: src
version: 4.0.1
epoch: 0
release: 1
summary: Build and release tools for Salesforce developers
url: https://github.com/SFDO-Tooling/CumulusCI
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cumulusci-4.0.1-1.src.rpm
checksum_type: sha256
description:
  [![Code Coverage](https://coveralls.io/repos/github/SFDO-Tooling/CumulusCI/badge.svg?branch=main)](https://coveralls.io/github/SFDO-Tooling/CumulusCI?branch=main)
  [![PyPI](https://img.shields.io/pypi/v/cumulusci)](https://pypi.org/project/cumulusci/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cumulusci)
  ![PyPI - License](https://img.shields.io/pypi/l/cumulusci)
  [![Documentation Status](https://readthedocs.org/projects/cumulusci/badge/?version=latest)](https://cumulusci.readthedocs.io/en/latest/?badge=latest)

  CumulusCI helps build great applications on the Salesforce platform by
  automating org setup, testing, and deployment for everyone --- from
  developers and admins to testers and product managers.

  **Best practices, proven at scale.** CumulusCI provides a complete
  development and release process created by Salesforce.org to build and
  release applications to thousands of users on the Salesforce platform.
  It\'s easy to start new projects with a standard set of tasks (single
  actions) and flows (sequences of tasks), or customize by adding your
  own.

  **Batteries included.** Out-of-the-box features help you quickly:

  -   Build sophisticated orgs with automatic installation of
      dependencies.
  -   Load and capture sample datasets to make your orgs feel real.
  -   Apply transformations to existing metadata to tailor orgs to your
      specific requirements.
  -   Run builds in continuous integration systems.
  -   Create end-to-end browser tests and setup automation using [Robot
      Framework](https://cumulusci.readthedocs.io/en/latest/robotframework.html).
  -   Generate synthetic data on any scale, from a single record to a
      million, using
      [Snowfakery](https://cumulusci.readthedocs.io/en/latest/cookbook.html#large-volume-data-synthesis-with-snowfakery).

  **Build anywhere.** Automation defined using CumulusCI is portable. It
  is stored in a source repository and can be run from your local command
  line, from a continuous integration system, or from a customer-facing
  MetaDeploy installer. CumulusCI can run automation on scratch orgs
  created using the Salesforce CLI, or on persistent orgs like sandboxes,
  production orgs, and Developer Edition orgs.



  For a tutorial introduction to CumulusCI, complete the [Build
  Applications with
  CumulusCI](https://trailhead.salesforce.com/en/content/learn/trails/build-applications-with-cumulusci)
  trail on Trailhead.

  To go in depth, read the [full
  documentation](https://cumulusci.readthedocs.io/en/latest/).

  If you just want a quick intro, watch [these screencast
  demos](https://cumulusci.readthedocs.io/en/latest/demos.html) of using
  CumulusCI to configure a Salesforce project from a GitHub repository.

  For a live demo with voiceover, please see Jason Lantz\'s [PyCon 2020
  presentation](https://www.youtube.com/watch?v=XL77lRTVF3g) from minute
  36 through minute 54.



  Ask in the [CumulusCI (CCI) group in the Trailblazer
  Community](https://success.salesforce.com/_ui/core/chatter/groups/GroupProfilePage?g=0F9300000009M9ZCAU).

  _Please note:_ CumulusCI is distributed under an [open source
  license](https://github.com/SFDO-Tooling/CumulusCI/blob/main/LICENSE)
  and is not covered by the Salesforce Master Subscription Agreement.

  <!-- Changelog -->




  -   Fixed a ModuleNotFoundError for docutils by adding the dependency `docutils` by [@jstvz](https://github.com/jstvz) in [#3558](https://github.com/SFDO-Tooling/CumulusCI/pull/3558).

  **Full Changelog**: https://github.com/SFDO-Tooling/CumulusCI/compare/v4.0.0...v4.0.1


pkgId: c74fe5db818c524c365cee39c7e5afd64ceddf6dd0a5d9db635fb0e90c75e3c0
name: python-cunyfirstapi
arch: src
version: 0.0.18
epoch: 0
release: 1
summary: A simple CUNYFIRST python API
url: https://github.com/CUNYSuite/CunyFirstAPI
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cunyfirstapi-0.0.18-1.src.rpm
checksum_type: sha256
description:
  First of, thanks for looking to help out! We're glad to have you!
  It's important that before you contribute you read the Our Goal section above.

  Okay so you know what we're looking to do. Here's how you can help:

  1. Contributing to the core
  	* 	Our core is written in python. Since this is an API (or more so a wrapper) we need to make it as robust as possible. If your interested in adding new methods, tests, improving methods then this is the section for you. Look below at the code contributions section to get started
  2. DevOps
  	* 	This API will be used in a few CUNYFirst related projects (Grade-Notifier, Textbook-Finder ... etc). These projects will rely heavily on this project being robust and working smoothly. If your interested in making sure each release is of the highest quality this is the section for you. Check out the code contributions section for getting started and focus on our Danger, bitrise.yml, hound.yml.
  3. Creating Issues
  	* 	Issues are bound to come up. Our Issues section is where all feature requests, bug reports should go. Making sure issues are categorized is very important. Head over to the Issues section of this GitHub repo and start adding issues, features and responding.
  4. Documentation
  	* 	Being an API means developers who implement the API need a quick way to understand how to use it. If your interested in writing up code documentation look below on how to get started and focus on functions without proper documentation.
  	*  We want to be inclusive. This README.md is meant to be warm but there is much room for improvement. If you like writing go ahead and edit this file. We also want/have a SETUP.md, PULL\_REQUEST\_GUIDE.md, CODE\_OF\_CONDUCT.md files. Those can all be improved or written.






  1. navigate into the folder where you want the project to exist
  2. run `gem install jump-starter`
  3. download this projects starter file and place it inside the folder - Starter file can be downloaded: [here](https://gist.github.com/Huddie/916ba13448fd9738d38ad61fc8c906b6/archive/f8aa8c36b0c313c0bf93487ca8e5d1eb99c6e37a.zip)
  4. run `jumpstart start`



  1. Click the fork button at the top right of the screen
  2. Navigate to the directory where you want this projects folder to reside
  3. git clone ....... from your fork


  To install and run this package locally, clone the repository and inside the root directory run `python3 -m pip install --user -e .`



  Please refer to [CODE OF CONDUCT](CODE_OF_CONDUCT.md)


pkgId: 4290294cd274a2d57d82189482dfa6aa3b107fee02c496a632a0442779471528
name: python-cuoco
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Cuoco is a tool for automatic data preprocessing. Cuoco comes from Italy, means chef.
url: https://pypi.org/project/cuoco/
rpm_license: : OSI Approved :: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cuoco-1.0.0-1.src.rpm
checksum_type: sha256
description:
  Cuoco is a tool for automatic processing of data.



  Json example:

  ```
  {
    "input_format": "csv",
    "output_format": "csv",
    "new_fileName": "new file",
    "new_file_route": "path/you/want/to/save/the/file",
    "index": "True",
    "header": "yes",
    "separator": ",",
    "num_nans": "mean",
    "str_nans": "yes",
    "caps": "lower",
    "normalize_method": "min_max",
    "normalize": [
      "Age"
    ],
    "balance_data": "yes",
    "balance_params": {
      "balance_method": "random",
      "y_col": "Age"
    }
  }
  ```


  Import the library

  ```
  import cuoco
  from cuoco import dataPipeline
  ```

  Use the dataPipeline

  ```
  dataPipeline.readJson('/content/biostats.csv', '/content/jsonTESTFILE.json')
  ```




  How it works:
  Cuoco uses a json created by the user to automatically apply data-processing functions to the desired dataset. The Json has the next values:

  - input_format: format of the input dataset. Can be csv, parquet, orc and txt
  - output_format: format of the resulted dataset. Can be csv, parquet, orc and txt
  - new_fileName: name of the new dataset the DataChef will write
  - new_file_route: route where to store the new data file
  - index: if you want your final dataset to have a row index. Can be:
      - True
      - False
  - header: if yor datasets has a header. Can be yes or none
  - separator: the separator of your dataset. Only applies if its csv o txt format.
  - num_nans: method you want to use against possible numerical nans (include empties). Can be:
      - drop: drop rows that contains nans
      - yes: dont do anything with rows that contains nans
      - mean: fill nans with the mean value of the column
      - median: fill nans with the median value of the column
      - mode: fill nans with the mode value of the column
  - str_nans: method you want to use against possible string nans (include empties). Can be:
      - yes: keep nans columns
      - no: drop nans columns
  - caps: method you want to use with strings that contains Upper and Lower case letters:
      - no: dont do anything
      - upper: put all strings of string columns to uppercase
      - lower: put all strings of string columns to lowercase
  - normalize_method: method to use to normalize numerical columns. Can be:
      - no: dont normalize
      - max_abs: uses max absolute value to normalize
      - min_max: uses min - max value method to normalize
      - z_score: uses z-score value method to normalize
  - normalize:
      - write the name of the columns you want to normalize
      - Note: if yor dataset does not have a header, you must write the columns's names you want to
              normalize in number format, if it has a header you must write the columns's names between ""
  - balance_data: if you want to balance your data (recomended for AI datasets). Can be:
      - yes
      - no
  - Inside balance_params there are two items:
    - balance_method: mehod you want for oversampling. Can be:
      - random: random oversampling
      - smote: perform SMOTE technique for oversampling.
    - y_col: column of the dataset you want to use as target for the balance


pkgId: 8bb20324774c2b21fe5a4d404913cb6f12dbadd96197e85018eccc682558b88e
name: python-curated-tokenizers
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Lightweight piece tokenization library
url: https://github.com/explosion/curated-tokenizers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curated-tokenizers-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This Python library provides word-/sentencepiece tokenizers. The following
  types of tokenizers are currenty supported:

  | Tokenizer | Binding       | Example model |
  | --------- | ------------- | ------------- |
  | BPE       | sentencepiece |               |
  | Byte BPE  | Native        | RoBERTa/GPT-2 |
  | Unigram   | sentencepiece | XLM-RoBERTa   |
  | Wordpiece | Native        | BERT          |



  This package is experimental and it is likely that the APIs will change in
  incompatible ways.



  Curated tokenizers is availble through PyPI:

  ```bash
  pip install curated_tokenizers
  ```



  The best way to get started with curated tokenizers is through the
  [`curated-transformers`](https://github.com/explosion/curated-transformers)
  library. `curated-transformers` also provides functionality to load tokenization
  models from Huggingface Hub.


pkgId: 233562e81c62c49ac71b70691072fb63d0608f57ca82cb3f9c6b1c24c9f7b9b6
name: python-curated-transformers
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A PyTorch library of transformer models and components
url: https://github.com/explosion/curated-transformers
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curated-transformers-2.0.1-1.src.rpm
checksum_type: sha256
description:
  <img src="docs/source/logo.png" width="100" align="right"/>



  [![Documentation Status](https://readthedocs.org/projects/button/badge/?version=latest)](https://curated-transformers.readthedocs.io/en/latest/?badge=latest)
  [![pypi Version](https://img.shields.io/pypi/v/curated-transformers.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/curated-transformers/)

  **State-of-the-art transformers, brick by brick**

  Curated Transformers is a transformer library for PyTorch. It provides
  state-of-the-art models that are composed from a set of reusable
  components. The stand-out features of Curated Transformer are:

  - ⚡️ Supports state-of-the art transformer models, including LLMs such
    as Falcon, Llama, and Dolly v2.
  - 👩‍🎨 Each model is composed from a set of reusable building blocks,
    providing many benefits:
    - Implementing a feature or bugfix benefits all models. For example,
      all models support 4/8-bit inference through the
      [`bitsandbytes`](https://github.com/TimDettmers/bitsandbytes) library
      and each model can use the PyTorch `meta` device to avoid unnecessary
      allocations and initialization.
    - Adding new models to the library is low-effort.
    - Do you want to try a new transformer architecture? A BERT encoder
      with rotary embeddings? You can make it in a pinch.
  - 💎 Consistent type annotations of all public APIs:
    - Get great coding support from your IDE.
    - Integrates well with your existing type-checked code.
  - 🎓 Great for education, because the building blocks are easy to study.
  - 📦 Minimal dependencies.

  Curated Transformers has been production-tested by [Explosion](http://explosion.ai/)
  and will be used as the default transformer implementation in spaCy 3.7.



  Supported encoder-only models:

  - ALBERT
  - BERT
  - CamemBERT
  - RoBERTa
  - XLM-RoBERTa

  Supported decoder-only models:

  - Falcon
  - GPT-NeoX
  - Llama 1/2
  - MPT

  Generator wrappers:

  - Dolly v2
  - Falcon
  - Llama 1/2
  - MPT

  All types of models can be loaded from Huggingface Hub.

  spaCy integration for curated transformers is provided by the
  [`spacy-curated-transformers`](https://github.com/explosion/spacy-curated-transformers)
  package.



  ```bash
  pip install curated-transformers
  ```



  The default Linux build of PyTorch is built with CUDA 11.7 support. You should
  explicitly install a CUDA build in the following cases:

  - If you want to use Curated Transformers on Windows.
  - If you want to use Curated Transformers on Linux with Ada-generation GPUs.
    The standard PyTorch build supports Ada GPUs, but you can get considerable
    performance improvements by installing PyTorch with CUDA 11.8 support.

  In both cases, you can install PyTorch with:

  ```bash
  pip install torch --index-url https://download.pytorch.org/whl/cu118
  ```



  ```python-console
  >>> import torch
  >>> from curated_transformers.generation import AutoGenerator, GreedyGeneratorConfig
  >>> generator = AutoGenerator.from_hf_hub(name="tiiuae/falcon-7b-instruct", device=torch.device("cuda"))
  >>> generator(["What is Python in one sentence?", "What is Rust in one sentence?"], GreedyGeneratorConfig())
  ['Python is a high-level programming language that is easy to learn and widely used for web development, data analysis, and automation.',
   'Rust is a programming language that is designed to be a safe, concurrent, and efficient replacement for C++.']
  ```

  You can find more [usage examples](https://curated-transformers.readthedocs.io/en/latest/usage.html)
  in the documentation. You can also find example programs that use Curated Transformers in the
  [`examples`](examples/) directory.



  You can read more about how to use Curated Transformers here:

  - [Overview](https://curated-transformers.readthedocs.io/en/v1.2.x/) ([Development](https://curated-transformers.readthedocs.io/en/latest/))
  - [Usage](https://curated-transformers.readthedocs.io/en/v1.2.x/usage.html) ([Development](https://curated-transformers.readthedocs.io/en/latest/usage.html))
  - [API](https://curated-transformers.readthedocs.io/en/v1.2.x/api.html) ([Development](https://curated-transformers.readthedocs.io/en/latest/api.html))



  `curated-transformers` supports dynamic 8-bit and 4-bit quantization of models by leveraging the [`bitsandbytes` library](https://github.com/TimDettmers/bitsandbytes).

  Use the quantization variant to automatically install the necessary dependencies:

  ```bash
  pip install curated-transformers[quantization]
  ```


pkgId: 2dad0fbce7f4db7400596559aa15e74517cace957650bdede3aaa172cc3871bc
name: python-curategpt
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: CurateGPT
url: https://pypi.org/project/curategpt/
rpm_license: BSD-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curategpt-0.2.2-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/645996391.svg)](https://zenodo.org/doi/10.5281/zenodo.8293691)


  CurateGPT is a prototype web application and framework for performing general purpose AI-guided curation
  and curation-related operations over *collections* of objects.


  See also the app on [curategpt.io](https://curategpt.io) (note: this is sometimes down, and may only have a
  subset of the functionality of the local app)






  CurateGPT is available on Pypi and may be installed with `pip`:

  `pip install curategpt`



  You will first need to [install Poetry](https://python-poetry.org/docs/#installation).

  Then clone this repo.

  ```
  git clone https://github.com/monarch-initiative/curategpt.git
  cd curategpt
  ```

  and install the dependencies:


  ```
  poetry install
  ```



  In order to get the best performance from CurateGPT, we recommend getting an OpenAI API key, and setting it:

  ```
  export OPENAI_API_KEY=<your key>
  ```

  (for members of Monarch: ask on Slack if you would like to use the group key)

  CurateGPT will also work with other large language models - see "Selecting models" below.



  You initially start with an empty database. You can load whatever you like into this
  database! Any JSON, YAML, or CSV is accepted.
  CurateGPT comes with *wrappers* for some existing local and remote sources, including
  ontologies. The [Makefile](Makefile) contains some examples of how to load these. You can
  load any ontology using the `ont-<name>` target, e.g.:

  ```
  make ont-cl
  ```

  This loads CL (via OAK) into a collection called `ont_cl`

  Note that by default this loads into a collection set stored at `stagedb`, whereas the app works off
  of `db`. You can copy the collection set to the db with:

  ```
  cp -r stagedb/* db/
  ```


  You can then run the streamlit app with:

  ```
  make app
  ```



  CurateGPT depends on vector database indexes of the databases/ontologies you want to curate.

  The flagship application is ontology curation, so to build an index for an OBO ontology like CL:

  ```
  make ont-cl
  ```

  This requires an OpenAI key.

  (You can build indexes using an open embedding model, modify the command to leave off
  the `-m` option, but this is not recommended as currently oai embeddings seem to work best).


  To load the default ontologies:

  ```
  make all
  ```

  (this may take some time)

  To load different databases:

  ```
  make load-db-hpoa
  make load-db-reactome
  ```



  You can load an arbitrary json, yaml, or csv file:

  ```
  curategpt view index -c my_foo foo.json
  ```

  (you will need to do this in the poetry shell)

  To load a GitHub repo of issues:

  ```
  curategpt -v view index -c gh_uberon -m openai:  --view github --init-with "{repo: obophenotype/uberon}"
  ```

  The following are also supported:

  - Google Drives
  - Google Sheets
  - Markdown files
  - LinkML Schemas
  - HPOA files
  - GOCAMs
  - MAXOA files
  - Many more



  - See [notebooks](notebooks) for examples.



  Currently this tool works best with the OpenAI gpt-4 model (for instruction tasks) and OpenAI `ada-text-embedding-002` for embedding.

  CurateGPT is layered on top of [simonw/llm](https://github.com/simonw/llm) which has a plugin
  architecture for using alternative models. In theory you can use any of these plugins.

  Additionally, you can set up an openai-emulating proxy using [litellm](https://github.com/BerriAI/litellm/).

  The `litellm` proxy may be installed with `pip` as `pip install litellm[proxy]`.

  Let's say you want to run mixtral locally using ollama. You start up ollama (you may have to run `ollama serve` first):

  ```
  ollama run mixtral
  ```

  Then start up litellm:

  ```
  litellm -m ollama/mixtral
  ```

  Next edit your `extra-openai-models.yaml` as detailed in [the llm docs](https://llm.datasette.io/en/stable/other-models.html):

  ```
  - model_name: ollama/mixtral
    model_id: litellm-mixtral
    api_base: "http://0.0.0.0:8000"
  ```

  You can now use this:

  ```yaml
  curategpt ask -m litellm-mixtral -c ont_cl "What neurotransmitter is released by the hippocampus?"
  ```

  But be warned that many of the prompts in curategpt were engineered
  against openai models, and they may give suboptimal results or fail
  entirely on other models. As an example, `ask` seems to work quite
  well with mixtral, but `complete` works horribly. We haven't yet
  investigated if the issue is the model or our prompts or the overall
  approach.

  Welcome to the world of AI engineering!



  ```bash
  curategpt --help
  ```

  You will see various commands for working with indexes, searching, extracting, generating, etc.

  These functions are generally available through the UI, and the current priority is documenting these.



  ```
  curategpt ask -c ont_cl "What neurotransmitter is released by the hippocampus?"
  ```

  may yield something like:

  ```
  The hippocampus releases gamma-aminobutyric acid (GABA) as a neurotransmitter [1](#ref-1).

  ...



  id: GammaAminobutyricAcidSecretion_neurotransmission
  label: gamma-aminobutyric acid secretion, neurotransmission
  definition: The regulated release of gamma-aminobutyric acid by a cell, in which the
    gamma-aminobutyric acid acts as a neurotransmitter.
  ...
  ```



  ```
  curategpt view ask -V pubmed "what neurons express VIP?"
  ```



  ```
  curategpt ask -c gh_obi "what are some new term requests for electrophysiology terms?"
  ```



  ```
  curategpt complete -c ont_cl  "mesenchymal stem cell of the apical papilla"
  ```

  yields

  ```yaml
  id: MesenchymalStemCellOfTheApicalPapilla
  definition: A mesenchymal cell that is part of the apical papilla of a tooth and has
    the ability to self-renew and differentiate into various cell types such as odontoblasts,
    fibroblasts, and osteoblasts.
  relationships:
  - predicate: PartOf
    target: ApicalPapilla
  - predicate: subClassOf
    target: MesenchymalCell
  - predicate: subClassOf
    target: StemCell
  original_id: CL:0007045
  label: mesenchymal stem cell of the apical papilla
  ```



  You can compare all objects in one collection

  `curategpt all-by-all --threshold 0.80 -c ont_hp -X ont_mp --ids-only -t csv > ~/tmp/allxall.mp.hp.csv`

  This takes 1-2s, as it involves comparison over pre-computed vectors. It reports top hits above a threshold.

  Results may vary. You may want to try different texts for embeddings
  (the default is the entire json object; for ontologies it is
  concatenation of labels, definition, aliases).

  sample:

  ```
  HP:5200068,Socially innappropriate questioning,MP:0001361,social withdrawal,0.844015132437909
  HP:5200069,Spinning,MP:0001411,spinning,0.9077306606290237
  HP:5200071,Delayed Echolalia,MP:0013140,excessive vocalization,0.8153252835818089
  HP:5200072,Immediate Echolalia,MP:0001410,head bobbing,0.8348177036912526
  HP:5200073,Excessive cleaning,MP:0001412,excessive scratching,0.8699103725005582
  HP:5200104,Abnormal play,MP:0020437,abnormal social play behavior,0.8984862078522344
  HP:5200105,Reduced imaginative play skills,MP:0001402,decreased locomotor activity,0.85571629684631
  HP:5200108,Nonfunctional or atypical use of objects in play,MP:0003908,decreased stereotypic behavior,0.8586700411012859
  HP:5200129,Abnormal rituals,MP:0010698,abnormal impulsive behavior control,0.8727804272023427
  HP:5200134,Jumping,MP:0001401,jumpy,0.9011393233129765
  ```

  Note that CurateGPT has a separate component for using an LLM to evaluate candidate matches (see also https://arxiv.org/abs/2310.03666); this is
  not enabled by default, this would be expensive to run for a whole ontology.


pkgId: 44aeba0d27288957fe9da397d2ac130c5e6efcfa36fea3c7605886c07b9a9bc2
name: python-curator-opensearch
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: Tending your Elasticsearch indices
url: https://github.com/uzhinskiy/curator-opensearch
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curator-opensearch-0.0.13-1.src.rpm
checksum_type: sha256
description:
  Have indices in Elasticsearch? This is the tool for you!
  Like a museum curator manages the exhibits and collections on display,
  Elasticsearch Curator helps you curate, or manage your indices.


pkgId: 81c9d700dd95f55bd4dc6198ae2daa87cd0b571a6dca004ddadb73d76cac0c24
name: python-curdling
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Concurrent package manager for Python
url: https://github.com/clarete/curdling
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curdling-0.4.1-1.src.rpm
checksum_type: sha256
description:
  Curdling is a command line tool for managing Python packages.
  It was designed to find, build and cache all the dependencies your
  application needs to start up and run smoothly. A solid concurrency
  model allows curdling to execute tasks asynchronously, resulting in a
  considerable improve in speed over `pip <http://pip-installer.org>`_
  and `easy_install
  <http://peak.telecommunity.com/DevCenter/EasyInstall>`_.
  You should definitely check the `Official Documentation
  <http://clarete.github.io/curdling>`_ to learn more about the project.


pkgId: d10a60e42d18cfa9f68e7d8b53e35620bcfffa9496610dfc35c6842d01e0cc22
name: python-cure
arch: src
version: 0.5.1
epoch: 0
release: 1
url: https://github.com/kalaspuff/cure
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cure-0.5.1-1.src.rpm
checksum_type: sha256
summary:
  Decorator for fixing naming conventions to keys of keyword arguments - adds trailing underscores to keys using bad naming such as reserved keywords or Python built-ins

description:
  ![Python package](https://github.com/kalaspuff/cure/workflows/Python%20package/badge.svg)
  [![pypi](https://badge.fury.io/py/cure.svg)](https://pypi.python.org/pypi/cure/)
  [![Made with Python](https://img.shields.io/pypi/pyversions/cure)](https://www.python.org/)
  [![Type hinted - mypy validated](https://img.shields.io/badge/typehinted-yes-teal)](https://github.com/kalaspuff/cure)
  [![MIT License](https://img.shields.io/github/license/kalaspuff/cure.svg)](https://github.com/kalaspuff/cure/blob/master/LICENSE)
  [![Code coverage](https://codecov.io/gh/kalaspuff/cure/branch/master/graph/badge.svg)](https://codecov.io/gh/kalaspuff/cure/tree/master/cure)

  *Library for adding trailing underscores to passed down keyword arguments from third party libraries. Adds the preferred trailing underscore to the key in the kwarg if the key would conflict with the Python reserved keywords or Python built-ins. Methods can be decorated with the `@cure` decorator.*

  Can also be used to convert input keyword arguments to snake case. All in all a decorator to put on your functions which take input from third party libraries which are dependant on user input. In my experience this may happen when working with web frameworks that may apply query values as kwargs or when interfacing with GraphQL libraries that will send user input arguments as kwargs.

  As described in *PEP 8 -- Style Guide for Python Code* (https://www.python.org/dev/peps/pep-0008/):
  > The following special forms using leading or trailing underscores are recognized (these can generally be combined with any case convention):
  >
  > `single_trailing_underscore_`: used by convention to avoid conflicts with Python keyword.



  Like you would install any other Python package, use `pip`, `poetry`, `pipenv` or your weapon of choice.
  ```
  $ pip install cure
  ```






  ```python
  import cure

  @cure.decorator(cure.KEYWORD_TRAILING_UNDERSCORES)
  def my_function(id_=None, username=None, type_=None):
      pass
  ```

  This function could then be called with the keyword arguments `id`, `username` and/or `type`. Since `id` and `type` are either reserved Python keywords or are Python built-ins and shouldn't be used as names, the decorator will add a trailing underscore to the kwargs before passing them into our function `my_function`.



  ```python
  import cure

  @cure.decorator(cure.KEYWORD_TRAILING_UNDERSCORES | cure.KEYWORD_SNAKE_CASE_RECURSIVE)
  def graphql_resolver(obj, info, resource_id, type_=None):
      pass
  ```

  This function uses both the options of adding trailing underscores to reserved keywords and built-ins as well as the option of converting input kwargs to snake case. Let's say we're dealing with a GraphQL framework which would otherwise call our function like this, depending on the user input `my_function(None, info, resourceId=kwargs["resourceId"], type=kwargs["type"])` or even more likely like `my_function(None, info, **kwargs)` where `kwargs` would be a dict holding the keys `resourceId` and `type`. Since we want our code to be Pythonic and adhere to proper naming conventions the `@cure.decorator` can help out with removing the hurdle of converting the kwargs ourself or by jumping through hoops otherwise required.


  * `cure.KEYWORD_TRAILING_UNDERSCORES`: Adds trailing underscores to keys in keyword arguments that are using a name that is either a reserved keyword or a Python built-in.
  * `cure.KEYWORD_SNAKE_CASE`: Converts keys in keyword arguments to snake case.
  * `cure.KEYWORD_SNAKE_CASE_RECURSIVE`: Converts keys in keyword arguments to snake case. If the keyword argument's value is a dict or a list of dicts it will also convert keys within these to snake case.
  * `cure.KEYWORD_CAMEL_CASE`: Converts keys in keyword arguments to camel case. This is not recommended, but may be used as a reversal of values converted by the snake case decorator.
  * `cure.KEYWORD_CAMEL_CASE_RECURSIVE`: Recursive conversion to camel case.


  The following functions are also available from the module.


  ```python
  import cure

  cure.is_keyword("id")

  cure.is_keyword("type")

  cure.is_keyword("api")

  ```


  ```python
  import cure

  cure.trail_name("id")

  cure.trail_name("type")

  cure.trail_name("api")

  ```


  ```python
  import cure

  cure.snake_case_name("apiSecret")

  cure.snake_case_dict({"user": {"userId": 4711, "userLevel": "ADMIN"}}, recursive=True)

  ```


  ```python
  import cure

  cure.camel_case_name("api_secret")

  cure.camel_case_dict({"user": {"user_id": 4711, "user_level": "ADMIN"}}, recursive=True)

  ```


pkgId: 52f6fb49a9a727be9ed4af38c658e3e612bdd36b8208c2cfeafd5e2acd5c09e2
name: python-curies
arch: src
version: 0.7.10
epoch: 0
release: 1
summary: Idiomatic conversion between URIs and compact URIs (CURIEs).
url: https://github.com/cthoyt/curies
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curies-0.7.10-1.src.rpm
checksum_type: sha256
description:
  <!--
  <p align="center">
    <img src="https://github.com/cthoyt/curies/raw/main/docs/source/logo.png" height="150">
  </p>
  -->

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

  <p align="center">
      <a href="https://github.com/biopragmatics/curies/actions/workflows/tests.yml">
          <img alt="Tests" src="https://github.com/biopragmatics/curies/actions/workflows/tests.yml/badge.svg" />
      </a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/curies" />
      </a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/curies" />
      </a>
      <a href="https://github.com/cthoyt/curies/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/curies" />
      </a>
      <a href='https://curies.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/curies/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="https://codecov.io/gh/cthoyt/curies/branch/main">
          <img src="https://codecov.io/gh/cthoyt/curies/branch/main/graph/badge.svg" alt="Codecov status" />
      </a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-snekpack-blue" />
      </a>
      <a href='https://github.com/psf/black'>
          <img src='https://img.shields.io/badge/code%20style-black-000000.svg' alt='Code style: black' />
      </a>
      <a href="https://github.com/cthoyt/curies/blob/main/.github/CODE_OF_CONDUCT.md">
          <img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"/>
      </a>
      <a href="https://zenodo.org/badge/latestdoi/519905487">
          <img src="https://zenodo.org/badge/519905487.svg" alt="DOI">
      </a>
  </p>

  Idiomatic conversion between URIs and compact URIs (CURIEs).

  ```python
  import curies

  converter = curies.load_prefix_map({
      "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_",
      
  })

  >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1")
  'CHEBI:1'

  >>> converter.expand("CHEBI:1")
  'http://purl.obolibrary.org/obo/CHEBI_1'
  ```

  Full documentation is available at [curies.readthedocs.io](https://curies.readthedocs.io).



  This package comes with a built-in CLI for running a resolver web application or a IRI mapper web application:

  ```shell

  python -m curies resolver --host 0.0.0.0 --port 8764 bioregistry


  python -m curies mapper --host 0.0.0.0 --port 8764 bioregistry
  ```

  The positional argument can be one of the following:

  1. A pre-defined prefix map to get from the web (bioregistry, go, obo, monarch, prefixcommons)
  2. A local file path or URL to a prefix map, extended prefix map, or one of several formats. Requires specifying
     a `--format`.

  The framework can be swapped to use Flask (default) or FastAPI with `--framework`. The
  server can be swapped to use Werkzeug (default) or Uvicorn with `--server`. These functionalities
  are also available programmatically, see the docs for more information.



  Other packages that convert between CURIEs and URIs:

  - https://github.com/prefixcommons/prefixcommons-py (Python)
  - https://github.com/prefixcommons/curie-util (Java)
  - https://github.com/geneontology/curie-util-py (Python)
  - https://github.com/geneontology/curie-util-es5 (Node.js)
  - https://github.com/endoli/curie.rs (Rust)
  - https://github.com/cthoyt/curies4j (Java)
  - https://github.com/biopragmatics/curies.rs (Rust, Node.js, Python)



  The most recent release can be installed from
  [PyPI](https://pypi.org/project/curies/) with:

  ```bash
  $ pip install curies
  ```

  This package currently supports both Pydantic v1 and v2. See the
  [Pydantic migration guide](https://docs.pydantic.dev/2.0/migration/)
  for updating your code.

  > [!WARNING]
  > Pydantic v1 support will be dropped on October 31<sup>st</sup>, 2024,
  > coincident with the [obsolescence of Python 3.8](https://endoflife.date/python).
  > This will be accompanied by the v0.8.0 release of the `curies` package.



  Contributions, whether filing an issue, making a pull request, or forking, are appreciated. See
  [CONTRIBUTING.md](https://github.com/cthoyt/curies/blob/master/.github/CONTRIBUTING.md) for more information on getting
  involved.





  This package heavily builds on the [trie](https://en.wikipedia.org/wiki/Trie)
  data structure implemented in [`pytrie`](https://github.com/gsakkis/pytrie).



  The code in this package is licensed under the MIT License.



  This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s
  [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s
  [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template.



  <details>
    <summary>See developer instructions</summary>


  The final section of the README is for if you want to get involved by making a code contribution.



  To install in development mode, use the following:

  ```bash
  $ git clone git+https://github.com/cthoyt/curies.git
  $ cd curies
  $ pip install -e .
  ```



  After cloning the repository and installing `tox` with `pip install tox`, the unit tests in the `tests/` folder can be
  run reproducibly with:

  ```shell
  $ tox
  ```

  Additionally, these tests are automatically re-run with each commit in a [GitHub Action](https://github.com/cthoyt/curies/actions?query=workflow%3ATests).



  The documentation can be built locally using the following:

  ```shell
  $ git clone git+https://github.com/cthoyt/curies.git
  $ cd curies
  $ tox -e docs
  $ open docs/build/html/index.html
  ```

  The documentation automatically installs the package as well as the `docs`
  extra specified in the [`setup.cfg`](setup.cfg). `sphinx` plugins
  like `texext` can be added there. Additionally, they need to be added to the
  `extensions` list in [`docs/source/conf.py`](docs/source/conf.py).



  After installing the package in development mode and installing
  `tox` with `pip install tox`, the commands for making a new release are contained within the `finish` environment
  in `tox.ini`. Run the following from the shell:

  ```shell
  $ tox -e finish
  ```

  This script does the following:

  1. Uses [Bump2Version](https://github.com/c4urself/bump2version) to switch the version number in the `setup.cfg`,
     `src/curies/version.py`, and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel using [`build`](https://github.com/pypa/build)
  3. Uploads to PyPI using [`twine`](https://github.com/pypa/twine). Be sure to have a `.pypirc` file configured to avoid the need for manual input at this
     step
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion minor` after.

  </details>


pkgId: edc57af220b55b647a20b5fbcbc47e9e4c2450285778674a6a3e6b06b8b4bec4
name: python-curies
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Idiomatic conversion between URIs and compact URIs (CURIEs)
url: https://github.com/biopragmatics/curies
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curies-0.8.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  <p align="center">
    <img src="https://github.com/cthoyt/curies/raw/main/docs/source/logo.png" height="150">
  </p>
  -->

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

  <p align="center">
      <a href="https://github.com/biopragmatics/curies/actions/workflows/tests.yml">
          <img alt="Tests" src="https://github.com/biopragmatics/curies/actions/workflows/tests.yml/badge.svg" />
      </a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/curies" />
      </a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/curies" />
      </a>
      <a href="https://github.com/cthoyt/curies/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/curies" />
      </a>
      <a href='https://curies.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/curies/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href="https://codecov.io/gh/cthoyt/curies/branch/main">
          <img src="https://codecov.io/gh/cthoyt/curies/branch/main/graph/badge.svg" alt="Codecov status" />
      </a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-snekpack-blue" />
      </a>
      <a href='https://github.com/psf/black'>
          <img src='https://img.shields.io/badge/code%20style-black-000000.svg' alt='Code style: black' />
      </a>
      <a href="https://github.com/cthoyt/curies/blob/main/.github/CODE_OF_CONDUCT.md">
          <img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"/>
      </a>
      <a href="https://zenodo.org/badge/latestdoi/519905487">
          <img src="https://zenodo.org/badge/519905487.svg" alt="DOI">
      </a>
  </p>

  Idiomatic conversion between URIs and compact URIs (CURIEs).

  ```python
  import curies

  converter = curies.load_prefix_map({
      "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_",
      
  })

  >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1")
  'CHEBI:1'

  >>> converter.expand("CHEBI:1")
  'http://purl.obolibrary.org/obo/CHEBI_1'
  ```

  Full documentation is available at [curies.readthedocs.io](https://curies.readthedocs.io).



  This package comes with a built-in CLI for running a resolver web application or a IRI mapper web application:

  ```shell

  python -m curies resolver --host 0.0.0.0 --port 8764 bioregistry


  python -m curies mapper --host 0.0.0.0 --port 8764 bioregistry
  ```

  The positional argument can be one of the following:

  1. A pre-defined prefix map to get from the web (bioregistry, go, obo, monarch, prefixcommons)
  2. A local file path or URL to a prefix map, extended prefix map, or one of several formats. Requires specifying
     a `--format`.

  The framework can be swapped to use Flask (default) or FastAPI with `--framework`. The
  server can be swapped to use Werkzeug (default) or Uvicorn with `--server`. These functionalities
  are also available programmatically, see the docs for more information.



  Other packages that convert between CURIEs and URIs:

  - https://github.com/prefixcommons/prefixcommons-py (Python)
  - https://github.com/prefixcommons/curie-util (Java)
  - https://github.com/geneontology/curie-util-py (Python)
  - https://github.com/geneontology/curie-util-es5 (Node.js)
  - https://github.com/endoli/curie.rs (Rust)
  - https://github.com/cthoyt/curies4j (Java)
  - https://github.com/biopragmatics/curies.rs (Rust, Node.js, Python)



  The most recent release can be installed from
  [PyPI](https://pypi.org/project/curies/) with:

  ```bash
  $ pip install curies
  ```

  As of v0.8, this package only supports Pydantic v2. v0.6.x and v0.7.x had
  cross-version support for Pydantic v1 and v2. v0.5.x and before only supported
  Pydantic v1. See the
  [Pydantic migration guide](https://docs.pydantic.dev/2.0/migration/)
  for updating your code.



  Contributions, whether filing an issue, making a pull request, or forking, are appreciated. See
  [CONTRIBUTING.md](https://github.com/cthoyt/curies/blob/master/.github/CONTRIBUTING.md) for more information on getting
  involved.





  This package heavily builds on the [trie](https://en.wikipedia.org/wiki/Trie)
  data structure implemented in [`pytrie`](https://github.com/gsakkis/pytrie).



  The code in this package is licensed under the MIT License.



  This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s
  [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s
  [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template.



  <details>
    <summary>See developer instructions</summary>


  The final section of the README is for if you want to get involved by making a code contribution.



  To install in development mode, use the following:

  ```bash
  $ git clone git+https://github.com/cthoyt/curies.git
  $ cd curies
  $ pip install -e .
  ```



  After cloning the repository and installing `tox` with `pip install tox`, the unit tests in the `tests/` folder can be
  run reproducibly with:

  ```shell
  $ tox
  ```

  Additionally, these tests are automatically re-run with each commit in a [GitHub Action](https://github.com/cthoyt/curies/actions?query=workflow%3ATests).



  The documentation can be built locally using the following:

  ```shell
  $ git clone git+https://github.com/cthoyt/curies.git
  $ cd curies
  $ tox -e docs
  $ open docs/build/html/index.html
  ```

  The documentation automatically installs the package as well as the `docs`
  extra specified in the [`setup.cfg`](setup.cfg). `sphinx` plugins
  like `texext` can be added there. Additionally, they need to be added to the
  `extensions` list in [`docs/source/conf.py`](docs/source/conf.py).



  After installing the package in development mode and installing
  `tox` with `pip install tox`, the commands for making a new release are contained within the `finish` environment
  in `tox.ini`. Run the following from the shell:

  ```shell
  $ tox -e finish
  ```

  This script does the following:

  1. Uses [Bump2Version](https://github.com/c4urself/bump2version) to switch the version number in the `setup.cfg`,
     `src/curies/version.py`, and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel using [`build`](https://github.com/pypa/build)
  3. Uploads to PyPI using [`twine`](https://github.com/pypa/twine). Be sure to have a `.pypirc` file configured to avoid the need for manual input at this
     step
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion minor` after.

  </details>

rpm_license:
  MIT License  Copyright (c) 2022 Charles Tapley Hoyt  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: 20727d5ddfcd18604b4846f428c8392147930d9f8a06efe3586861ff638582ee
name: python-curies
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Idiomatic conversion between URIs and compact URIs (CURIEs)
url: https://github.com/biopragmatics/curies
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curies-0.9.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  <p align="center">
    <img src="https://github.com/biopragmatics/curies/raw/main/docs/source/logo.png" height="150">
  </p>
  -->

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

  <p align="center">
      <a href="https://github.com/biopragmatics/curies/actions/workflows/tests.yml">
          <img alt="Tests" src="https://github.com/biopragmatics/curies/actions/workflows/tests.yml/badge.svg" /></a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/curies" /></a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/curies" /></a>
      <a href="https://github.com/biopragmatics/curies/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/curies" /></a>
      <a href='https://curies.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/curies/badge/?version=latest' alt='Documentation Status' /></a>
      <a href="https://codecov.io/gh/biopragmatics/curies/branch/main">
          <img src="https://codecov.io/gh/biopragmatics/curies/branch/main/graph/badge.svg" alt="Codecov status" /></a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-snekpack-blue" /></a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;"></a>
      <a href="https://github.com/biopragmatics/curies/blob/main/.github/CODE_OF_CONDUCT.md">
          <img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"/></a>
      <a href="https://zenodo.org/badge/latestdoi/519905487">
          <img src="https://zenodo.org/badge/519905487.svg" alt="DOI"></a>
  </p>

  Idiomatic conversion between URIs and compact URIs (CURIEs).

  ```python
  import curies

  converter = curies.load_prefix_map({
      "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_",
      
  })

  >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1")
  'CHEBI:1'

  >>> converter.expand("CHEBI:1")
  'http://purl.obolibrary.org/obo/CHEBI_1'
  ```

  Full documentation is available at [curies.readthedocs.io](https://curies.readthedocs.io).



  This package comes with a built-in CLI for running a resolver web application or a IRI mapper web application:

  ```shell

  python -m curies resolver --host 0.0.0.0 --port 8764 bioregistry


  python -m curies mapper --host 0.0.0.0 --port 8764 bioregistry
  ```

  The positional argument can be one of the following:

  1. A pre-defined prefix map to get from the web (bioregistry, go, obo, monarch, prefixcommons)
  2. A local file path or URL to a prefix map, extended prefix map, or one of several formats. Requires specifying
     a `--format`.

  The framework can be swapped to use Flask (default) or FastAPI with `--framework`. The
  server can be swapped to use Werkzeug (default) or Uvicorn with `--server`. These functionalities
  are also available programmatically, see the docs for more information.



  Other packages that convert between CURIEs and URIs:

  - https://github.com/prefixcommons/prefixcommons-py (Python)
  - https://github.com/prefixcommons/curie-util (Java)
  - https://github.com/geneontology/curie-util-py (Python)
  - https://github.com/geneontology/curie-util-es5 (Node.js)
  - https://github.com/endoli/curie.rs (Rust)
  - https://github.com/cthoyt/curies4j (Java)
  - https://github.com/biopragmatics/curies.rs (Rust, Node.js, Python)



  The most recent release can be installed from
  [PyPI](https://pypi.org/project/curies/) with:

  ```console
  python3 -m pip install curies
  ```

  As of v0.8, this package only supports Pydantic v2. v0.6.x and v0.7.x had
  cross-version support for Pydantic v1 and v2. v0.5.x and before only supported
  Pydantic v1. See the
  [Pydantic migration guide](https://docs.pydantic.dev/2.0/migration/)
  for updating your code.



  Contributions, whether filing an issue, making a pull request, or forking, are appreciated. See
  [CONTRIBUTING.md](https://github.com/biopragmatics/curies/blob/master/.github/CONTRIBUTING.md)
  for more information on getting involved.





  This package heavily builds on the [trie](https://en.wikipedia.org/wiki/Trie)
  data structure implemented in [`pytrie`](https://github.com/gsakkis/pytrie).



  The code in this package is licensed under the MIT License.



  This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s
  [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s
  [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template.



  <details>
    <summary>See developer instructions</summary>

  The final section of the README is for if you want to get involved by making a code contribution.



  To install in development mode, use the following:

  ```console
  git clone git+https://github.com/biopragmatics/curies.git
  cd curies
  python3 -m pip install -e .
  ```



  This project uses `cruft` to keep boilerplate (i.e., configuration, contribution guidelines, documentation
  configuration)
  up-to-date with the upstream cookiecutter package. Update with the following:

  ```console
  python3 -m pip install cruft
  cruft update
  ```

  More info on Cruft's update command is
  available [here](https://github.com/cruft/cruft?tab=readme-ov-file#updating-a-project).



  After cloning the repository and installing `tox` with
  `python3 -m pip install tox tox-uv`,
  the unit tests in the `tests/` folder can be run reproducibly with:

  ```console
  tox -e py
  ```

  Additionally, these tests are automatically re-run with each commit in a
  [GitHub Action](https://github.com/biopragmatics/curies/actions?query=workflow%3ATests).



  The documentation can be built locally using the following:

  ```console
  git clone git+https://github.com/biopragmatics/curies.git
  cd curies
  tox -e docs
  open docs/build/html/index.html
  ```

  The documentation automatically installs the package as well as the `docs`
  extra specified in the [`pyproject.toml`](pyproject.toml). `sphinx` plugins
  like `texext` can be added there. Additionally, they need to be added to the
  `extensions` list in [`docs/source/conf.py`](docs/source/conf.py).

  The documentation can be deployed to [ReadTheDocs](https://readthedocs.io) using
  [this guide](https://docs.readthedocs.io/en/stable/intro/import-guide.html).
  The [`.readthedocs.yml`](.readthedocs.yml) YAML file contains all the configuration you'll need.
  You can also set up continuous integration on GitHub to check not only that
  Sphinx can build the documentation in an isolated environment (i.e., with `tox -e docs-test`)
  but also that [ReadTheDocs can build it too](https://docs.readthedocs.io/en/stable/pull-requests.html).



  1. Log in to ReadTheDocs with your GitHub account to install the integration
     at https://readthedocs.org/accounts/login/?next=/dashboard/
  2. Import your project by navigating to https://readthedocs.org/dashboard/import then clicking the plus icon next to
     your repository
  3. You can rename the repository on the next screen using a more stylized name (i.e., with spaces and capital letters)
  4. Click next, and you're good to go!





  [Zenodo](https://zenodo.org) is a long-term archival system that assigns a DOI to each release of your package.

  1. Log in to Zenodo via GitHub with this link: https://zenodo.org/oauth/login/github/?next=%2F. This brings you to a
     page that lists all of your organizations and asks you to approve installing the Zenodo app on GitHub. Click "grant"
     next to any organizations you want to enable the integration for, then click the big green "approve" button. This
     step only needs to be done once.
  2. Navigate to https://zenodo.org/account/settings/github/, which lists all of your GitHub repositories (both in your
     username and any organizations you enabled). Click the on/off toggle for any relevant repositories. When you make
     a new repository, you'll have to come back to this

  After these steps, you're ready to go! After you make "release" on GitHub (steps for this are below), you can navigate
  to https://zenodo.org/account/settings/github/repository/biopragmatics/curies
  to see the DOI for the release and link to the Zenodo record for it.



  You only have to do the following steps once.

  1. Register for an account on the [Python Package Index (PyPI)](https://pypi.org/account/register)
  2. Navigate to https://pypi.org/manage/account and make sure you have verified your email address. A verification email
     might not have been sent by default, so you might have to click the "options" dropdown next to your address to get to
     the "re-send verification email" button
  3. 2-Factor authentication is required for PyPI since the end of 2023 (see
     this [blog post from PyPI](https://blog.pypi.org/posts/2023-05-25-securing-pypi-with-2fa/)). This means
     you have to first issue account recovery codes, then set up 2-factor authentication
  4. Issue an API token from https://pypi.org/manage/account/token



  You have to do the following steps once per machine. Create a file in your home directory called
  `.pypirc` and include the following:

  ```ini
  [distutils]
  index-servers =
      pypi
      testpypi

  [pypi]
  username = __token__
  password = <the API token you just got>


  [testpypi]
  repository = https://test.pypi.org/legacy/
  username = __token__
  password = <an API token from test PyPI>
  ```

  Note that since PyPI is requiring token-based authentication, we use `__token__` as the user, verbatim.
  If you already have a `.pypirc` file with a `[distutils]` section, just make sure that there is an `index-servers`
  key and that `pypi` is in its associated list. More information on configuring the `.pypirc` file can
  be found [here](https://packaging.python.org/en/latest/specifications/pypirc).



  After installing the package in development mode and installing
  `tox` with `python3 -m pip install tox tox-uv`,
  run the following from the console:

  ```console
  tox -e finish
  ```

  This script does the following:

  1. Uses [bump-my-version](https://github.com/callowayproject/bump-my-version) to switch the version number in
     the `pyproject.toml`, `CITATION.cff`, `src/curies/version.py`,
     and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel using
     [`uv build`](https://docs.astral.sh/uv/guides/publish/#building-your-package)
  3. Uploads to PyPI using [`twine upload`](https://github.com/pypa/twine).
     This will be replaced soon with `uv publish` (see https://github.com/cthoyt/cookiecutter-snekpack/issues/29)
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion -- minor` after.



  1. Navigate
     to https://github.com/biopragmatics/curies/releases/new
     to draft a new release
  2. Click the "Choose a Tag" dropdown and select the tag corresponding to the release you just made
  3. Click the "Generate Release Notes" button to get a quick outline of recent changes. Modify the title and description
     as you see fit
  4. Click the big green "Publish Release" button

  This will trigger Zenodo to assign a DOI to your release as well.

  </details>

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


pkgId: 7d92adb1498496c3911625d4cf91569d7abcf1de3f735bf0c7ca3c6db262cbc3
name: python-curies
arch: src
version: 0.9.2
epoch: 0
release: 1
summary: Idiomatic conversion between URIs and compact URIs (CURIEs)
url: https://github.com/biopragmatics/curies
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curies-0.9.2-1.src.rpm
checksum_type: sha256
description:
  <!--
  <p align="center">
    <img src="https://github.com/biopragmatics/curies/raw/main/docs/source/logo.png" height="150">
  </p>
  -->

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

  <p align="center">
      <a href="https://github.com/biopragmatics/curies/actions/workflows/tests.yml">
          <img alt="Tests" src="https://github.com/biopragmatics/curies/actions/workflows/tests.yml/badge.svg" /></a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/curies" /></a>
      <a href="https://pypi.org/project/curies">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/curies" /></a>
      <a href="https://github.com/biopragmatics/curies/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/curies" /></a>
      <a href='https://curies.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/curies/badge/?version=latest' alt='Documentation Status' /></a>
      <a href="https://codecov.io/gh/biopragmatics/curies/branch/main">
          <img src="https://codecov.io/gh/biopragmatics/curies/branch/main/graph/badge.svg" alt="Codecov status" /></a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-snekpack-blue" /></a>
      <a href="https://github.com/astral-sh/ruff">
          <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;"></a>
      <a href="https://github.com/biopragmatics/curies/blob/main/.github/CODE_OF_CONDUCT.md">
          <img src="https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg" alt="Contributor Covenant"/></a>
      <a href="https://zenodo.org/badge/latestdoi/519905487">
          <img src="https://zenodo.org/badge/519905487.svg" alt="DOI"></a>
  </p>

  Idiomatic conversion between URIs and compact URIs (CURIEs).

  ```python
  import curies

  converter = curies.load_prefix_map({
      "CHEBI": "http://purl.obolibrary.org/obo/CHEBI_",
      
  })

  >>> converter.compress("http://purl.obolibrary.org/obo/CHEBI_1")
  'CHEBI:1'

  >>> converter.expand("CHEBI:1")
  'http://purl.obolibrary.org/obo/CHEBI_1'
  ```

  Full documentation is available at [curies.readthedocs.io](https://curies.readthedocs.io).



  This package comes with a built-in CLI for running a resolver web application or a IRI mapper web application:

  ```shell

  python -m curies resolver --host 0.0.0.0 --port 8764 bioregistry


  python -m curies mapper --host 0.0.0.0 --port 8764 bioregistry
  ```

  The positional argument can be one of the following:

  1. A pre-defined prefix map to get from the web (bioregistry, go, obo, monarch, prefixcommons)
  2. A local file path or URL to a prefix map, extended prefix map, or one of several formats. Requires specifying
     a `--format`.

  The framework can be swapped to use Flask (default) or FastAPI with `--framework`. The
  server can be swapped to use Werkzeug (default) or Uvicorn with `--server`. These functionalities
  are also available programmatically, see the docs for more information.



  Other packages that convert between CURIEs and URIs:

  - https://github.com/prefixcommons/prefixcommons-py (Python)
  - https://github.com/prefixcommons/curie-util (Java)
  - https://github.com/geneontology/curie-util-py (Python)
  - https://github.com/geneontology/curie-util-es5 (Node.js)
  - https://github.com/endoli/curie.rs (Rust)
  - https://github.com/cthoyt/curies4j (Java)
  - https://github.com/biopragmatics/curies.rs (Rust, Node.js, Python)



  The most recent release can be installed from
  [PyPI](https://pypi.org/project/curies/) with:

  ```console
  python3 -m pip install curies
  ```

  As of v0.8, this package only supports Pydantic v2. v0.6.x and v0.7.x had
  cross-version support for Pydantic v1 and v2. v0.5.x and before only supported
  Pydantic v1. See the
  [Pydantic migration guide](https://docs.pydantic.dev/2.0/migration/)
  for updating your code.



  Contributions, whether filing an issue, making a pull request, or forking, are appreciated. See
  [CONTRIBUTING.md](https://github.com/biopragmatics/curies/blob/master/.github/CONTRIBUTING.md)
  for more information on getting involved.





  This package heavily builds on the [trie](https://en.wikipedia.org/wiki/Trie)
  data structure implemented in [`pytrie`](https://github.com/gsakkis/pytrie).



  The code in this package is licensed under the MIT License.



  This package was created with [@audreyfeldroy](https://github.com/audreyfeldroy)'s
  [cookiecutter](https://github.com/cookiecutter/cookiecutter) package using [@cthoyt](https://github.com/cthoyt)'s
  [cookiecutter-snekpack](https://github.com/cthoyt/cookiecutter-snekpack) template.



  <details>
    <summary>See developer instructions</summary>

  The final section of the README is for if you want to get involved by making a code contribution.



  To install in development mode, use the following:

  ```console
  git clone git+https://github.com/biopragmatics/curies.git
  cd curies
  python3 -m pip install -e .
  ```



  This project uses `cruft` to keep boilerplate (i.e., configuration, contribution guidelines, documentation
  configuration)
  up-to-date with the upstream cookiecutter package. Update with the following:

  ```console
  python3 -m pip install cruft
  cruft update
  ```

  More info on Cruft's update command is
  available [here](https://github.com/cruft/cruft?tab=readme-ov-file#updating-a-project).



  After cloning the repository and installing `tox` with
  `python3 -m pip install tox tox-uv`,
  the unit tests in the `tests/` folder can be run reproducibly with:

  ```console
  tox -e py
  ```

  Additionally, these tests are automatically re-run with each commit in a
  [GitHub Action](https://github.com/biopragmatics/curies/actions?query=workflow%3ATests).



  The documentation can be built locally using the following:

  ```console
  git clone git+https://github.com/biopragmatics/curies.git
  cd curies
  tox -e docs
  open docs/build/html/index.html
  ```

  The documentation automatically installs the package as well as the `docs`
  extra specified in the [`pyproject.toml`](pyproject.toml). `sphinx` plugins
  like `texext` can be added there. Additionally, they need to be added to the
  `extensions` list in [`docs/source/conf.py`](docs/source/conf.py).

  The documentation can be deployed to [ReadTheDocs](https://readthedocs.io) using
  [this guide](https://docs.readthedocs.io/en/stable/intro/import-guide.html).
  The [`.readthedocs.yml`](.readthedocs.yml) YAML file contains all the configuration you'll need.
  You can also set up continuous integration on GitHub to check not only that
  Sphinx can build the documentation in an isolated environment (i.e., with `tox -e docs-test`)
  but also that [ReadTheDocs can build it too](https://docs.readthedocs.io/en/stable/pull-requests.html).



  1. Log in to ReadTheDocs with your GitHub account to install the integration
     at https://readthedocs.org/accounts/login/?next=/dashboard/
  2. Import your project by navigating to https://readthedocs.org/dashboard/import then clicking the plus icon next to
     your repository
  3. You can rename the repository on the next screen using a more stylized name (i.e., with spaces and capital letters)
  4. Click next, and you're good to go!





  [Zenodo](https://zenodo.org) is a long-term archival system that assigns a DOI to each release of your package.

  1. Log in to Zenodo via GitHub with this link: https://zenodo.org/oauth/login/github/?next=%2F. This brings you to a
     page that lists all of your organizations and asks you to approve installing the Zenodo app on GitHub. Click "grant"
     next to any organizations you want to enable the integration for, then click the big green "approve" button. This
     step only needs to be done once.
  2. Navigate to https://zenodo.org/account/settings/github/, which lists all of your GitHub repositories (both in your
     username and any organizations you enabled). Click the on/off toggle for any relevant repositories. When you make
     a new repository, you'll have to come back to this

  After these steps, you're ready to go! After you make "release" on GitHub (steps for this are below), you can navigate
  to https://zenodo.org/account/settings/github/repository/biopragmatics/curies
  to see the DOI for the release and link to the Zenodo record for it.



  You only have to do the following steps once.

  1. Register for an account on the [Python Package Index (PyPI)](https://pypi.org/account/register)
  2. Navigate to https://pypi.org/manage/account and make sure you have verified your email address. A verification email
     might not have been sent by default, so you might have to click the "options" dropdown next to your address to get to
     the "re-send verification email" button
  3. 2-Factor authentication is required for PyPI since the end of 2023 (see
     this [blog post from PyPI](https://blog.pypi.org/posts/2023-05-25-securing-pypi-with-2fa/)). This means
     you have to first issue account recovery codes, then set up 2-factor authentication
  4. Issue an API token from https://pypi.org/manage/account/token



  You have to do the following steps once per machine.

  ```console
  $ uv tool install keyring
  $ keyring set https://upload.pypi.org/legacy/ __token__
  $ keyring set https://test.pypi.org/legacy/ __token__
  ```

  Note that this deprecates previous workflows using `.pypirc`.



  After installing the package in development mode and installing
  `tox` with `python3 -m pip install tox tox-uv`,
  run the following from the console:

  ```console
  tox -e finish
  ```

  This script does the following:

  1. Uses [bump-my-version](https://github.com/callowayproject/bump-my-version) to switch the version number in
     the `pyproject.toml`, `CITATION.cff`, `src/curies/version.py`,
     and [`docs/source/conf.py`](docs/source/conf.py) to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel using
     [`uv build`](https://docs.astral.sh/uv/guides/publish/#building-your-package)
  3. Uploads to PyPI using [`uv publish`](https://docs.astral.sh/uv/guides/publish/#publishing-your-package).
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion -- minor` after.



  1. Navigate
     to https://github.com/biopragmatics/curies/releases/new
     to draft a new release
  2. Click the "Choose a Tag" dropdown and select the tag corresponding to the release you just made
  3. Click the "Generate Release Notes" button to get a quick outline of recent changes. Modify the title and description
     as you see fit
  4. Click the big green "Publish Release" button

  This will trigger Zenodo to assign a DOI to your release as well.

  </details>

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


pkgId: 392fedbb3b79371cfa6089ba5e7d96de1d3d67fcb0a7fb9902f2c7433d3ecb19
name: python-curifactory
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: An experiment workflow and organization tool
url: https://github.com/ORNL/curifactory
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curifactory-0.18.0-1.src.rpm
checksum_type: sha256
description:
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI version](https://badge.fury.io/py/curifactory.svg)](https://badge.fury.io/py/curifactory)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/curifactory.svg)](https://anaconda.org/conda-forge/curifactory)
  [![status](https://joss.theoj.org/papers/e6ace365c4f632391a289ddea5bbfd1c/status.svg)](https://joss.theoj.org/papers/e6ace365c4f632391a289ddea5bbfd1c)
  [![tests](https://github.com/ORNL/curifactory/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/ORNL/curifactory/actions/workflows/tests.yml)
  [![Python versions](https://img.shields.io/pypi/pyversions/curifactory.svg)](https://github.com/ORNL/curifactory)
  [![License](https://img.shields.io/pypi/l/curifactory)](https://github.com/ORNL/curifactory/blob/main/LICENSE)

  Curifactory is a library and CLI tool designed to help organize and manage
  research experiments in python.

  ![screenshot flow](https://raw.githubusercontent.com/ORNL/curifactory/main/sphinx/source/images/diagram.png)

  Experiment management must fulfill several tasks, including experiment orchestration,
  parameterization, caching, reproducibility, reporting, and parallelization.
  Existing projects such as MLFlow, MetaFlow, Luigi, and Pachyderm
  support these tasks in several different ways and to various degrees.
  Curifactory provides a different opinion, with a heavier focus on supporting general
  research experiment workflows for individuals or small teams working primarily
  in python.

  You can read more about these design principles in our paper in the [SciPy 2022
  proceedings](https://conference.scipy.org/proceedings/scipy2022/nathan_martindale.html).



  * Adds a CLI layer on top of your codebase, a single entrypoint for running experiments
  * Automatic caching of intermediate data and lazy loading of stored objects
  * Jupyter notebook output for further exploration of an experiment run
  * Docker container output with copy of codebase, conda environment, full experiment run cache, and jupyter run notebook
  * HTML report output from each run with graphviz-rendered diagram of experiment
  * Easily report plots and values to HTML report
  * Configuration files are python scripts, allowing programmatic definition, parameter composition, and parameter inheritance
  * Output logs from every run
  * Run experiments directly from CLI or other python code, notebooks, etc.




  ```python
  pip install curifactory
  ```

  Graphviz is required for certain features and can be installed through conda
  via:

  ```python
  conda install python-graphviz
  ```



  For tab-completion in bash/zsh, install the `argcomplete` package (if using curifactory inside
  a conda environment, you'll need to install this in your system python.)

  ```python
  pip install argcomplete
  ```

  To enable, you can either use argcomplete's global hook `activate-global-python-argcomplete`, which
  will enable tab complete on all argcomplete-enabled python packages (e.g. pytest), or you can add
  `eval "$(register-python-argcomplete experiment)"` to your shell's rc file. Curifactory can add
  this line for you automatically with:

  ```bash
  curifactory completion [--bash|--zsh]  # use the shell flag appropriate
  ```

  Once enabled, the `experiment` command will provide tab complete for experiment names, parameter names, and flags.



  **OS**: We primarily develop and test Curifactory on Linux, but it runs on Windows and MacOS as well.

  **Python**: 3.9-3.11

  **Optional**:

  * Conda/Mamba
  * Graphviz
  * Docker
  * Jupyter notebook/lab




  The documentation for the latest version of Curifactory can be found at:
  [https://ornl.github.io/curifactory/stable/index.html](https://ornl.github.io/curifactory/stable/index.html).




  Several small example can be found in the `examples` folder.
  `examples/notebooks` includes walkthroughs demonstrating usage of curifactory
  solely in Jupyter.




  Please use the following BibTeX if citing this project:
  ```bibtex
  @article{Martindale2023,
    doi = {10.21105/joss.05793},
    url = {https://doi.org/10.21105/joss.05793},
    year = {2023},
    publisher = {The Open Journal},
    volume = {8},
    number = {90},
    pages = {5793},
    author = {Nathan Martindale and Scott L. Stewart and Jason Hite and Mark B. Adams},
    title = {Curifactory: A research experiment manager},
    journal = {Journal of Open Source Software}
  }
  ```




  Curifactory is one tool and one opinion among many, other projects that have similar goals and/or approaches:

  * [Kedro](https://github.com/kedro-org/kedro)
  * [Tango](https://github.com/allenai/tango)
  * [Sacred](https://github.com/IDSIA/sacred)
  * [MLFlow](https://github.com/mlflow/mlflow)


pkgId: 3fab8fbc0ea487649b732ae37c899c760e4129627ea7a83675a7b57b60220f1d
name: python-curio
arch: src
version: 1.6
epoch: 0
release: 1
summary: Curio
url: https://github.com/dabeaz/curio
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curio-1.6-1.src.rpm
checksum_type: sha256
description:
  Curio is a coroutine-based library for concurrent systems programming.  No longer
  maintained as a PyPi project.  Latest version is available on GitHub.


pkgId: 9f97ea3b525e9e52441820f0ce30dcbf259d369937ab4af119dc9a49bedb1b70
name: python-curl-cffi
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: libcurl ffi bindings for Python, with impersonation support.
url: https://pypi.org/project/curl-cffi/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curl-cffi-0.7.2-1.src.rpm
checksum_type: sha256
description:
  <a href="https://scrapfly.io/?utm_source=github&utm_medium=sponsoring&utm_campaign=curl_cffi" target="_blank"><img src="https://raw.githubusercontent.com/lexiforest/curl_cffi/main/assets/scrapfly.png" alt="Scrapfly.io" width="149"></a>
  [Scrapfly](https://scrapfly.io/?utm_source=github&utm_medium=sponsoring&utm_campaign=curl_cffi)
  is an enterprise-grade solution providing Web Scraping API that aims to simplify the
  scraping process by managing everything: real browser rendering, rotating proxies, and
  fingerprints (TLS, HTTP, browser) to bypass all major anti-bots. Scrapfly also unlocks the
  observability by providing an analytical dashboard and measuring the success rate/block
  rate in detail.
  Scrapfly is a good solution if you are looking for a cloud-managed solution for `curl_cffi`.
  If you are managing TLS/HTTP fingerprint by yourself with `curl_cffi`, they also maintain a

rpm_license:
  MIT License  Copyright (c) 2018 multippt Copyright (c) 2022 perker  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: e6747b60e908cfb040267c3756e7f0a0ff7f2e7fb0407e300889498cda80a90e
name: python-curl-to-json
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Convert curl command to json data
url: https://github.com/KingJem/curl-to-json
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curl-to-json-0.1.0-1.src.rpm
checksum_type: sha256
description:
  将参数转化为json 的时候尽量使用 -- 之后的值，作为字典的键。
  这个库的目的是将curl 发送请求的参数转化为json 格式，方便在python 中使用。

  curl 功能很强大，支持的参数也很多，这里只做了部分的解析

  重点放在curl HTTP发送请求的方面.

  其他一些特性，--ipv4,--ipv6,本地文件读取，指定dns 寻址服务器
  DoH,ftp 等协议暂未支持

  支持的参数

  - `-X`, `  --request` 支持的请求方法，

  - `--http2` 是否使用http2 协议 默认为否

  - `-d`,`--data` 支持, 支持在一行命令中多次使用`-d` 参数，此时HTTP 请求头中
    `Content-Type : application/x-www-form-urlencoded`

    使用该参数，请求自动转化为POST.

  - `-H`,`--header`  添加HTTP请求头,支持多行

  - `-I`,`--head` 发送HEAD请求，并打印header，支持

  - `-s`,`--silent`, 不输出任何东西，只返回HTTP 头

  - `-v`, `--verbose` 输出通信的整个过程，用于调试

  - `-b`, `--cookie` cookie 支持多个-b 参数，不支持文件读取

  - `-A`, `--user-agent` 设置User-Agent,curl 默认的User-Agent 为 curl/version,本项目默认为空

  - `--compressed` 是否压缩请求

  - `-k`, `--insecure` 允许不验证服务器的证书

  - `-u`, `--user` 用户名:密码

  - `-L`, `--location` 允许自动跟随重定向

  - `-I`,`--include` 打印头信息

  - `-x`，`--proxy` 使用代理 代理 格式为：hostname:port，如果没有scheme 默认使用http

  - `-U`, `--proxy-user` 代理用户名密码 ,格式为：username:password 如果有会自动将账号密码添加到代理url 中

  - `-u`, `--user` basic 认证，格式为：username:password，输出为headers 中的Authorization

  - `--connect-timeout` 连接超时时间

  - `--referer` 请求头中的referer



  1. 命令行中使用
  ```shell
  python -m curl_to_json  curl_to_json curl -X GET http://example.com
  ```
  2. 也可以直接使用
  ```shell
  curl_to_json curl -X GET http://example.com
  ```

  3. 也可以使用 以下格式
  ```shell
  curl_to_json "curl -X GET http://example.com"
  ```

  4. 在python 代码中使用
  ```python
  from curl_to_json import parse

  cmd = 'curl -X GET http://example.com'

  print(parse(cmd))

  ```




  *1. [curl 的用法指南](https://www.ruanyifeng.com/blog/2019/09/curl-reference.html)*

  *2. [Linux命令大全-curl](https://hezhiqiang.gitbook.io/linux/ming-ling/curl)*

  *3. [Uncurl](https://github.com/spulec/uncurl)*

  *4. [curl 在线手册](https://man.cx/curl)*


pkgId: 4d705e8035afafb627efc0126fa16d5cee513406228cea19e55a6a26ed44da48
name: python-curl2pyreqs
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: A Library to Convert Curl to Python Requests File
url: https://github.com/knightz1224/curl2pyreqs
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curl2pyreqs-0.4.1-1.src.rpm
checksum_type: sha256
description:
  A library to convert curl to python requests file.



  Python >= 3.6

  pyperclip >= 1.8.0

  rich >= 9.13.0

  On Linux, xclip or xsel needed:

  ```Shell
  sudo apt-get install xclip
  or
  sudo apt-get install xsel

  ```



  ```Bash
  $ pip install curl2pyreqs
  ```





  -   Export curl request file to python script.

  ```Bash
  $ curl2pyreqs -F example.curl
  Convertion Finished.
  Please open example.py to check the code.
  ```

  -   Convert curl request in the clipboard and paste the requests code back

  ```Bash
  $ curl2pyreqs
  Convertion Finished.
  Now requests code is copyed in your clipboard.
  ```



  -   Convert a curl string to python-requests, copyed from Chrome or Firefox:

  ```Python
  >>> from curl2pyreqs.ulti import parseCurlString
  >>> output = parseCurlString("""curl -H 'user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:87.0) Gecko/20100101 Firefox/87.0' -H 'accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8' -H 'accept-language: en-US,en;q=0.5' --compressed -H 'upgrade-insecure-requests: 1' -H 'te: trailers' https://pypi.org/""")
  >>> print(output)
  ```

  -   Convert curl file stream to python-requests, copyed from Chrome or Firefox:

  ```Python
  >>> from curl2pyreqs.ulti import parseCurlFile
  >>> output = parseCurlFile('./example.curl')
  >>> print(output)
  ```



  [中文版说明](https://github.com/knightz1224/curl2pyreqs/blob/main/README_CN.md)


pkgId: 14c1335c3b900fcb34ea2989e868a55c5f8140c11a6681d16dca6edfcc77ba88
name: python-curl2swift
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: Tool for transforming cURL to Swift code.
url: https://github.com/tomnvt/curl2swift
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curl2swift-0.4.4-1.src.rpm
checksum_type: sha256
description:
  `curl2swift` is a command line tool for transforming a cURL request to Swift code.
  It takes a cURL and generates code for the request, the request's response mapping and a test.

  Note that the generated code is not yet intended for general usage,
  because it depends on some code that is specific to the project for which this tool was initially designed.


  - Implement template configuration and customization.
  - Try out various cURLs to add handling for unexpected arguments.
  - Add configuration options for specifying output file.
  - Enable path param specification (e.g. using {...} to denote a path param placeholder.)


  1. Copy a cURL into the clipboard.
  2. Call `curl2swift` and pass a request name and (optional) description, e.g. `curl2swift TestRequest "Call test request"`.
  3. Processed request template is printed out with a promt if user wants to copy it.
  4. Processed test template is printed out with the same promt.


  After step 3:
  ```
  /// Add docs
  class TestRequest: RequestSpecBuilder {


      struct Response: Codable {
          let login : String?
          let id : Int?
          let nodeNode : String?
          let avatarAvatar : String?
          let gravatarGravatar : String?
          let url : String?
          let htmlHtml : String?
          let followersFollowers : String?
          let followingFollowing : String?
          let gistsGists : String?
          let starredStarred : String?
          let subscriptionsSubscriptions : String?
          let organizationsOrganizations : String?
          let reposRepos : String?
          let eventsEvents : String?
          let receivedReceived : String?
          let type : String?
          let siteSite : Bool?
          let name : String?
          let company : String?
          let blog : String?
          let location : String?
          let email : String?
          let hireable : String?
          let bio : String?
          let twitterTwitter : String?
          let publicPublic : Int?
          let publicPublic : Int?
          let followers : Int?
          let following : Int?
          let createdCreated : String?
          let updatedUpdated : String?

          enum CodingKeys: String, CodingKey {
              case login = "login"
              case id = "id"
              case nodeNode = "node_id"
              case avatarAvatar = "avatar_url"
              case gravatarGravatar = "gravatar_id"
              case url = "url"
              case htmlHtml = "html_url"
              case followersFollowers = "followers_url"
              case followingFollowing = "following_url"
              case gistsGists = "gists_url"
              case starredStarred = "starred_url"
              case subscriptionsSubscriptions = "subscriptions_url"
              case organizationsOrganizations = "organizations_url"
              case reposRepos = "repos_url"
              case eventsEvents = "events_url"
              case receivedReceived = "received_events_url"
              case type = "type"
              case siteSite = "site_admin"
              case name = "name"
              case company = "company"
              case blog = "blog"
              case location = "location"
              case email = "email"
              case hireable = "hireable"
              case bio = "bio"
              case twitterTwitter = "twitter_username"
              case publicPublic = "public_repos"
              case publicPublic = "public_gists"
              case followers = "followers"
              case following = "following"
              case createdCreated = "created_at"
              case updatedUpdated = "updated_at"
          }
      }


      required init(baseURL: String = "",
                    path: String = "",
                    method: HTTPMethod = .get,
                    headers: [String: String] = [:],
                    params: [String: String] = [:]) {
          super.init(baseURL: baseURL, path: path, method: method, headers: headers, params: params)
          set(.path("/users/defunkt"))
          set(.method(.get))
      }
  }

  extension TestRequest {
  }


  - - - - - - - - - - - -
  END OF GENERATED OUTPUT
  - - - - - - - - - - - -

  Copy output to clipboard? [y/n]
  ```

  Note that the extension contains setters for headers and body paramaeters, if the request has any.

  After step 4:
  ```
  - - - - - - - -
  GENERATED TEST:
  - - - - - - - -

      func testTestRequest() {
          let expectation = XCTestExpectation(description: "waiting for reponse")
          TestRequest()
              .set(.baseURL("https://api.github.com"))
              .set(.path("/users/defunkt"))
              .makeRxRequest()
              .mapTo(TestRequest.Response.self)
              .do(onSuccess: { _ in expectation.fulfill() })
              .discardableSubscribe()
          wait(for: [expectation], timeout: 10)
      }


  - - - - - - - - - - - -
  END OF GENERATED OUTPUT
  - - - - - - - - - - - -

  Copy to clipboard? [y/n]
  ```


pkgId: 1136789940823f7e6a86f532dbdea1a6dea8d670c4d931e3f41f2606cb5c1c31
name: python-curlify2
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Library to convert python requests and httpx object to curl command.
url: https://github.com/marcuxyz/curlify2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curlify2-2.0.0-1.src.rpm
checksum_type: sha256
description:
  The library convert python 'requests' and 'httpx' object in curl command. Curlify2 is a enhancement of [curlify]('https://github.com/ofw/curlify').




  To install the library use pip or poetry command, see:

  ```bash
  $ pip install curlify2
  ```

  or poetry:

  ```bash
  $ poetry add curlify2
  ```



  using **requests** module:

  ```python
  from curlify2 import Curlify
  import requests

  URL = "https://run.mocky.io/v3/b0f4ffd8-6696-4f90-8bab-4a3bcad9ef3f"

  request = requests.get(URL)
  response = Curlify(request.request)

  print(response.to_curl()) # curl -X GET -H "User-Agent: python-requests/2.24.0" -H "Accept-Encoding: gzip, deflate" -H "Accept: */*" -H "Connection: keep-alive" -d 'None' https://run.mocky.io/v3/b0f4ffd8-6696-4f90-8bab-4a3bcad9ef3f
  ```

  using **httpx** module:

  ```python
  import curlify2
  import httpx

  URL = "https://run.mocky.io/v3/b0f4ffd8-6696-4f90-8bab-4a3bcad9ef3f"

  request = httpx.get(URL)
  response = Curlify(request.request)

  print(response.to_curl()) # curl -X GET -H "User-Agent: python-requests/2.24.0" -H "Accept-Encoding: gzip, deflate" -H "Accept: */*" -H "Connection: keep-alive" -d 'None' https://run.mocky.io/v3/b0f4ffd8-6696-4f90-8bab-4a3bcad9ef3f
  ```


pkgId: a6bef91597e33d76fee160fb5af508d52016ba5467ab1b0538a59f3be05a9f01
name: python-curlparser
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Parse cURL commands returning object representing the request.
url: https://github.com/nlecoy/curlparser
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curlparser-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Parse cURL commands returning object representing the request.



  `curlparser` is available on PyPi:



  ```shell
  $ pip install curlparser
  ```


  ```shell
  $ poetry add curlparser
  ```



  ```shell
  $ pipenv install curlparser
  ```



  ```python
  >>> import curlparser

  >>> result = curlparser.parse(
      """
      curl \
        --header 'Content-Type: application/json' \
        --request PUT \
        --user nlecoy:my_password \
        --data '{"username":"xyz", "password":"xyz"}' \
        https://api.github.com/repos/nlecoy/curlparser
      """
  )

  >>> result.url
  'https://api.github.com/repos/nlecoy/curlparser'

  >>> result.auth
  ('nlecoy', 'my_password')

  >>> result.json
  {'username': 'xyz', 'password': 'xyz'}
  ```



  `curlparser`'s parse method will return a `ParsedCommand` object containing the following fields:

  - method
  - url
  - auth
  - cookies
  - data
  - json
  - header
  - verify



  cURL Parser is distributed under the Apache 2.0. See [LICENSE](LICENSE) for more information.


pkgId: bcdac818bbb935a1849bcb95ab52755811c9e920777102c69fcb9c49d13f9a55
name: python-curly-comparer
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A little package with string comparison tools
url: https://github.com/Pedro-UwU/curly-comparer
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curly-comparer-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A lightweight Python package for advanced string comparison and distance calculation.



  `curly_comparer` provides flexible string comparison algorithms, primarily focusing on Levenshtein distance calculations with customizable cost functions.



  - **Basic Levenshtein Distance**: Quick string comparison
  - **Weighted Levenshtein Distance**: Customizable cost functions for:
    - Character insertions
    - Character deletions
    - Character substitutions



  Install `curly_comparer` using pip:

  ```bash
  pip install curly_comparer
  ```



  - Python 3.10+
  - NumPy 2.1+





  ```python
  from curly_comparer.algorithms.levenshtein import distace


  distance = distace("hello", "hallo")
  print(distance)  # Outputs: 1
  ```



  ```python
  from curly_comparer.algorithms.levenshtein import weighted_distance


  def custom_insertion_cost(char):
      return 1.5  # Different cost for inserting characters

  def custom_substitution_cost(char1, char2):
      return 2.0  # Custom substitution cost

  distance = weighted_distance(
      "hello",
      "hallo",
      insertion_fn=custom_insertion_cost,
      deletion_fn=lambda x: 1.0,
      subs_fn=custom_substitution_cost
  )
  ```



  The `weighted_distance` function allows complete flexibility in defining costs for string transformations:

  - `insertion_fn`: Cost of inserting a character
  - `deletion_fn`: Cost of deleting a character
  - `subs_fn`: Cost of substituting one character for another



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



  Licensed under the Apache License 2.0



  Pedro Lopez (pdihax@gmail.com)


pkgId: cb52732bc631404e0a08bfc9c7736fc089bc5d3f470126d6f1995eadafc8f1e3
name: python-curlylint
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: {{ 🎀}} Experimental HTML templates linting for Jinja, Nunjucks, Django templates, Twig, Liquid
url: https://github.com/thibaudcolas/curlylint
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curlylint-0.13.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/curlylint.svg)](https://pypi.org/project/curlylint/) [![PyPI downloads](https://img.shields.io/pypi/dm/curlylint.svg)](https://pypi.org/project/curlylint/) [![Build status](https://github.com/thibaudcolas/curlylint/workflows/CI/badge.svg)](https://github.com/thibaudcolas/curlylint/actions) [![Coverage Status](https://coveralls.io/repos/github/thibaudcolas/curlylint/badge.svg?branch=main)](https://coveralls.io/github/thibaudcolas/curlylint?branch=main) [![Total alerts](https://img.shields.io/lgtm/alerts/g/thibaudcolas/curlylint.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/thibaudcolas/curlylint/alerts/)

  > **{{ 🎀}}** Experimental HTML templates linting for [Jinja](https://jinja.palletsprojects.com/), [Nunjucks](https://mozilla.github.io/nunjucks/), [Django templates](https://docs.djangoproject.com/en/dev/topics/templates/), [Twig](https://twig.symfony.com/), [Liquid](https://shopify.github.io/liquid/).
  > Forked from [jinjalint](https://github.com/motet-a/jinjalint).



  [Curlylint](https://www.curlylint.org/) is an HTML linter for [“curly braces”](https://www.curlylint.org/docs/template-languages) templates, and their HTML. It focuses on [rules](https://www.curlylint.org/docs/rules/all) to check for common accessibility issues.

  ![Screenshot of the curlylint CLI, with an example invocation raising a parsing issue and a rule error](.github/curlylint-screenshot.png)

  On the roadmap:

  - More checks for common accessibility issues in HTML.
  - Checks for common security issues – for example `rel="noopener noreferrer"`, or known sources of XSS vulnerabilities.
  - More [ideas welcome](https://www.curlylint.org/docs/reference/ideas)!



  Curlylint is available on [PyPI](<(https://pypi.org/project/curlylint/)>), grab it and you can start linting:

  ```bash

  pip install curlylint

  curlylint template-directory/
  ```

  Have a look at our [documentation](https://www.curlylint.org/docs/) to make the most of it:

  - [Getting Started](https://www.curlylint.org/)
  - [Command Line Usage](https://www.curlylint.org/docs/command-line-usage)
  - [Configuration](https://www.curlylint.org/docs/configuration)
  - [Template Languages](https://www.curlylint.org/docs/template-languages)
  - [Rules](https://www.curlylint.org/docs/rules/all)



  See anything you like in here? Anything missing? We welcome all support, whether on bug reports, feature requests, code, design, reviews, tests, documentation, and more. Please have a look at our [contribution guidelines](CONTRIBUTING.md).

  If you just want to set up the project on your own computer, the contribution guidelines also contain all of the setup commands.



  This project started as a fork of [jinjalint](https://github.com/motet-a/jinjalint). Image credit: [FxEmojis](https://github.com/mozilla/fxemoji). [Test templates](tests/README.md) extracted from third-party projects. Website hosted by [Netlify](https://www.netlify.com/).

  View the full list of [contributors](https://github.com/thibaudcolas/curlylint/graphs/contributors). [MIT](LICENSE) licensed. Website content available as [CC0](https://creativecommons.org/share-your-work/public-domain/cc0/).


pkgId: a53cebf098e30dc6d5b6853bfe0466178d5c8700b07442b5952943f5c9d9840c
name: python-currency-converter-lite
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A Library for currency conversion in Real Time
url: https://github.com/AmeerTechsoft/currency-converter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-currency-converter-lite-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A lightweight, offline-ready Python library for currency conversion with support for caching exchange rates.



  - Convert between any two currencies using Yahoo or Google Finance.
  - Caches exchange rates for offline use.
  - Simple and easy-to-use API.



  Install the library using pip:

  ```py
  pip install currency-converter-lite
  ```


  ``` py
  from currency_converter.converter import CurrencyConverter

  ```



  ``` py


  converter = CurrencyConverter(use_yahoo=True)

  ```

  ``` py


  converter = CurrencyConverter(use_yahoo=False)

  ```



  ``` py
  amount_in_eur = converter.convert(100, "USD", "EUR")
  print(f"100 USD is {amount_in_eur} EUR")

  ```

  This project is licensed under the MIT License.


  Copyright (c) 2024 Ameer Adeigbe

  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: ...


pkgId: 5e25c63331342d444e7ec2b7c46999ff418ef814c27644f4efc3e85faa639e62
name: python-currency-normalizer
arch: src
version: 0.0.0
epoch: 0
release: 1
summary: A module to normalize currency strings
url: https://pypi.org/project/currency-normalizer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-currency-normalizer-0.0.0-1.src.rpm
checksum_type: sha256
description:
  Whole purpose of this package is to normlize currency strings to the standard currency codes

  You can input USD or $ or USD dollars and it will be normalized. This is it.


  ```

  cn = CurrencyNormalizer()
  r=cn.normalize("$")
  print(r)



  ```


pkgId: dd8ab45e66767f235d9f72b5b4d7ab31a32fe3c64b2e837c2cd6db3b35201579
name: python-currency-quote
arch: src
version: 4.0.0
epoch: 0
release: 1
url: https://pypi.org/project/currency-quote-wrapper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-currency-quote-4.0.0-1.src.rpm
checksum_type: sha256
summary:
  Complete solution for extracting currency pair quotes data. With comprehensive testing, parameter validation, flexible configuration management, Hexagonal Architecture, CI/CD pipelines, code quality tools, and detailed documentation.

description:
  Complete solution for extracting currency pair quotes data.
  With comprehensive testing, parameter validation, flexible configuration management, Hexagonal Architecture, CI/CD pipelines, code quality tools, and detailed documentation.


  [![PyPI - Status](https://img.shields.io/pypi/status/currency-quote?style=for-the-badge&logo=pypi)](https://pypi.org/project/currency-quote/)

  [![PyPI - Downloads](https://img.shields.io/pypi/dm/currency-quote?style=for-the-badge&logo=pypi)](https://pypi.org/project/currency-quote/)

  [![PyPI - Version](https://img.shields.io/pypi/v/currency-quote?style=for-the-badge&logo=pypi)](https://pypi.org/project/currency-quote/#history)

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/currency-quote?style=for-the-badge&logo=python)

  [![CI](https://img.shields.io/github/actions/workflow/status/IvanildoBarauna/currency-quote-wrapper/CI.yaml?&style=for-the-badge&logo=githubactions&cacheSeconds=60&label=Tests+and+pre+build)](https://github.com/IvanildoBarauna/currency-quote-wrapper/actions/workflows/CI.yaml)
  [![CD](https://img.shields.io/github/actions/workflow/status/IvanildoBarauna/currency-quote-wrapper/CD.yaml?&style=for-the-badge&logo=githubactions&cacheSeconds=60&event=release&label=Package+publication)](https://github.com/IvanildoBarauna/currency-quote-wrapper/actions/workflows/CD.yaml)

  [![Codecov](https://img.shields.io/codecov/c/github/IvanildoBarauna/currency-quote-wrapper?style=for-the-badge&logo=codecov)](https://app.codecov.io/gh/IvanildoBarauna/currency-quote-wrapper)



  ![Python](https://img.shields.io/badge/-Python-05122A?style=flat&logo=python)&nbsp;
  ![Docker](https://img.shields.io/badge/-Docker-05122A?style=flat&logo=docker)&nbsp;
  ![Poetry](https://img.shields.io/badge/-Poetry-05122A?style=flat&logo=poetry)&nbsp;
  ![GitHub Actions](https://img.shields.io/badge/-GitHub_Actions-05122A?style=flat&logo=githubactions)&nbsp;
  ![CodeCov](https://img.shields.io/badge/-CodeCov-05122A?style=flat&logo=codecov)&nbsp;
  ![pypi](https://img.shields.io/badge/-pypi-05122A?style=flat&logo=pypi)&nbsp;
  ![pandas](https://img.shields.io/badge/-pandas-05122A?style=flat&logo=pandas)&nbsp;
  ![pytest](https://img.shields.io/badge/-pytest-05122A?style=flat&logo=pytest)&nbsp;




  - **Comprehensive Testing:** Development of tests to ensure the quality and robustness of the code

  - **Parameter Validation:** Sending valid parameters based on the request data source itself, ensuring the integrity and accuracy of the information processed.

  - **Configuration Management:** Use of a configuration module to manage endpoints, retry times and number of attempts, providing flexibility and ease of adjustment.

  - **Hexagonal Architecture:** Adoption of Hexagonal Architecture to decouple the core logic from external dependencies, ensuring that any current data source can be replaced seamlessly in case of unavailability. This is facilitated by the use of adapters, which act as intermediaries between the core application and the external services.

  - **Cotinuous Integration** and Continuous Deployment: Use of CI/CD pipelines to automate the build, test and deployment processes, ensuring that the application is always up to date and ready for use.

  - **Code Quality:** Use of code quality tools such as linters and formatters to ensure that the codebase is clean, consistent and easy to read.

  - **Documentation:** Creation of detailed documentation to facilitate the understanding and use of the application, including installation instructions, usage examples and troubleshooting guides.



  See the following docs:

  - [Contributing Guide](https://github.com/IvanildoBarauna/currency-quote-wrapper/blob/main/CONTRIBUTING.md)
  - [Code Of Conduct](https://github.com/IvanildoBarauna/currency-quote-wrapper/blob/main/CODE_OF_CONDUCT.md)




  ``` python

  from currency_quote import ClientBuilder


  client = ClientBuilder(currency_list="USD-BRL")

  client = ClientBuilder(currency_list=['USD-BRL', 'EUR-BRL'])


  print(client.get_last_quote())

  print(client.get_history_quote(reference_date=20220101))
  ```
  * This is expected payload for get Last Quote with USD-BRL currency pair
  ```json
  [
     {
        "currency_pair":"USD-BRL",
        "currency_pair_name":"Dólar Americano/Real Brasileiro",
        "base_currency_code":"USD",
        "quote_currency_code":"BRL",
        "quote_timestamp":1727201744,
        "bid_price":"5.4579",
        "ask_price":"5.4589",
        "quote_extracted_at":1727201753
     }
  ]
  ```

  * This is expected payload for get History Quote with USD-BRL currency pair

  ```json
  [
     {
        "currency_pair":"USD-BRL",
        "currency_pair_name":"Dólar Americano/Real Brasileiro",
        "base_currency_code":"USD",
        "quote_currency_code":"BRL",
        "quote_timestamp":1719440767,
        "bid_price":5.524,
        "ask_price":5.5245,
        "quote_extracted_at":1727201753
     }
  ]
  ```

  * This is expected payload for get last Quote with two or more currencies

  ```json
  [
     {
        "currency_pair":"USD-BRL",
        "currency_pair_name":"Dólar Americano/Real Brasileiro",
        "base_currency_code":"USD",
        "quote_currency_code":"BRL",
        "quote_timestamp":1727201384,
        "bid_price":"5.4594",
        "ask_price":"5.4599",
        "quote_extracted_at":1727201387
     },
     {
        "currency_pair":"USD-EUR",
        "currency_pair_name":"Dólar Americano/Euro",
        "base_currency_code":"USD",
        "quote_currency_code":"EUR",
        "quote_timestamp":1727201376,
        "bid_price":"0.8957",
        "ask_price":"0.8958",
        "quote_extracted_at":1727201387
     }
  ]
  ```
  * This is expected payload for history last Quote with two or more currencies
  ```json
  [
     {
        "currency_pair":"USD-BRL",
        "currency_pair_name":"Dólar Americano/Real Brasileiro",
        "base_currency_code":"USD",
        "quote_currency_code":"BRL",
        "quote_timestamp":1727201384,
        "bid_price":"5.4594",
        "ask_price":"5.4599",
        "quote_extracted_at":1727201387
     },
     {
        "currency_pair":"USD-EUR",
        "currency_pair_name":"Dólar Americano/Euro",
        "base_currency_code":"USD",
        "quote_currency_code":"EUR",
        "quote_timestamp":1727201376,
        "bid_price":"0.8957",
        "ask_price":"0.8958",
        "quote_extracted_at":1727201387
     }
  ]
  ```


  ![Arch](./hexagonal_design_arch.png)


pkgId: f954b0d461c92100425073fd2744cc583ae4011be11ecae6047ee4f1f587ecdf
name: python-currency-symbols
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Get currency symbol by currency code
url: https://github.com/arshadkazmi42/currency-symbols
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-currency-symbols-2.0.3-1.src.rpm
checksum_type: sha256
description:
  ﻿# currency-symbols :money_with_wings:

  [![Build](https://github.com/arshadkazmi42/currency-symbols/actions/workflows/pytest.yml/badge.svg)](https://github.com/arshadkazmi42/currency-symbols/actions/workflows/pytest.yml)
  [![Downloads](https://img.shields.io/pypi/dm/currency-symbols.svg)](https://pypi.org/project/currency-symbols/)
  [![Repo Size](https://img.shields.io/github/languages/code-size/arshadkazmi42/currency-symbols.svg)](https://github.com/arshadkazmi42/currency-symbols)
  [![LICENSE](https://img.shields.io/pypi/l/currency-symbols.svg)](https://pypi.org/project/currency-symbols/)
  [![Version](https://img.shields.io/pypi/v/currency-symbols.svg)](https://pypi.org/project/currency-symbols/)
  [![Last Commit](https://img.shields.io/github/last-commit/arshadkazmi42/currency-symbols.svg)](https://github.com/arshadkazmi42/currency-symbols)

  Get currency symbol by currency code `eg: USD -> $`


  [ISO 4217 - Currency Codes](https://www.iso.org/iso-4217-currency-codes.html)



  ```
  $ pip3 install currency-symbols
  ```



  ```python
  from currency_symbols import CurrencySymbols

  dollarSymbol = CurrencySymbols.get_symbol('USD')
  print(dollarSymbol)




  euroSymbol = CurrencySymbols.get_symbol('EUR')
  print(euroSymbol)




  britishPoundSymbol = CurrencySymbols.get_symbol('GBP')
  print(britishPoundSymbol)




  bitcoinSymbol = CurrencySymbols.get_symbol('BTC')
  print(bitcoinSymbol)



  ```



  Interested in contributing to this project?
  You can log any issues or suggestion related to this library [here](https://github.com/arshadkazmi42/currency-symbols/issues/new)

  Read our contributing [guide](https://github.com/arshadkazmi42/currency-symbols/blob/master/CONTRIBUTING.md) on getting started with contributing to the codebase




  Inspired by work of [@bengourley](https://github.com/bengourley) on [currency-symbol-map](https://github.com/bengourley/currency-symbol-map#readme)


pkgId: cf5c2c48b5847c30d2651dd391b08f9c5614b29640667b46ebaa40bb5864034d
name: python-currencyapicom
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: CurrencyAPI Python Client
url: https://github.com/everapihq/currencyapi-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-currencyapicom-0.1.1-1.src.rpm
checksum_type: sha256
description:
  CurrencyAPI Python Client is the official Python Wrapper around the CurrencyAPI [API](https://currencyapi.com/).



  Install from pip:
  ````sh
  pip install currencyapicom
  ````

  Install from code:
  ````sh
  pip install git+https://github.com/everapihq/currencyapi-python.git
  ````



  All curencyapi API requests are made using the `Client` class. This class must be initialized with your API access key string. [Where is my API access key?](https://app.currencyapi.com/dashboard)

  In your Python application, import `currencyapicom` and pass authentication information to initialize it:

  ````python
  import currencyapicom
  client = currencyapicom.Client('API_KEY')
  ````



  ```python

  print(client.status())

  ```


  [https://currencyapi.com/docs/currencies](https://currencyapi.com/docs/currencies)
  ```python

  result = client.currencies(currencies=['EUR', 'CAD'])
  print(result)

  ```


  [https://currencyapi.com/docs/latest](https://currencyapi.com/docs/latest)

  ```python

  result = client.latest()
  print(result)

  ```


  [https://currencyapi.com/docs/historical](https://currencyapi.com/docs/historical)

  ```python

  result = client.historical('2022-02-02')
  print(result)

  ```


  [https://currencyapi.com/docs/range](https://currencyapi.com/docs/range)

  ```python

  result = client.range('2022-02-02', '2022-02-04')
  print(result)

  ```


  [https://currencyapi.com/docs/convert](https://currencyapi.com/docs/convert)

  ```python

  result = client.convert(1234)
  print(result)

  ```



  Any feedback? Please feel free to [contact our team](mailto:office@everapi.com).


pkgId: bff5e4660572ff2912f89c0662afec018cc692f2826a885cd70eac0f0cd248c2
name: python-current
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Current module relative paths and imports
url: https://github.com/xflr6/current
rpm_license: CC0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-current-0.4.1-1.src.rpm
checksum_type: sha256
description:
  |PyPI version| |License| |Supported Python| |Wheel|
  |Build| |Codecov|
  Get the path of a file relative to the current module. Import a Python module
  relative to the current module. Temporarily change ``sys.path`` for imports.
  Get the path of a file relative to the module of the current caller.


pkgId: 396d7f1f07548fa6051d73ad04251025dbaabe7fb456fb0a0f35c44f69afb9d4
name: python-currentscape
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: Module to easily plot currentscape.
url: https://github.com/BlueBrain/Currentscape
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-currentscape-1.0.16-1.src.rpm
checksum_type: sha256
description:
  +----------------+------------+
  | Latest Release | |pypi|     |
  +----------------+------------+
  | Documentation  | |docs|     |
  +----------------+------------+
  | License        | |license|  |
  +----------------+------------+
  | Build Status 	 | |build|    |
  +----------------+------------+
  | Coverage       | |coverage| |
  +----------------+------------+
  | Gitter         | |gitter|   |
  +----------------+------------+
  | Citation       | |zenodo|   |
  +----------------+------------+

rpm_license:
  Currentscape is licensed under the Apache License, unless noted otherwise, e.g., for external dependencies. See file COPYING for the full license. The 'original paper plot' example is under the CC0 1.0 license, and the 'use case' example is under the CC-BY-NC-SA license, as specified by the LICENSE.txt file in each example repository.   Copyright 2023 Blue Brain Project / EPFL  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: 80396cd7774e0a234909fa6a0669c98793c73367d74a801868da6679426b7319
name: python-curricula
arch: src
version: 2.1.2
epoch: 0
release: 1
summary: A content manager and grading toolkit for evaluating student code
url: https://github.com/curriculagg/curricula
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curricula-2.1.2-1.src.rpm
checksum_type: sha256
description:
  [![Codacy Badge](https://api.codacy.com/project/badge/Grade/e6d63124ef0c4a939f726c1609841978)](https://www.codacy.com/manual/csci104/curricula?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=csci104/curricula&amp;utm_campaign=Badge_Grade)

  Curricula is a set of specifications and tools for managing content and grading assignments in a college-level computer science setting.
  It is currently being developed by [Noah Kim](https://noahbkim.github.io) for CSCI 104, the most challenging core-track C++ course at USC for CS majors.



  Curricula covers the two main aspects of managing assignments for a programming course.

  1. **Assignment creation**: Curricula provides a schema for developing assignments per-problem rather than all at once.
     This allows content producers to easily port assignments from previous semesters to the evolving parameters of the current.
     Assignments can then be built up from their components problems, separating each and combining their independent parts into packages for publishing, grading, etc.

  2. **Submission grading**: the other function of Curricula is to provide a robust framework for testing all aspects of submitted code.
     This includes checks for things like correctness, time complexity, resources leakage, and even code style, all while facilitating granular configuration.
     These tests are written to a universal output format so that they can be reinterpreted without having to re-run the code.



  Curricula can be used by installing the [command line interface](https://github.com/csci104/curricula-shell).
  This repository only contains the core functionality.


pkgId: 3ad187b097342604a1c215380e9435cb1d68ced1b6d8863845a8f732e3306b1f
name: python-cursedspace
arch: src
version: 1.5.2
epoch: 0
release: 1
summary: Library for TUI programs on basis of curses
url: https://vonshednob.cc/cursedspace
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cursedspace-1.5.2-1.src.rpm
checksum_type: sha256
description:
  A python library/framework for TUI application on the basis of the curses
  package.




  Here’s a very simple example of how to use the cursedspace package:

      

      import curses
      from cursedspace import Application, Key, Panel, colors


      class DemoApplication(Application):
          def __init__(self):
              super().__init__()
              self.panel = None

          def main(self):
              self.panel = Panel(self)
              self.resize()

              self.screen.addstr(0, 0, "Just some color example", colors.attr(colors.RED))

              while True:
                  curses.doupdate()

                  key = self.read_key()

                  if key == Key.RESIZE:
                      self.resize()
                  elif key in [Key.ESCAPE, "q", "^C"]:
                      break

          def resize(self):
              height, width = self.size()
              self.panel.resize(height, width)
              self.panel.paint()


      
      DemoApplication().run()

  For more examples see the `examples` folder.



   * `Application` is the main application class and provides boilerplate
     initialisations
   * `Panel` is a basic panel with support for borders and key handling in the
     context of an `Application`
   * `InputLine` is a panel with very basic editing support.
   * `Key` provides a convenient wrapper around curses’ key system. It can be
     used standalone even when you don’t want to use `Application` or `Panel`.
   * `ShellContext` is a convenient wrapper to execute external processes (e.g.
     through subprocess) and returning to the curses context afterwards again.
   * `colors` is a generic way to define colors in pairs (foreground and
     background) and have them automatically registerd for use in curses. You
     only have to call `colors.attr(ColorPair(...))` to use a new color
     combination (limited by the terminal, of course).


pkgId: 8ab7878e10f30d8f211a70b7340c33f37ec4943fd7d169114ebeec784bfb0164
name: python-curses-menu
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: A simple console menu system using curses
url: http://github.com/pmbarrett314/curses-menu
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curses-menu-0.9.0-1.src.rpm
checksum_type: sha256
description:
  A simple Python menu-based GUI system on the terminal using curses.
  Perfect for those times when you need a GUI, but don’t want the overhead
  or learning curve of a full-fledged GUI framework. However, it's also
  flexible enough to do cool stuff like on-the-fly changing of menus and is extensible to
  a large variety of uses.
  http://curses-menu.readthedocs.org/en/latest/
  Installation
  ~~~~~~~~~~~~
  Tested on Python 3.8+ pypy and pypy3.
  The curses library comes bundled with python on Linux and MacOS. Windows
  users can visit http://www.lfd.uci.edu/~gohlke/pythonlibs/#curses and
  get a third-party build for your platform and Python version.
  Then just run
     pip install curses-menu


pkgId: f00f6e86dc3fbb566be7dea39dbcdf2f57f48f2698f93b1073d4242c720312bf
name: python-curses-playlist
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: curses based interactive playlist creation for videos
url: https://pypi.org/project/curses-playlist/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curses-playlist-0.4.2-1.src.rpm
checksum_type: sha256
description:
  curses based interactive playlist creation for video files.



  ```
  plist.exe --playlist c:\tmp\test.m3u --working-directory Z:\movies
  ```



  Interactively create a `playlist.m3u` then launch it using `vlc.exe`.
  Automatically loads last playlist on startup.
  There are 2 modes which you can toggle using the `ESC` key:
  ```
  [INPUT: ENTER - add | ESC - CMD]
  [CMD: m - mod | q | w | p - play | r - reset]
  ```

  In `INPUT` Mode, filenames in the playlist are searched for substrings that you enter, separated by a single whitespace.

  E.g.: `rick` `morty` `s01e01` would yield all filenames that contain all 3 strings.

  In `CMD` mode you have the following options:

  * `m` move
    * `j` navigate/move down
    * `k` navigate/move up
    * `d` del
    * `m` toggle navigate/move
  * `p` play: start vlc player with playlist
  * `r` reset: reset the playlist
  * `q` quit: doing nothing



  https://github.com/dosnpfand/curses-playlist


pkgId: 918d6778d9b460a72e66b8b9ab8107958b1eee703d5e08d7cf10a35adde2b904
name: python-cursesplus
arch: src
version: 3.16.5
epoch: 0
release: 1
summary: An extension program to curses that offers option menus, message boxes, file dialogues and more
url: https://github.com/Enderbyte-Programs/Curses-Plus
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cursesplus-3.16.5-1.src.rpm
checksum_type: sha256
description:
  Extension library to curses


  Use ```pip3 install cursesplus```
  on Linux or ```py -m pip install cursesplus```
  on Windows



  For Windows you need to also install ```windows-curses``` or related program
  to provide the basic curses functionality





  - Fix critical bug in input

  - Textview is now more colourful



  - Add the ability to do home, end, pgup, and pgdown on textview



  **The following changes likely require changes in your code**

  - Move filline, showcursor, and hidecursor to a new module called utils.

  - Fix spelling issue, utils.filline is now utils.fill_line

  - Change displayops to optionmenu. Please refactor all calls from displayops() to optionmenu(): No other changes are required

  - Remove legacy function `showerror`. Use messagebox.showerror as a replacement

  - Remove legacy function `askyesno_old`. Use messagebox.askyesno as a replacement

  - Combine `displaymsg` and `displaymsgnodelay` into one function

  - Existing `displaymsgnodelay` calls can be changed to `displaymsg(stdscr,[messages],False)`, so change the flag wait_for_keypress to false

  - Remove redundant american function `set_color`. You can either use the (correct) spelling `set_colour` or you can not use this library.






  transitions contains many transitions to add animations to your program



  **NOTE: THIS IS AN INTERNAL FUNCTION, IT IS NOT MEANT TO BE USED BY THE COMMON USER**

  This executes `func(args)`



  This is a replacement function to old's type zero. It fills the screen from the top down with horizontal white bars. It then replaces them with black bars in the same configuration.

  - `stdscr` is a curses window object

  - `func_to_call` is a function. If it is set to none, no function is called

  - `args` is a tuple. The tuple will be passed to the function as arguments

  - `speed` is an int. A higher value increases the animation speed. A lower value (0 - 1) makes it slower. If you set speed to 0, the program will crash.



  This is a replacement for old's type one transition. It fills random characters of the screen with blocks until the whole screen is covered, then it removes it in the same fashion.

  - `stdscr` is a curses window object

  - `func_to_call` is a function. If it is set to none, no function is called

  - `args` is a tuple. The tuple will be passed to the function as arguments

  - `speed` is an int. A higher value increases the animation speed. A lower value (0 - 1) makes it slower. If you set speed to 0, the program will crash.



  This is an all new transition. It functions like horizontal bars except they are vertical and go left to right.

  - `stdscr` is a curses window object

  - `func_to_call` is a function. If it is set to none, no function is called

  - `args` is a tuple. The tuple will be passed to the function as arguments

  - `speed` is an int. A higher value increases the animation speed. A lower value (0 - 1) makes it slower. If you set speed to 0, the program will crash.



  Utils.py Contain a series of non-ui utility functions. By non-ui I mean that it does not show a screen and it is non-interactive. It is meant to enhance the creation of custom menus.



  This function fills row `line` with the colour `colour`.

  - `stdscr` is a curses window object

  - `line` is an int. It is the row number you wish to fill in

  - `colour` is a curses colour. Use `cursesplus.set_colour()` for this



  This function hides the console cursor



  This function shows the console cursor



  constants.py contains a series of constants such as colours and special lines.

  ** This documentation is not yet complete. There are many more features than this **


pkgId: 6ac19c9841625ceafb5e50b701f6dffb0c6388c6cb9f94301d1432f62e4bd1a5
name: python-cursivepy
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/cursivepy/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cursivepy-0.7.2-1.src.rpm
checksum_type: sha256
description:
  ![Logo](/docs/logo-dark.svg#gh-dark-mode-only)
  ![Logo](/docs/logo-light.svg#gh-light-mode-only)

  Cursive is a universal and intuitive framework for interacting with LLMs.


  <img width=14 height=0 src=""/>✦ **Extensible** - You can easily hook into any part of a completion life cycle. Be it to log, cache, or modify the results.

  <img width=14 height=0 src=""/>✦ **Functions** - Easily describe functions that the LLM can use along with its definition, with any model (currently supporting GPT-4, GPT-3.5, Claude 2, and Claude Instant)

  <img width=14 height=0 src=""/>✦ **Universal** - Cursive aims to bridge as many capabilities between different models as possible. Ultimately, this means that with a single interface, you can allow your users to choose any model.

  <img width=14 height=0 src=""/>✦ **Informative** - Cursive comes with built-in token usage and costs calculations, as accurate as possible.

  <img width=14 height=0 src=""/>✦ **Reliable** - Cursive comes with automatic retry and model expanding upon exceeding context length. Which you can always configure.


  1. Install.

  ```bash
  poetry add cursivepy

  pip install cursivepy
  ```

  2. Start using.

  ```python
  from cursive import Cursive

  cursive = Cursive()

  response = cursive.ask(
      prompt='What is the meaning of life?',
  )

  print(response.answer)
  ```



  Chaining a conversation is easy with `cursive`. You can pass any of the options you're used to with OpenAI's API.

  ```python
  res_a = cursive.ask(
      prompt='Give me a good name for a gecko.',
      model='gpt-4',
      max_tokens=16,
  )

  print(res_a.answer) # Zephyr

  res_b = res_a.conversation.ask(
      prompt='How would you say it in Portuguese?'
  )

  print(res_b.answer) # Zéfiro
  ```

  Streaming is also supported, and we also keep track of the tokens for you!
  ```python
  result = cursive.ask(
      prompt='Count to 10',
      stream=True,
      on_token=lambda partial: print(partial['content'])
  )

  print(result.usage.total_tokens) # 40
  ```



  You can use very easily to define and describe functions, along side with their execution code.

  ```python
  from cursive import cursive_function, Cursive

  cursive = Cursive()

  @cursive_function()
  def add(a: float, b: float):
      """
      Adds two numbers.

      a: The first number.
      b: The second number.
      """
      return a + b

  res = cursive.ask(
      prompt='What is the sum of 232 and 243?',
      functions=[add],
  )

  print(res.answer) # The sum of 232 and 243 is 475.
  ```

  The functions' result will automatically be fed into the conversation and another completion will be made. If you want to prevent this, you can add `pause` to your function definition.

  ```python

  @cursive_function(pause=True)
  def create_character(name: str, age: str):
      """
      Creates a character.

      name: The name of the character.
      age: The age of the character.
      """
      return {
          'name': name,
          'age': age,
      }

  res = cursive.ask(
      prompt='Create a character named John who is 23 years old.',
      functions=[create_character],
  )

  print(res.function_result) # { name: 'John', age: 23 }
  ```

  Cursive also supports passing in undecorated functions!

  ```python
  def add(a: float, b: float):
      return a + b

  res = cursive.ask(
      prompt='What is the sum of 232 and 243?',
      functions=[add], # this is equivalent to cursive_function(pause=True)(add)
  )
  if res.function_result:
      print(res.function_result) # 475
  else:
      print(res.answer) # Text answer in case the function is not called
  ```



  Cursive also supports the generation of Pydantic BaseModels.

  ```python
  from cursive.compat.pydantic import BaseModel, Field # Pydantic V1 API

  class Character(BaseModel):
      name: str
      age: int
      skills: list[str] = Field(min_items=2)

  res = cursive.ask(
      prompt='Create a character named John who is 23 years old.',
      function_call=Character,
  )
  res.function_result # is a Character instance with autogenerated fields
  ```



  You can hook into any part of the completion life cycle.

  ```python
  cursive.on('completion:after', lambda result: print(
      result.data.cost.total,
      result.data.usage.total_tokens,
  ))

  cursive.on('completion:error', lambda result: print(
      result.error,
  ))

  cursive.ask({
      prompt: 'Can androids dream of electric sheep?',
  })



  ```


  You can create embeddings pretty easily with `cursive`.
  ```ts
  embedding = cursive.embed('This should be a document.')
  ```
  This will support different types of documents and integrations pretty soon.


  Cursive comes with automatic retry with backoff upon failing completions, and model expanding upon exceeding context length -- which means that it tries again with a model with a bigger context length when it fails by running out of it.

  You can configure this behavior by passing the `retry` and `expand` options to `Cursive` constructor.

  ```python
  cursive = Cursive(
      max_retries=5, # 0 disables it completely
      expand={
          'enable': True,
          'defaults_to': 'gpt-3.5-turbo-16k',
          'resolve_model': {
              'gpt-3.5-turbo': 'gpt-3.5-turbo-16k',
              'gpt-4': 'claude-2',
          },
      },
  )
  ```


  <details>
  <summary><strong>OpenAI models<strong></summary>

  - `gpt-3.5-turbo`
  - `gpt-3.5-turbo-16k`
  - `gpt-4`
  - `gpt-4-32k`
  - Any other chat completion model version


  You can pass your OpenAI API key to `Cursive`'s constructor, or set the `OPENAI_API_KEY` environment variable.
  </details>

  <details>
  <summary><strong>Anthropic models</strong></summary>

  - `claude-2`
  - `claude-instant-1`
  - `claude-instant-1.2`
  - Any other model version


  You can pass your Anthropic API key to `Cursive`'s constructor, or set the `ANTHROPIC_API_KEY` environment variable.
  </details>

  <details>
  <summary><strong>OpenRouter models</strong></summary>

  OpenRouter is a service that gives you access to leading language models in an OpenAI-compatible API, including function calling!

  - `anthropic/claude-instant-1.2`
  - `anthropic/claude-2`
  - `openai/gpt-4-32k`
  - `google/palm-2-codechat-bison`
  - `nousresearch/nous-hermes-llama2-13b`
  - Any model version from https://openrouter.ai/docs#models



  ```python
  from cursive import Cursive

  cursive = Cursive(
      openrouter={
        "api_key": "sk-or-...",
        "app_title": "Your App Name",
        "app_url": "https://appurl.com",
      }
  )

  cursive.ask(
      model="anthropic/claude-instant-1.2",
      prompt="What is the meaning of life?"
  )
  ```
  </details>


  <details>
  <summary><strong>Cohere models</strong></summary>

  - `command`
  - Any other model version (such as `command-nightly`)


  You can pass your Cohere API key to `Cursive`'s constructor, or set the `COHERE_API_KEY` environment variable.

  </details>

  <details>
  <summary><strong>Replicate models</strong></summary>
  You can prepend `replicate/` to any model name and version available on Replicate.


  ```python
  cursive.ask(
      prompt='What is the meaning of life?',
      model='replicate/a16z-infra/llama-2-13b-chat:2a7f981751ec7fdf87b5b91ad4db53683a98082e9ff7bfd12c8cd5ea85980a52',
  )
  ```


  You can pass your Replicate API key to `Cursive`'s constructor, or set the `REPLICATE_API_TOKEN` environment variable.

  </details>




  - [x] Anthropic
  - [x] Cohere
  - [x] Replicate
  - [x] OpenRouter
  - [ ] Azure OpenAI models
  - [ ] Huggingface


pkgId: 57250ab6af7233348362706a52b3601765beb325e2fe4b94be4dcce45da7a47e
name: python-curso-fiap-dev-ia-package
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Descricao da sua lib curso_fiap_dev_ia
url: https://github.com/dioleal
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curso-fiap-dev-ia-package-1.0.0-1.src.rpm
checksum_type: sha256
description:
  A simple example library.



  ```sh
  pip install curso_fiap_dev_ia
  ```



  ```python
  from curso_fiap_dev_ia import hello_world

  print(hello_world())
  ```


pkgId: 187f93511bfa347750e243fd555b75f08d4714d2b51ba33174012f27b0c2b09c
name: python-cursofiapml-package
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Descricao da sua lib cursofiapml
url: https://github.com/tadrianonet/cursofiapml
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cursofiapml-package-1.0.0-1.src.rpm
checksum_type: sha256
description:
  A simple example library.



  ```sh
  pip install cursofiapml
  ```



  ```python
  from cursofiapml import hello_world

  print(hello_world())
  ```


pkgId: 63964b565fb9883036d6e0f0fced856fc1bc8fcaf80b8b1fa4068f72befe52e5
name: python-cursor
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: A small Python package to hide or show the terminal cursor
url: https://github.com/GijsTimmers/cursor
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cursor-1.3.5-1.src.rpm
checksum_type: sha256
description:
  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

  ![PyPI version](https://badge.fury.io/py/cursor.svg)


  A small Python package to hide or show the terminal cursor.
  Works on Linux and Windows, on both Python 2 and Python 3.

  ![demonstration](http://i.imgur.com/2iXviMi.gif)


  The code is almost entirely a copy of
  [James Spencer's](http://stackoverflow.com/u/1375885/)
  [answer on StackOverflow](http://stackoverflow.com/a/10455937/1096437).



  The preferred way of installing `cursor` is via `pip`.
  You can install `pip` with your package manager:



      sudo apt-get install python-pip
      pip install --user cursor



      git clone https://aur.archlinux.org/python-cursor.git
      cd python-cursor
      makepkg -si



  ```python
  import cursor
  cursor.hide() ## Hides the cursor
  cursor.show() ## Shows the cursor
  ```


  Note that the cursor will stay hidden until you call `cursor.show()` —
  even after exiting your python script!

  Because of that, `pip` will install two scripts, which can be run
  from the command line: `cursor_hide` and `cursor_show`.

  An alternative is using the `HiddenCursor()` class in conjunction
  with Python's `with` statement. This will make sure that the cursor
  is shown again after running your code, even if exceptions are
  raised:

  ```python
  import cursor
  with cursor.HiddenCursor():     ## Cursor will stay hidden
      import time                 ## while code is being executed;
      for a in range(1,100):      ## afterwards it will show up again
          print(a)
          time.sleep(0.05)

  ```

  You could also use Python's `atexit` module:

  ```python
  import cursor
  import atexit
  import time

  atexit.register(cursor.show)    ## Make sure cursor.show() is called
                                  

  cursor.hide()                   ## Hides cursor
  for a in range(1,100):
      print(a)
      time.sleep(0.05)
  exit()                          ## Cursor will show again
  ```


  [Manraj Singh](https://github.com/ManrajGrover): allowed setting
  a customisable stream

  [Alexander Seiler](https://github.com/goggle): packaging for Arch

  Patrik Kopkan: packaging for Fedora



  [`halo`](https://github.com/ManrajGrover/halo): beautiful
  terminal spinners in Python

  [`pipenv`](https://github.com/pypa/pipenv): a tool that aims to bring the best of all packaging worlds to the Python world


pkgId: d960e84867d0a94fa18112af49adfe3049cae6c3b79403d67a47a055502b44e5
name: python-curtainutils
arch: src
version: 0.1.18
epoch: 0
release: 1
summary: A utility package that can be used to upload data to a curtain backend server.
url: https://pypi.org/project/curtainutils/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curtainutils-0.1.18-1.src.rpm
checksum_type: sha256
description:
  A utility package for converting different MS output files into a format usable by Curtain (https://curtain.proteo.info) and CurtainPTM (https://curtainptm.proteo.info).



  - [Installation](#installation)
  - [Usage](#usage)
    - [Convert MSFragger PTM single site output to CurtainPTM input](#convert-msfragger-ptm-single-site-output-to-curtainptm-input)
    - [Convert DIA-NN PTM output to CurtainPTM input](#convert-dia-nn-ptm-output-to-curtainptm-input)
    - [Convert Spectronaut output to Curtain input](#convert-spectronaut-output-to-curtain-input)
    - [Submit data to a Curtain server](#submit-data-to-a-curtain-server)
    - [Submit data to a CurtainPTM server](#submit-data-to-a-curtainptm-server)
  - [License](#license)



  The package can be installed using the following command:

  ```bash
  pip install curtainutils
  ```



  - Python 3.6 or higher
  - `pip` package manager





  This script should be used to convert a differential analysis file that contains the index column and peptide column. The index column should also be the original index column output by MS-Fragger that contains both the Accession ID as well as the position of the PTM within the protein sequence.

  ```bash
  msf-curtainptm -f <MSFragger PTM single site output file> -i <index column with site information> -o <output file> -p <peptide column> -a <fasta file>
  ```



  This script should be used to convert a differential analysis file that contains the following columns: "Modified.Sequence", "Precursor.Id", "Protein.Group" from the pr report file by combining the file with the Report file which contains the column "PTM.Site.Confidence".

  ```bash
  diann-curtainptm -p <differential analysis file> -r <report file> -o <output file> -m <modification_of_interests from the Modified.Sequence column>
  ```



  This script should be used to convert a differential analysis file that contains the "PTM_collapse_key" and "PEP.StrippedSequence" columns from the original Spectronaut output.

  ```bash
  spn-curtainptm -f <differential analysis file> -o <output file>
  ```



  ```python
  from curtainutils.client import CurtainClient

  de_file = r"differential-file-path"
  raw_file = r"raw-file-path"

  fc_col = "foldchange-column-name"
  transform_fc = False
  transform_significant = False
  reverse_fc = False
  p_col = "significance-column-name"

  comp_col = ""  # Leave empty if no comparison column is used
  comp_select = []  # Leave empty if no comparison column is used

  primary_id_de_col = "primary-id-column-name-in-differential-file"
  primary_id_raw_col = "primary-id-column-name-in-raw-file"

  sample_cols = ["4Hr-AGB1.01", "4Hr-AGB1.02", "4Hr-AGB1.03", "4Hr-AGB1.04", "4Hr-AGB1.05", "24Hr-AGB1.01",
                 "24Hr-AGB1.02", "24Hr-AGB1.03", "24Hr-AGB1.04", "24Hr-AGB1.05", "4Hr-Cis.01", "4Hr-Cis.02", "4Hr-Cis.03",
                 "24Hr-Cis.01", "24Hr-Cis.02", "24Hr-Cis.03"]
  c = CurtainClient("curtain-backend-url")
  payload = c.create_curtain_session_payload(
      de_file,
      raw_file,
      fc_col,
      transform_fc,
      transform_significant,
      reverse_fc,
      p_col,
      comp_col,
      comp_select,
      primary_id_de_col,
      primary_id_raw_col,
      sample_cols
  )

  package = {
      "enable": "True",
      "description": payload["settings"]["description"],
      "curtain_type": "TP",
  }

  result = c.post_curtain_session(package, payload)
  print(result)
  ```



  ```python
  from curtainutils.client import CurtainClient

  de_file = r"differential-file-path"
  raw_file = r"raw-file-path"

  fc_col = "foldchange-column-name"
  transform_fc = False
  transform_significant = False
  reverse_fc = False
  p_col = "significance-column-name"
  comp_col = ""  # Leave empty if no comparison column is used
  comp_select = []  # Leave empty if no comparison column is used
  primary_id_de_col = "primary-id-column-name-in-differential-file"
  primary_id_raw_col = "primary-id-column-name-in-raw-file"
  sample_cols = []
  peptide_col = "peptide-sequence-column-name"
  acc_col = "protein-accession-column-name"
  position_col = "position-in-protein-column-name"
  position_in_peptide_col = "position-in-peptide-column-name"
  sequence_window_col = "sequence-window-column-name"
  score_col = "score-column-name"

  c = CurtainClient("curtain-backend-url")

  payload = c.create_curtain_ptm_session_payload(
      de_file,
      raw_file,
      fc_col,
      transform_fc,
      transform_significant,
      reverse_fc,
      p_col,
      comp_col,
      comp_select,
      primary_id_de_col,
      primary_id_raw_col,
      sample_cols,
      peptide_col,
      acc_col,
      position_col,
      position_in_peptide_col,
      sequence_window_col,
      score_col
  )

  package = {
      "enable": "True",
      "description": payload["settings"]["description"],
      "curtain_type": "PTM",
  }

  result = c.post_curtain_session(package, payload)
  print(result)
  ```



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


pkgId: b37e0b0d86f605fc3c050e08b1d2c86656f9d833a2cb6b6936789270c612081d
name: python-curtsies
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Curses-like terminal wrapper, with colored strings!
url: https://github.com/bpython/curtsies
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curtsies-0.4.2-1.src.rpm
checksum_type: sha256
description:
  [FmtStr](http://curtsies.readthedocs.org/en/latest/FmtStr.html) objects are strings formatted with
  colors and styles displayable in a terminal with [ANSI escape sequences](http://en.wikipedia.org/wiki/ANSI_escape_code>`_).
  ![](https://i.imgur.com/bRLI134.png)
  [FSArray](http://curtsies.readthedocs.org/en/latest/FSArray.html) objects contain multiple such strings
  with each formatted string on its own row, and FSArray
  objects can be superimposed on each other
  to build complex grids of colored and styled characters through composition.
  (the import statement shown below is outdated)
  ![](http://i.imgur.com/rvTRPv1.png)
  Such grids of characters can be rendered to the terminal in alternate screen mode
  (no history, like `Vim`, `top` etc.) by [FullscreenWindow](http://curtsies.readthedocs.org/en/latest/window.html#curtsies.window.FullscreenWindow) objects
  or normal history-preserving screen by [CursorAwareWindow](http://curtsies.readthedocs.org/en/latest/window.html#curtsies.window.CursorAwareWindow) objects.
  User keyboard input events like pressing the up arrow key are detected by an
  [Input](http://curtsies.readthedocs.org/en/latest/input.html) object.


pkgId: 54307b9119d6f3d5a748a4af432c6b28fe5ec6f3f857205b4822cf35b4b215dd
name: python-curv-amqp
arch: src
version: 1.3.7
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: http://github.com/rep-ai/curv_amqp
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curv-amqp-1.3.7-1.src.rpm
checksum_type: sha256
description:
  Pika framework that handles reconnecting while using a blocking connection and has helpful defaults, building blocks, type hints, and a priority requeue method

  ```shell script
  pip install curv-amqp
  ```


  ```shell script
  git clone https://github.com/rep-ai/curv_amqp.git
  cd curv_amqp
  pip install -r requirements.txt
  pip install -e .
  ```


  ```python
  from curv_amqp.connection import Connection, ConnectionParameters
  from curv_amqp.publisher import Publisher
  from curv_amqp.consumer import Consumer, ConsumerMessage
  host = 'localhost'
  queue_name = 'test'
  connection = Connection(parameters=ConnectionParameters(host))

  publisher = Publisher(connection=connection)
  publisher.publish(routing_key=queue_name, body=b'message')

  consumer = Consumer(connection=connection)

  def on_message_callback(message: ConsumerMessage):
      print('message.body:', message.body)
      message.ack()
      
      
      message.consumer.stop_consuming()

  consumer.consume(queue=queue_name, prefetch_count=1, on_message_callback=on_message_callback)

  ```

  ```python
  from argparse import ArgumentParser

  from curv_amqp.connection import Connection, URLParameters, ConnectionParameters
  from curv_amqp.publisher import Publisher
  from curv_amqp.consumer import Consumer, ConsumerMessage
  from curv_amqp.exceptions import ChannelClosedError, ConnectionClosedError, RequeueRetryCountError


  def main():
      parser = ArgumentParser()
      parser.add_argument('--url', type=str, default='localhost', help='amqp url or localhost - '
                                                                       'localhost assumes rabbitmq is installed - '
                                                                       '"brew install rabbitmq"')
      parser.add_argument('--queue', type=str, default='test-queue-name', help='amqp queue name')
      parser.add_argument('--body', type=str, default='your message', help='amqp message body')
      args = parser.parse_args()
      
      
      url: str = args.url
      parameters = ConnectionParameters(url) if url is 'localhost' else URLParameters(url)
      queue_name = args.queue
      body = bytes(args.body, encoding='utf-8')

      connection = Connection(parameters=parameters)
      
      connection.blocking_connection.close()
      
      
      publisher = Publisher(connection=connection)
      
      publisher.blocking_channel.close()
      publisher.publish(routing_key=queue_name, body=body)

      consumer = Consumer(connection=connection)
      
      consumer.blocking_channel.close()

      def on_message_callback(message: ConsumerMessage):
          print('message.body:', message.body)
          print('message.properties.priority', message.properties.priority)
          try:
              message.priority_requeue(publisher)
          except RequeueRetryCountError as ex:
              print(ex)
              message.ack()
              message.consumer.stop_consuming()

      consumer.consume(queue=queue_name, prefetch_count=1, on_message_callback=on_message_callback)

      publisher.publish(routing_key=queue_name, body=body)
      for msg in consumer.consume_generator(queue=queue_name, prefetch_count=1, auto_ack=True, inactivity_timeout=1):
          print('msg.body:', msg.body)

      try:
          
          publisher.close()
          publisher.publish(routing_key=queue_name, body=body)
      except ChannelClosedError as e:
          print(e)

      try:
          
          publisher = Publisher(connection=connection)
          connection.close()
          publisher.publish(routing_key=queue_name, body=body)
      except ConnectionClosedError as e:
          print(e)


  if __name__ == '__main__':
      main()

  ```


  ```shell script

  python setup.py sdist bdist_wheel
  twine check dist/*
  twine upload dist/*
  ```

  ```shell script
  bash deploy.sh
  ```


pkgId: a7d4a01268ad9c660f5599769a2c598d851fdafe3380b2a8c32ab98dfb477d2a
name: python-curvanato
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Anatomical curvature processing for medical images.
url: https://pypi.org/project/curvanato/
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curvanato-1.0.0-1.src.rpm
checksum_type: sha256
description:
  local curvature quantification for anatomical data




  To install the package locally, navigate to the package root and run:

  ```bash
  pip install .
  ```




  ```python
  import ants
  import antspynet
  import antspyt1w
  import curvanato
  import re
  import os  # For checking file existence
  import pandas as pd
  import numpy as np
  os.environ["ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS"] = "32"

  fn='.//bids/sub-RC4111/ses-1/anat/sub-RC4111_ses-1_T1w.nii.gz' # easy
  fn='.//bids/sub-RC4103/ses-1/anat/sub-RC4103_ses-1_T1w.nii.gz'
  fn='./bids//sub-RC4110/ses-2/anat/sub-RC4110_ses-2_T1w.nii.gz'
  if os.path.exists(fn):
      t1=ants.image_read( fn )
      t1=ants.resample_image( t1, [0.5, 0.5, 0.5], use_voxels=False, interp_type=0 )
      hoafn = re.sub( ".nii.gz", "_hoa.nii.gz" , fn )
      if not os.path.exists(hoafn):
          hoa = antspynet.harvard_oxford_atlas_labeling(t1, verbose=True)['segmentation_image']
          ants.image_write( hoa, hoafn)
      hoa = ants.image_read( hoafn )
      citfn = re.sub( ".nii.gz", "_cit168.nii.gz" , fn )
      if not os.path.exists(citfn):
          t1b = antspynet.brain_extraction( t1, modality="t1threetissue" )['segmentation_image'].threshold_image(1,1)
          t1r = ants.rank_intensity( t1 * t1b )
          cit = antspyt1w.deep_cit168( t1r, verbose=True)['segmentation']
          ants.image_write( cit, citfn)
      cit = ants.image_read( citfn )





  ctype='cit'
  tcaudL=curvanato.load_labeled_caudate( option='hmt', binarize=False, label=[1,3,5] )
  tcaudR=curvanato.load_labeled_caudate( option='hmt', binarize=False, label=[2,4,6] )
  vlab=None
  leftside=True
  gr=0
  subd=0
  otherside=True
  if otherside:
      ccfn = [
          re.sub( ".nii.gz", "_"+ctype+"Rkappa.nii.gz" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"R.nii.gz" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Rthk.nii.gz" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Rkappa.csv" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Rkappa.png" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Rthk.png" , fn ) ]
      pcaud=[3,4]
      plabs=[4]
      if ctype == 'cit':
          mytl=18
      xx = curvanato.t1w_caudcurv(  cit, target_label=mytl, ventricle_label=vlab,
          prior_labels=pcaud, prior_target_label=plabs, subdivide=subd, grid=gr,
          priorparcellation=tcaudR,  plot=True,
          verbose=True )
      ants.plot( xx[0], xx[1], crop=True, axis=2, nslices=21, ncol=7, filename=ccfn[4] )
      ants.plot( xx[0], xx[2], crop=True, axis=2, nslices=21, ncol=7, filename=ccfn[5] )
      for j in range(3):
          ants.image_write( xx[j], ccfn[j] )
      xx[3].to_csv( ccfn[3] )

  if leftside:
      mytl=2
      ccfn = [
          re.sub( ".nii.gz", "_"+ctype+"Lkappa.nii.gz" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"L.nii.gz" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Lthk.nii.gz" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Lkappa.csv" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Lkappa.png" , fn ),
          re.sub( ".nii.gz", "_"+ctype+"Lthk.png" , fn ) ]
      print("Begin " + fn + " caud kap")
      pcaud=[1,2]
      plabs=[2]
      xx = curvanato.t1w_caudcurv( cit, target_label=2, ventricle_label=vlab,
          prior_labels=pcaud, prior_target_label=plabs, subdivide=subd, grid=gr,
          priorparcellation=tcaudL,  plot=True, searchrange=20,
          verbose=True )
      ants.plot( xx[0], xx[1], crop=True, axis=2, nslices=21, ncol=7, filename=ccfn[4] )
      ants.plot( xx[0], xx[1], crop=True, axis=2, nslices=21, ncol=7, filename=ccfn[5] )
      for j in range(3):
          ants.image_write( xx[j], ccfn[j] )
      xx[3].to_csv( ccfn[3] )



  ```




  this package has been tested on [ANTPD data from openneuro](https://openneuro.org/datasets/ds001907/versions/2.0.3).

  could also try data [here](https://openneuro.org/datasets/ds004560/versions/1.0.1) which included repeated T1w acquisitions on same subjects but with different parameters.    however, last time i tried this, the link was not working.


  ```
  rm -r -f build/ curvanato.egg-info/ dist/
  python3 -m  build .
  python3 -m pip install --upgrade twine
  python3 -m twine upload --repository antspyt1w dist/*
  ```


pkgId: 93b8509e6311eb93fa5e14c6d641150e69e80eef67ce22978c893da2cd5eba3e
name: python-curve-dao
arch: src
version: 1.0.11
epoch: 0
release: 1
summary: DAO governance tools for CurveDAO.
url: https://pypi.org/project/curve-dao/
rpm_license: AGPL-3.0-only License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curve-dao-1.0.11-1.src.rpm
checksum_type: sha256
description:
  ```python
  import boa
  import curve_dao

  contract = boa.load("contracts/contract.vy",
      curve_dao.get_address("ownership"), curve_dao.get_address("param"), curve_dao.get_address("emergency"),  # Set admins
  )
  ACTIONS = [
      ("0xcontract", "set_something", ("values",), 70, "set"),  # 0xcontract.set_something(("values",), 70, "set)
      (contract, "enact"),  # contract.enact()
  ]
  DESCRIPTION = "Enact something"
  vote_id = curve_dao.create_vote("ownership", ACTIONS, DESCRIPTION,
                                  etherscan_api_key=os.environ["ETHERSCAN_API_KEY"], pinata_token=os.environ["PINATA_TOKEN"])
  if is_simulation:  # forked environment
      curve_dao.simulate(vote_id, "ownership", etherscan_api_key=os.environ["ETHERSCAN_API_KEY"])
  ```



  Simple python package to simulate on-chain CurveDAO proposals and publish proposals for DAO voting on-chain.



  veCRV holders looking to create on-chain proposals such as

  - Creating or killing Curve DAO gauges that reward CRV inflation to addresses (liquidity pools or otherwise).
  - Creating a smartwallet whitelist to lock veCRV (veCRV restricts smart contracts to lock CRV, subject to a DAO whitelist vote)
  - Changing liquidity pool parameters
  - Adding gauge types ...
  - ... etc.

  Curve DAO stakeholders have the ability to change the protocol in many ways. This repository is an attempt to consolidate all on-chain DAO operations into a single tool.



  `pip install curve-dao`



  1. Fork + Pull Requests.
  2. Create issues.
  3. ...



  `python -m pytest .`



  1. Update codebase
  2. Up version in pyproject.toml
  3. `python -m build; python -m twine upload --repository pypi dist/* --verbose`


pkgId: 8424dcfe080a1acb94768884115773a24f5f8f507a359446ff2c4ccc094c6708
name: python-curvedpy
arch: src
version: 0.0.1.dev0
epoch: 0
release: 1
summary: General Relativistic Geodesic Integrator
url: https://github.com/bldevries/curvedpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curvedpy-0.0.1.dev0-1.src.rpm
checksum_type: sha256
description:
  Author: <a href="https://www.linkedin.com/in/bldevries/" target="_blank">BL de Vries</a>. PhD and Scientific visualisation advisor at <a href="https://www.surf.nl" target="_blank">SURF</a>.

  At this moment, just check out the readme in the Blender render engine repo here: https://github.com/bldevries/blackhole_geodesic_calculator


pkgId: 9e741e3c98f43f13495d4cf345423408ef86c0d360d957902deebc02f5a54e5c
name: python-curvelets
arch: src
version: 0.0.2a0
epoch: 0
release: 1
summary: Open source implementation of the uniform discrete curvelet transform in Python.
url: https://github.com/cako/curvelets
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curvelets-0.0.2a0-1.src.rpm
checksum_type: sha256
description:
  > [!WARNING]
  > **This project is in *very* early development! Expect bugs!**


  <h3>
    <a href="#getting-started">Getting Started</a>
    <span> | </span>
    <a href="#FAQs">FAQs</a>
    <span> | </span>
    <a href="https://curvelets.readthedocs.io/en/latest/auto_examples/index.html">Examples</a>
  </h3>

  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status](https://readthedocs.org/projects/curvelets/badge/?version=latest)](https://curvelets.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/github/cako/curvelets/graph/badge.svg?token=T16E0ANTLR)](https://codecov.io/github/cako/curvelets)

  [![PyPI version][pypi-version]][pypi-link]
  [![Conda-Forge][conda-badge]][conda-link]
  [![PyPI platforms][pypi-platforms]][pypi-link]
  ![PyPI downloads](https://img.shields.io/pypi/dm/curvelets.svg?label=Pypi%20downloads)
  ![OS-support](https://img.shields.io/badge/OS-linux,win,osx-850A8B.svg)
  ![License](https://img.shields.io/github/license/cako/curvelets)

  [![GitHub Discussion][github-discussions-badge]][github-discussions-link]

  <!-- SPHINX-START -->

  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/cako/curvelets/workflows/CI/badge.svg
  [actions-link]:             https://github.com/cako/curvelets/actions
  [conda-badge]:              https://img.shields.io/conda/vn/conda-forge/Curvelets
  [conda-link]:               https://github.com/conda-forge/Curvelets-feedstock
  [github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
  [github-discussions-link]:  https://github.com/cako/curvelets/discussions
  [pypi-link]:                https://pypi.org/project/Curvelets/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/Curvelets
  [pypi-version]:             https://img.shields.io/pypi/v/Curvelets
  [rtd-badge]:                https://readthedocs.org/projects/Curvelets/badge/?version=latest
  [rtd-link]:                 https://Curvelets.readthedocs.io/en/latest/?badge=latest

  <!-- prettier-ignore-end -->


  ```python
  import numpy as np
  from curvelets.numpy import SimpleUDCT

  x = np.ones((128, 128))
  C = SimpleUDCT(shape=x.shape)
  y = C.forward(x)
  np.testing.assert_allclose(x, C.backward(y))
  ```

  You can use `SimpleUDCT` very similarly to `FDCT` from [curvelops](https://github.com/PyLops/curvelops), with a limitation that SimpleUDCT only operates arrays whose sizes are powers of 2.







  Probably not! This library is a work in progress, pre-alpha library for a very specific version of the curvelet transform known as the Uniform Discrete Curvelet Transform (UDCT).

  Consider using other, more mature projects.

  |                                                             | Description                         | License                                  | N-D?       | Shape       | Invertible? |
  | ----------------------------------------------------------- | ----------------------------------- | ---------------------------------------- | ---------- | ----------- | ----------- |
  | curvelets                                                   | UDCT in Python                      | MIT                                      | N-D        | Powers of 2 | Exact       |
  | [Curvelab](https://curvelet.org/software.php)               | FDCT in C++ and Matlab              | Proprietary (free for academic use only) | 2D, 3D     | Any         | Exact       |
  | [curvelops](https://github.com/PyLops/curvelops)            | Curvelab Python wrapper             | MIT, depedends on Curvelab               | 2D, 3D     | Any         | Exact       |
  | [Kymatio](https://www.kymat.io/)                            | Wavelet scattering transform        | BSD 3-clause                             | 1D, 2D, 3D | Any         | Approximate |
  | [dtcwt](https://dtcwt.readthedocs.io)                       | Dual-Tree Complex Wavelet Transform | Custom BSD 2-clause                      | 1D, 2D, 3D | Any         | Exact       |
  | [Pytorch Wavelets](https://pytorch-wavelets.readthedocs.io) | Discrete WT and Dual-Tree CWT       | MIT                                      | 2D         | Any         | Exact       |





     Curvelets are like wavelets, but in 2D (3D, 4D, etc.). But so are steerable wavelets, Gabor wavelets, wedgelets, beamlets, bandlets, contourlets, shearlets, wave atoms, platelets, surfacelets, ... you get the idea. Like wavelets, these "X-lets" allow us to separate a signal into different "scales" (analog to frequency in 1D, that is, how fast the signal is varying), "location" (equivalent to time in 1D) and the direction in which the signal is varying (which does not have 1D analog).

     What separates curvelets from the other X-lets are their interesting properties, including:
     * The curvelet transform has an exact inverse
     * The discrete curvelet transform has efficient decomposition ("analysis") and reconstruction ("synthesis") implementations [[1](#1-candès-e-l-demanet-d-donoho-and-l-ying-2006-fast-discrete-curvelet-transforms-multiscale-modeling--simulation-5-861899), [2](#2-nguyen-t-t-and-h-chauris-2010-uniform-discrete-curvelet-transform-ieee-transactions-on-signal-processing-58-36183634)]
     * The curvelet transform is naturally N-dimensional
     * Curvelet basis functions yield an optimally sparse representation of wave phenomena (seismic data, ultrasound data, etc.) [[3](#3-candès-e-j-and-l-demanet-2005-the-curvelet-representation-of-wave-propagators-is-optimally-sparse-communications-on-pure-and-applied-mathematics-58-14721528)]
     * Curvelets have little redundancy, forming a _tight frame_ [[4](#4-candès-e-j-and-d-l-donoho-2003-new-tight-frames-of-curvelets-and-optimal-representations-of-objects-with-piecewise-c2-singularities-communications-on-pure-and-applied-mathematics-57-219266)]

    You can find a good overview (plug: I wrote it!) of curvelets in the Medium article [Demystifying Curvelets](https://towardsdatascience.com/desmystifying-curvelets-c6d88faba0bf).


     Curvelets have a long history and rich history in signal processing. They have been used for a multitude of tasks related in areas such as biomedical imaging (ultrasound, MRI), seismic imaging, synthetic aperture radar, among others. They allow us to extract useful features which can be used to attack problems such as segmentation, inpaining, classification, adaptive subtraction, etc.



  There are three flavors of the discrete curvelet transform with available implementations. The first two are based on the Fast Discrete Curvelet Transform (FDCT) pioneered by Candès, Demanet, Donoho and Ying. They are the "wrapping" and "USFFT" (unequally-spaced Fast Fourier Transform) versions of the FDCT. Both are implemented (2D and 3D for the wrapping version and 2D only for the USFFT version) in the proprietary [CurveLab Toolbox](http://www.curvelet.org/software.html) in Matlab and C++.

  As of 2024, any non-academic use of the CurveLab Toolbox requires a commercial license. This includes libraries which wrap the CurveLab toolbox such as pybind11-based wrapper [curvelops](https://github.com/PyLops/curvelops), Python SWIG-based wrapper [PyCurvelab](https://github.com/slimgroup/PyCurvelab). Neither curvelops nor PyCurvelab package include any source code of Curvelab. It should be noted, however, that any library which ports or converts Curvelab code to another language is subject to Curvelab's license. Again, neither curvelops or PyCurvelab do so, and can therefore be freely distributed as per their licenses (both have MIT licenses).

  A third flavor is the Uniform Discrete Curvelet Transform (UDCT) which does not have the same restrictive license as the FDCT. The UDCT was first implemented in Matlab (see [ucurvmd](https://github.com/nttruong7/ucurvmd) \[dead link\]) by one of its authors, Truong Nguyen. The 2D version was ported to Julia as the [Curvelet.jl](https://github.com/fundamental/Curvelet.jl) package, whose development has since been abandoned.

  This library provides the first pure-Python implementation of the UDCT, borrowing heavily from Nguyen's original implementation. The goal of this library is to allow industry processionals to use the UDCT more easily.

  Note: The Candès FDCTs and Nguyen UDCT are not the only curvelet transforms. To my knowledge, there is another implementation of the 3D Discrete Curvelet Transform named the LR-FCT (Low-Redudancy Fast Curvelet Transform) by Woiselle, Stack and Fadili [[5](#5-woiselle-a-j-l-starck-and-j-fadili-2010-3d-curvelet-transforms-and-astronomical-data-restoration-applied-and-computational-harmonic-analysis-28-171188)], but the code seems to have disappeared off the internet [[6](#6-starck-jean-luc-f-cur3d--cosmostat-cosmostat-26-june-2017-wwwcosmostatorgsoftwaref-cur3d-accessed-25-feb-2024)]. Moreover, there is also another type of continuous curvelet transform, the monogenic curvelet transform [[7](#7-storath-m-2010-the-monogenic-curvelet-transform-2010-ieee-international-conference-on-image-processing)], but I have found no implementation available.
  Lastly, the [S2LET](https://astro-informatics.github.io/s2let/) package the equivalent of curvelets but on the sphere [[8](#8-chan-j-y-h-b-leistedt-t-d-kitching-and-j-d-mcewen-2017-second-generation-curvelets-on-the-sphere-ieee-transactions-on-signal-processing-65-514)].


  This is another facet of the "data-centric" vs "model-centric" debate in machine learning. Exploiting curvelets is a type of model engineering, as opposed to using conventional model architectures and letting the data guide the learning process. Alternatively, if the transform is used as a preprocessing step, it can be seen from as feature engineering.

  My suggestion is to use curvelets and other transforms for small to mid-sized datasets, especially in niche areas without a wide variety of high-quality tranining data. It has been shown that fixed filter banks can be useful in speeding up training and improving performance of deep neural networks [[9](#9-luan-s-c-chen-b-zhang-j-han-and-j-liu-2018-gabor-convolutional-networks-ieee-transactions-on-image-processing-27-43574366), [10](#10-bruna-j-and-s-mallat-2013-invariant-scattering-convolution-networks-ieee-transactions-on-pattern-analysis-and-machine-intelligence-35-18721886)] in some cases.

  Another expected to consider is the availability of high-performance, GPU-accelerated and autodiff-friendly libraries. As far as I know, no curvelet library (including this one) satisfies those constraints. Alternative transforms can be found in [Kymatio](https://www.kymat.io/) and [Pytorch Wavelets](https://pytorch-wavelets.readthedocs.io/en/latest/readme.html) which implement the wavelet scattering transform [[11](#11-andreux-m-t-angles-g-exarchakis-r-leonarduzzi-g-rochette-l-thiry-j-zarka-s-mallat-j-andén-e-belilovsky-j-bruna-v-lostanlen-m-chaudhary-m-j-hirn-e-oyallon-s-zhang-c-cella-and-m-eickenberg-2020-kymatio-scattering-transforms-in-python-journal-of-machine-learning-research-2160-16)] and dual-tree complex wavelet transform, respectively [[12](#12-kingsbury-n-2001-complex-wavelets-for-shift-invariant-analysis-and-filtering-of-signals-applied-and-computational-harmonic-analysis-10-234253)].

rpm_license:
  Copyright 2024 Carlos Alberto da Costa Filho  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: 1e07a9f8afe4348cc335da27510059d38cb6f3337f794c0bcf778bbc99c335c2
name: python-curvelets
arch: src
version: 0.0.4a0
epoch: 0
release: 1
summary: Open source implementation of the uniform discrete curvelet transform in Python.
url: https://github.com/cako/curvelets
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curvelets-0.0.4a0-1.src.rpm
checksum_type: sha256
description:
  > [!WARNING]
  > **This project is in *very* early development! Expect bugs!**


  <h3>
    <a href="#getting-started">Getting Started</a>
    <span> | </span>
    <a href="#FAQs">FAQs</a>
    <span> | </span>
    <a href="https://curvelets.readthedocs.io/en/latest/auto_examples/index.html">Examples</a>
  </h3>

  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status](https://readthedocs.org/projects/curvelets/badge/?version=latest)](https://curvelets.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/github/cako/curvelets/graph/badge.svg?token=T16E0ANTLR)](https://codecov.io/github/cako/curvelets)

  [![PyPI version][pypi-version]][pypi-link]
  [![Conda-Forge][conda-badge]][conda-link]
  [![PyPI platforms][pypi-platforms]][pypi-link]
  ![PyPI downloads](https://img.shields.io/pypi/dm/curvelets.svg?label=Pypi%20downloads)
  ![OS-support](https://img.shields.io/badge/OS-linux,win,osx-850A8B.svg)
  ![License](https://img.shields.io/github/license/cako/curvelets)

  [![GitHub Discussion][github-discussions-badge]][github-discussions-link]

  <!-- SPHINX-START -->

  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/cako/curvelets/workflows/CI/badge.svg
  [actions-link]:             https://github.com/cako/curvelets/actions
  [conda-badge]:              https://img.shields.io/conda/vn/conda-forge/Curvelets
  [conda-link]:               https://github.com/conda-forge/Curvelets-feedstock
  [github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
  [github-discussions-link]:  https://github.com/cako/curvelets/discussions
  [pypi-link]:                https://pypi.org/project/Curvelets/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/Curvelets
  [pypi-version]:             https://img.shields.io/pypi/v/Curvelets
  [rtd-badge]:                https://readthedocs.org/projects/Curvelets/badge/?version=latest
  [rtd-link]:                 https://Curvelets.readthedocs.io/en/latest/?badge=latest

  <!-- prettier-ignore-end -->


  ```python
  import numpy as np
  from curvelets.numpy import SimpleUDCT

  x = np.ones((128, 128))
  C = SimpleUDCT(shape=x.shape)
  y = C.forward(x)
  np.testing.assert_allclose(x, C.backward(y))
  ```

  You can use `SimpleUDCT` very similarly to `FDCT` from [curvelops](https://github.com/PyLops/curvelops), with a limitation that SimpleUDCT only operates arrays whose sizes are powers of 2.







  Probably not! This library is a work in progress, pre-alpha library for a very specific version of the curvelet transform known as the Uniform Discrete Curvelet Transform (UDCT).

  Consider using other, more mature projects.

  |                                                             | Description                         | License                                  | N-D?       | Invertible? |
  | ----------------------------------------------------------- | ----------------------------------- | ---------------------------------------- | ---------- | ----------- |
  | curvelets                                                   | UDCT in Python                      | MIT                                      | N-D        | Exact       |
  | [Curvelab](https://curvelet.org/software.php)               | FDCT in C++ and Matlab              | Proprietary (free for academic use only) | 2D, 3D     | Exact       |
  | [curvelops](https://github.com/PyLops/curvelops)            | Curvelab Python wrapper             | MIT, depedends on Curvelab               | 2D, 3D     | Exact       |
  | [Kymatio](https://www.kymat.io/)                            | Wavelet scattering transform        | BSD 3-clause                             | 1D, 2D, 3D | Approximate |
  | [dtcwt](https://dtcwt.readthedocs.io)                       | Dual-Tree Complex Wavelet Transform | Custom BSD 2-clause                      | 1D, 2D, 3D | Exact       |
  | [Pytorch Wavelets](https://pytorch-wavelets.readthedocs.io) | Discrete WT and Dual-Tree CWT       | MIT                                      | 2D         | Exact       |





     Curvelets are like wavelets, but in 2D (3D, 4D, etc.). But so are steerable wavelets, Gabor wavelets, wedgelets, beamlets, bandlets, contourlets, shearlets, wave atoms, platelets, surfacelets, ... you get the idea. Like wavelets, these "X-lets" allow us to separate a signal into different "scales" (analog to frequency in 1D, that is, how fast the signal is varying), "location" (equivalent to time in 1D) and the direction in which the signal is varying (which does not have 1D analog).

     What separates curvelets from the other X-lets are their interesting properties, including:
     * The curvelet transform has an exact inverse
     * The discrete curvelet transform has efficient decomposition ("analysis") and reconstruction ("synthesis") implementations [[1](#1-candès-e-l-demanet-d-donoho-and-l-ying-2006-fast-discrete-curvelet-transforms-multiscale-modeling--simulation-5-861899), [2](#2-nguyen-t-t-and-h-chauris-2010-uniform-discrete-curvelet-transform-ieee-transactions-on-signal-processing-58-36183634)]
     * The curvelet transform is naturally N-dimensional
     * Curvelet basis functions yield an optimally sparse representation of wave phenomena (seismic data, ultrasound data, etc.) [[3](#3-candès-e-j-and-l-demanet-2005-the-curvelet-representation-of-wave-propagators-is-optimally-sparse-communications-on-pure-and-applied-mathematics-58-14721528)]
     * Curvelets have little redundancy, forming a _tight frame_ [[4](#4-candès-e-j-and-d-l-donoho-2003-new-tight-frames-of-curvelets-and-optimal-representations-of-objects-with-piecewise-c2-singularities-communications-on-pure-and-applied-mathematics-57-219266)]

    You can find a good overview (plug: I wrote it!) of curvelets in the Medium article [Demystifying Curvelets](https://towardsdatascience.com/desmystifying-curvelets-c6d88faba0bf).


     Curvelets have a long history and rich history in signal processing. They have been used for a multitude of tasks related in areas such as biomedical imaging (ultrasound, MRI), seismic imaging, synthetic aperture radar, among others. They allow us to extract useful features which can be used to attack problems such as segmentation, inpaining, classification, adaptive subtraction, etc.



  There are three flavors of the discrete curvelet transform with available implementations. The first two are based on the Fast Discrete Curvelet Transform (FDCT) pioneered by Candès, Demanet, Donoho and Ying. They are the "wrapping" and "USFFT" (unequally-spaced Fast Fourier Transform) versions of the FDCT. Both are implemented (2D and 3D for the wrapping version and 2D only for the USFFT version) in the proprietary [CurveLab Toolbox](http://www.curvelet.org/software.html) in Matlab and C++.

  As of 2024, any non-academic use of the CurveLab Toolbox requires a commercial license. This includes libraries which wrap the CurveLab toolbox such as pybind11-based wrapper [curvelops](https://github.com/PyLops/curvelops), Python SWIG-based wrapper [PyCurvelab](https://github.com/slimgroup/PyCurvelab). Neither curvelops nor PyCurvelab package include any source code of Curvelab. It should be noted, however, that any library which ports or converts Curvelab code to another language is subject to Curvelab's license. Again, neither curvelops or PyCurvelab do so, and can therefore be freely distributed as per their licenses (both have MIT licenses).

  A third flavor is the Uniform Discrete Curvelet Transform (UDCT) which does not have the same restrictive license as the FDCT. The UDCT was first implemented in Matlab (see [ucurvmd](https://github.com/nttruong7/ucurvmd) \[dead link\]) by one of its authors, Truong Nguyen. The 2D version was ported to Julia as the [Curvelet.jl](https://github.com/fundamental/Curvelet.jl) package, whose development has since been abandoned.

  This library provides the first pure-Python implementation of the UDCT, borrowing heavily from Nguyen's original implementation. The goal of this library is to allow industry processionals to use the UDCT more easily.

  Note: The Candès FDCTs and Nguyen UDCT are not the only curvelet transforms. To my knowledge, there is another implementation of the 3D Discrete Curvelet Transform named the LR-FCT (Low-Redudancy Fast Curvelet Transform) by Woiselle, Stack and Fadili [[5](#5-woiselle-a-j-l-starck-and-j-fadili-2010-3d-curvelet-transforms-and-astronomical-data-restoration-applied-and-computational-harmonic-analysis-28-171188)], but the code seems to have disappeared off the internet [[6](#6-starck-jean-luc-f-cur3d--cosmostat-cosmostat-26-june-2017-wwwcosmostatorgsoftwaref-cur3d-accessed-25-feb-2024)]. Moreover, there is also another type of continuous curvelet transform, the monogenic curvelet transform [[7](#7-storath-m-2010-the-monogenic-curvelet-transform-2010-ieee-international-conference-on-image-processing)], but I have found no implementation available.
  Lastly, the [S2LET](https://astro-informatics.github.io/s2let/) package the equivalent of curvelets but on the sphere [[8](#8-chan-j-y-h-b-leistedt-t-d-kitching-and-j-d-mcewen-2017-second-generation-curvelets-on-the-sphere-ieee-transactions-on-signal-processing-65-514)].


  This is another facet of the "data-centric" vs "model-centric" debate in machine learning. Exploiting curvelets is a type of model engineering, as opposed to using conventional model architectures and letting the data guide the learning process. Alternatively, if the transform is used as a preprocessing step, it can be seen from as feature engineering.

  My suggestion is to use curvelets and other transforms for small to mid-sized datasets, especially in niche areas without a wide variety of high-quality tranining data. It has been shown that fixed filter banks can be useful in speeding up training and improving performance of deep neural networks [[9](#9-luan-s-c-chen-b-zhang-j-han-and-j-liu-2018-gabor-convolutional-networks-ieee-transactions-on-image-processing-27-43574366), [10](#10-bruna-j-and-s-mallat-2013-invariant-scattering-convolution-networks-ieee-transactions-on-pattern-analysis-and-machine-intelligence-35-18721886)] in some cases.

  Another expected to consider is the availability of high-performance, GPU-accelerated and autodiff-friendly libraries. As far as I know, no curvelet library (including this one) satisfies those constraints. Alternative transforms can be found in [Kymatio](https://www.kymat.io/) and [Pytorch Wavelets](https://pytorch-wavelets.readthedocs.io/en/latest/readme.html) which implement the wavelet scattering transform [[11](#11-andreux-m-t-angles-g-exarchakis-r-leonarduzzi-g-rochette-l-thiry-j-zarka-s-mallat-j-andén-e-belilovsky-j-bruna-v-lostanlen-m-chaudhary-m-j-hirn-e-oyallon-s-zhang-c-cella-and-m-eickenberg-2020-kymatio-scattering-transforms-in-python-journal-of-machine-learning-research-2160-16)] and dual-tree complex wavelet transform, respectively [[12](#12-kingsbury-n-2001-complex-wavelets-for-shift-invariant-analysis-and-filtering-of-signals-applied-and-computational-harmonic-analysis-10-234253)].

rpm_license:
  Copyright 2024 Carlos Alberto da Costa Filho  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: e9ca855ad62b62ed4bfdb56aeb220b323aaa7499136b7989f7c0548ec2349434
name: python-curvenote
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Helper library from Curvenote for data science in Jupyter notebooks
url: http://curvenote.com
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curvenote-0.7.2-1.src.rpm
checksum_type: sha256
description:
  The Curvenote helper library for working in Jupyter Notebooks with Python kernels



  ```bash
      ~$ python -m pip install curvenote
  ```



  - `stash` save a dict or pandas dataframe in a cell output without diaplying the data

    ```python
         from curvenote import stash

         stash('myvars', myvars)
    ```

  - `AppState` a traitlet based class to help manage state in ipywidgets ui's

    ```python
      from curvenote import AppState, with_state

      state = AppState()

      
      wave_1_amp = FloatSlider(1.0, min=0.1, max=5.0, step=0.1, description="1 - Amp")
      state.register_stateful_widget(wave_1_amp, "wave_1_amp", Float(1.0))

      
      state.register_stateful_property("my_dict", Dict(dict(A="hello", B="world", C=1)))

      
      def my_update_fn(state):
        some_calc_function(state.wave_1_amp, state.my_dict)
      state.observe(with_state(my_update_fn))

      
      def wave_1_observer(evt):
        pass
      state.register_widget_observer("wave_1_amp", wave_1_observer)

      
      def trait_observer(evt):
        pass
      state.register_widget_observer("my_dict", trait_observer)

      
      from IPython.display import display
      display(state.outlet)

    ```


pkgId: d3fa99824c3eb335aff6b6f3a0ca80dae55ebe937e991b387ac4a655fea644ef
name: python-curvit
arch: src
version: 1.7.2
epoch: 0
release: 1
summary: light curves from UVIT data
url: https://github.com/prajwel/curvit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-curvit-1.7.2-1.src.rpm
checksum_type: sha256
description:
  > Create light curves from UVIT data.

  <a href="https://ascl.net/2101.013"><img src="https://img.shields.io/badge/ascl-2101.013-blue.svg?colorB=262255" alt="ascl:2101.013" /></a>
  <a href="https://pypi.org/project/curvit/"><img src="https://img.shields.io/pypi/v/curvit?color=262255"/></a>
  [![Documentation Status](https://readthedocs.org/projects/curvit/badge/?version=latest)](https://curvit.readthedocs.io/en/latest/?badge=latest)




  Curvit is an open-source python package to generate light curves from UVIT (Ultraviolet Imaging Telescope) data.

  The software paper manuscript is accessible at https://arxiv.org/abs/2101.06377



  Curvit is on the Python Package Index (PyPI) and you can install the package using [pip](https://pip.pypa.io/en/stable/) as follows:

  ```sh
  pip install curvit --user
  ```



  If you come across any bugs or mistakes, please report them on the GitHub issue tracker. If you have a solution or a new feature in mind, we welcome you to submit a pull request! Your contributions are greatly appreciated in making Curvit even better.


pkgId: 668efa7cb8794a94ae19712cddd62c940f2bc3a47ffce50983dd1d8671fc941c
name: python-cus-lib
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: custom common fun
url: https://github.com/crazyetiii/common_lib
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cus-lib-0.0.2-1.src.rpm
checksum_type: sha256
description:
  1. 使用方式
  2. 导包，可选

  ```
  cus_lib

  Usage:

      from cus_log import setup_logger

      logger = setup_logger("test.log")
      logger.info('test cus_lib!')
  """


  ```



  ```bash
  py -m build
  ```



  ```bash
  twine upload dist/*

  ```


pkgId: 7792b3d4558c21ee1a80607e19d7e5a26f427bf9ff32f980a7023d1149d4fd1f
name: python-cushy-storage
arch: src
version: 1.3.8
epoch: 0
release: 1
summary: A data local persistence ORM framework.
url: https://github.com/Undertone0809/cushy-storage
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cushy-storage-1.3.8-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
      cushy-storage
  </h1>
  <p align="center">
    <strong>An ORM framework based on disk caching</strong>
  </p>

  <p align="center">
      <a target="_blank" href="">
          <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg?label=license" />
      </a>
      <a target="_blank" href=''>
          <img src="https://static.pepy.tech/personalized-badge/cushy-storage?period=total&units=international_system&left_color=grey&right_color=blue&left_text=Downloads/Total"/>
     </a>
      <a target="_blank" href=''>
          <img src="https://static.pepy.tech/personalized-badge/cushy-storage?period=month&units=international_system&left_color=grey&right_color=blue&left_text=Downloads/Week"/>
     </a>
      <a target="_blank" href=''>
          <img src="assets/coverage.svg"/>
      </a>
  </p>

  [English](/README.md) [中文](/README_zh.md)



  cushy-storage is an ORM framework based on disk caching that allows you to easily perform CRUD operations on your custom data through ORM. On the other hand, cushy-storage saves you the effort of devising a data storage standard. Dictionary-like operations can reduce a lot of development costs. If you have a need for local file data operations, this framework can facilitate local data storage with ease.



  - Supports ORM storage, basic data storage, and custom data storage, compatible with all data types
  - Supports ORM framework-level object operations, enabling easy CRUD operations on object-level data
  - Basic data storage operations are as simple as dict read and write, very convenient
  - Easily perform local disk storage of data (basic data types, custom data types)
  - Eliminates the need for direct file handling
  - Provides multiple serialization options
  - Offers various data compression methods



  - [Official documentation on github-pages](https://undertone0809.github.io/cushy-storage/#/)
  - [Current development plan](https://undertone0809.github.io/cushy-storage/#/plan)
  - [Contribution/Developer's manual](https://undertone0809.github.io/cushy-storage/#/contribution)
  - [Frequently Asked Questions](https://undertone0809.github.io/cushy-storage/#/qa)
  - [pypi repository](https://pypi.org/project/cushy-storage/)



  ```bash
  pip install cushy-storage -U
  ```



  The use of `cushy-storage` is mainly divided into four parts: `CushyOrmCache`, `CushyDict`, `BaseDict`, `disk_cache`. For more detailed information, please read the relevant documentation.

  - [CushyORMCache](https://undertone0809.github.io/cushy-storage/#/cushy-orm-cache?id=cushyormcache)
    Object storage based on the ORM framework, which allows for very convenient CRUD operations on object-level data.
  - [CushyDict](https://undertone0809.github.io/cushy-storage/#/cushy-dict): An enhanced version of `BaseDict`, storing various types of data, including basic data types and custom data types.
  - [BaseDict](https://undertone0809.github.io/cushy-storage/#/base-dict): Stores basic binary data.
  - [disk_cache](https://undertone0809.github.io/cushy-storage/#/disk-cache): Function data caching.



  If you want to contribute to this project, you can submit a PR or issue. I am happy to see more people get involved and improve it.


pkgId: c5e9933d6e678e10aeafb70d255cdb2bd42efe51ed67012d0a3012e8eec2053b
name: python-custodes
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: ok
url: https://github.com/private_repo/uuidentifier
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custodes-0.1.1-1.src.rpm
checksum_type: sha256
description:
  App guardians.


  ```python
  import asyncio
  from typing import Any, Dict

  from codefast.asyncio.rabbitmq import consume
  from rich import print

  from custodes.server import get
  from custodes.client import post

  async def main():
      return await asyncio.gather(
          post('custodes server', {'code': 0, 'message': 'OK'}, loop=True, expire=120),
          get()
      )

  if __name__ == '__main__':
      cf.info('custodes server started...')
      asyncio.run(main())

  ```


pkgId: d4579fd4c2dea79b1fdaf7cd76e87f1d58502676a994a18b4915ee0315bb9bb8
name: python-custodian
arch: src
version: 2024.10.14
epoch: 0
release: 1
summary: A simple JIT job management framework in Python.
url: https://pypi.org/project/custodian/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custodian-2024.10.14-1.src.rpm
checksum_type: sha256
description:
  ![Custodian logo](https://raw.githubusercontent.com/materialsproject/custodian/master/docs/assets/custodian_logo.png)
  [![GitHub license](https://img.shields.io/github/license/materialsproject/custodian)](https://github.com/materialsproject/custodian/blob/main/LICENSE)
  [![Linting](https://github.com/materialsproject/custodian/workflows/Linting/badge.svg)](https://github.com/materialsproject/custodian/workflows/Linting/badge.svg)
  [![Testing](https://github.com/materialsproject/custodian/actions/workflows/test.yml/badge.svg)](https://github.com/materialsproject/custodian/actions/workflows/test.yml)
  [![Downloads](https://pepy.tech/badge/custodian)](https://pepy.tech/project/custodian)
  [![codecov](https://codecov.io/gh/materialsproject/custodian/branch/master/graph/badge.svg?token=OwDQVJnghu)](https://codecov.io/gh/materialsproject/custodian)

  Custodian is a simple, robust and flexible just-in-time (JIT) job management
  framework written in Python. Using custodian, you can create wrappers that
  perform error checking, job management and error recovery. It has a simple
  plugin framework that allows you to develop specific job management workflows
  for different applications.

  Error recovery is an important aspect of many *high-throughput* projects that
  generate data on a large scale. When you are running on the order of hundreds
  of thousands of jobs, even an error-rate of 1% would mean thousands of errored
  jobs that would be impossible to deal with on a case-by-case basis.

  The specific use case for custodian is for long running jobs, with potentially
  random errors. For example, there may be a script that takes several days to
  run on a server, with a 1% chance of some IO error causing the job to fail.
  Using custodian, one can develop a mechanism to gracefully recover from the
  error, and restart the job with modified parameters if necessary.

  The current version of Custodian also comes with several sub-packages for error
  handling for Vienna Ab Initio Simulation Package (VASP), NwChem, QChem, FEFF, Lobster and CP2K
  calculations.





  The version at the Python Package Index (PyPI) is always the latest stable release that will be hopefully, be
  relatively bug-free. Install as follows:

  ```sh
  pip install custodian
  ```

  Some plugins (e.g., VASP management) require additional setup (please see [pymatgen docs]).



  The bleeding edge developmental version is at the custodian's [Github repo](https://github.com/materialsproject/custodian). The developmental
  version is likely to be more buggy, but may contain new features. The Github version include test files as well for
  complete unit testing. After cloning the source, you can type

  ```sh
  pip install -e .
  ```

  to install the package in editable mode.



  Custodian supports Python 3.8+. There are no other required dependencies. However, if you wish to use many of the
  built-in error handlers and Jobs for VASP, NWChem, QChem, etc., you will likely need pymatgen to be installed as well.



  Please refer to the official [custodian docs] for details on how to use
  custodian.



  If you use custodian in your research, especially the VASP component, please
  consider citing the following work:

  ```txt
  Shyue Ping Ong, William Davidson Richards, Anubhav Jain, Geoffroy Hautier,
  Michael Kocher, Shreyas Cholia, Dan Gunter, Vincent Chevrier, Kristin A.
  Persson, Gerbrand Ceder. *Python Materials Genomics (pymatgen) : A Robust,
  Open-Source Python Library for Materials Analysis.* Computational
  Materials Science, 2013, 68, 314-319. doi:10.1016/j.commatsci.2012.10.028
  ```



  Custodian is released under the MIT License. The terms of the license are as
  follows:

  ```txt
  The MIT License (MIT)
  Copyright (c) 2011-2012 MIT & LBNL

  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.
  ```

  [pymatgen docs]: http://pymatgen.org/
  [custodian docs]: https://materialsproject.github.io/custodian/

rpm_license:
  The MIT License (MIT) Copyright (c) 2011-2012 MIT & LBNL  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: 025315966f645546c6dff88bcaa585a2b0b2938cf81dc75ef64ad03ca0f5369c
name: python-custom-formatter
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A lightweight package for formatting and serializing messages.
url: https://github.com/manidasari27/formatter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-formatter-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Formatter is a lightweight Python package for formatting and serializing messages. It simplifies the process of creating structured data for logging, notifications, and integrations with AWS services.



  ```bash
  pip install formatter
  ```


pkgId: 35aca2a05d9f41b8c9d243bfe68f546507ff49626536be229384e6390dafccc1
name: python-custom-inherit
arch: src
version: 2.4.1
epoch: 0
release: 1
url: https://github.com/rsokl/custom_inherit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-inherit-2.4.1-1.src.rpm
checksum_type: sha256
summary:
  A Python package that provides customized docstring inheritance       schemes between derived classes and their parents.


pkgId: ca33bfde48f72384565720005f649f80ee94000036ae0f842cebdfbd4391d3ce
name: python-custom-json-diff
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: CycloneDx BOM and Oasis CSAF diffing and comparison tool.
url: https://github.com/appthreat/custom-json-diff
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-json-diff-2.1.1-1.src.rpm
checksum_type: sha256
description:
  Comparing two JSON files presents an issue when the two files have certain fields which are
  dynamically generated (e.g. timestamps), variable ordering, or other fields which need to be
  excluded or undergo specialized comparison for one reason or another. Enter custom-json-diff,
  which allows you to specify fields to ignore in the comparison and sorts all fields.



  `pip install custom-json-diff`



  Note, you may use `cjd` rather than `custom-json-diff` to run.

  ```
  usage: custom-json-diff [-h] [-v] -i INPUT INPUT [-o OUTPUT] [-c CONFIG] [-x EXCLUDE] [--debug] {preset-diff} ...

  positional arguments:
    {preset-diff}         subcommand help
      preset-diff         Compare CycloneDX BOMs or Oasis CSAFs

  options:
    -h, --help            show this help message and exit
    -v, --version         show program's version number and exit
    -i INPUT INPUT, --input INPUT INPUT
                          Two JSON files to compare - older file first.
    -o OUTPUT, --output OUTPUT
                          Export JSON of differences to this file.
    -c CONFIG, --config-file CONFIG
                          Import TOML configuration file (overrides commandline options).
    -x EXCLUDE, --exclude EXCLUDE
                          Exclude field(s) from comparison.
    --debug               Print debug messages.

  ```

  preset-diff usage
  ```
  usage: custom-json-diff preset-diff [-h] [--allow-new-versions] [--allow-new-data] [--type PRESET_TYPE] [-r REPORT_TEMPLATE] [--include-extra INCLUDE]

  options:
    -h, --help            show this help message and exit
    --allow-new-versions, -anv
                          BOM only - allow newer versions in second BOM to pass.
    --allow-new-data, -and
                          Allow populated values in newer BOM or CSAF to pass against empty values in original BOM/CSAF.
    --type PRESET_TYPE    Either bom or csaf
    -r REPORT_TEMPLATE, --report-template REPORT_TEMPLATE
                          Jinja2 template to use for report generation.
    --include-extra INCLUDE
                          BOM only - include properties/evidence/licenses/hashes/externalReferences (list which with comma, no space, inbetween).

  ```


  CJD offers advanced diffing for Cyclonedx BOM (v1.5 or v1.6) produced by
  [CycloneDx Cdxgen](https://github.com/CycloneDX/cdxgen) and Oasis CSAF v2 produced by
  [OWASP-dep-scan](https://github.com/OWASP-dep-scan/dep-scan).




  The `preset-diff --type bom` command compares CycloneDx BOM components, services, and dependencies, as well as data
  outside of these parts.

  Some component fields are excluded from the component comparison by default but can be explicitly
  specified for inclusion using `preset-diff --include-extra` and whichever field(s) you wish to include (e.g.
  `--include-extra properties,evidence,licenses`:
  - properties
  - evidence
  - licenses
  - hashes
  - externalReferences

  You can use the -x --exclude switch before the preset-diff command to exclude any of these
  (see [Specifying fields to exclude](#specifying-fields-to-exclude)) except for bom-ref, as that is needed for the comparison -
  if the bom-ref includes a version, that part can be excluded as needed (see
  [Allowing newer versions](#allowing-newer-versions)).

  Default included fields:

  bomFormat
  metadata
  specVersion
  version

  components:
  - author
  - bom-ref
  - description
  - group
  - name
  - publisher
  - purl
  - scope
  - type
  - version

  services
  - name
  - endpoints
  - authenticated
  - x-trust-boundary

  dependencies
  - dependsOn
  - ref

  vulnerabilities
  - advisories
  - affects
  - analysis
  - bom-ref
  - cwes
  - description
  - detail
  - id
  - properties
  - published
  - ratings
  - recommendation
  - references
  - source
  - updated




  CSAF diffing includes the following fields at this time. Only the vulnerabilities section uses the
  allows new data option. Fields can be excluded using the -x --exclude as described for bom diffing
  except for title as that is currently being populated by depscan with the bom-ref of the
  vulnerability as a unique id.

  document

  product_tree

  vulnerabilities
  - acknowledgements
  - cwe
  - cve
  - discovery_date
  - ids
  - notes
  - product_status
  - references
  - scores
  - title




  [Currently BOM only] The --allow-new-versions option attempts to parse component versions and
  ascertain if a discrepancy is attributable to an updated version. Dependency refs and dependents
  are compared with the version string removed rather than checking for a newer version.




  The --allow-new-data option allows for empty fields in the original BOM not to be reported as a
  difference when the data is populated in the second specified BOM. It also addresses when a field
  such as properties is expanded, checking that all original elements are still present but allowing
  additional elements in the newer BOM.

  The --components-only option only analyzes components, not services, dependencies, or other data.



  You may use the builtin report templates or create one of your own. The variables available to you
  for each preset type are as follows.

  **BOM**
  * common_lib
  * common_frameworks
  * common_services
  * common_deps
  * common_apps
  * common_other
  * common_vdrs
  * diff_lib_1
  * diff_lib_2
  * diff_frameworks_1
  * diff_frameworks_2
  * diff_apps_1
  * diff_apps_2
  * diff_other_1
  * diff_other_2
  * diff_services_1
  * diff_services_2
  * diff_deps_1
  * diff_deps_2
  * diff_vdrs_1
  * diff_vdrs_2
  * bom_1 (filename)
  * bom_2
  * stats (this is a statistic summary)
  * metadata (a bool to indicate if misc_data passed)
  * diff_status (integer representing the diff status)

  **CSAF**
  * common_document
  * common_product_tree
  * common_vulnerabilities
  * diff_document_1
  * diff_document_2
  * diff_product_tree_1
  * diff_product_tree_2
  * diff_vulnerabilities_1
  * diff_vulnerabilities_2
  * diff_status (integer representing the diff status)
  * csaf_1 (filename)
  * csaf_2




  To exclude fields from comparison, use the `-x` or `--exclude` flag and specify the field name(s)
  to exclude. The json will be flattened, so fields are specified using dot notation. For example:

  ```json
  {
      "field1": {
          "field2": "value",
          "field3": [
              {"a": "val1", "b": "val2"},
              {"a": "val3", "b": "val4"}
          ]
      }
  }
  ```

  is flattened to:
  ```json
  {
      "field1.field2": "value",
      "field1.field3.[0].a": "val1",
      "field1.field3.[0].b": "val2",
      "field1.field3.[1].a": "val3",
      "field1.field3.[1].b": "val4"
  }
  ```

  To exclude field2, you would specify `field1.field2`. To exclude the `a` field in the array of
  objects, you would specify `field1.field3.[].a` (do NOT include the array index, just do `[]`).
  Multiple fields may be specified separated by a comma (no space). To better understand what your fields should
  be, check out json-flatten, which is the package used for this function.



  custom-json-diff will sort the imported JSON alphabetically. If your JSON document contains arrays
  of objects, you will need to specify any keys you want to sort by in a toml file or use a preset.
  The first key located from the provided keys that is present in the object will be used, so order
  any keys provided accordingly.



  ```toml
  [settings]
  excluded_fields = []
  sort_keys = ["url", "content", "ref", "name", "value"]

  [preset_settings]
  type = "bom"
  allow_new_data = false
  allow_new_versions = true
  components_only = false
  include_extra = ["licenses", "properties", "hashes", "evidence", "externalReferences"]
  report_template = "custom_json_diff/bom_diff_template.j2"
  ```


pkgId: 794f5f5ccb5d189b5d89562dd8204326a040ec38bf29532f2af858f513cf5275
name: python-custom-json-diff
arch: src
version: 2.1.3
epoch: 0
release: 1
summary: CycloneDx BOM and Oasis CSAF diffing and comparison tool.
url: https://github.com/appthreat/custom-json-diff
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-json-diff-2.1.3-1.src.rpm
checksum_type: sha256
description:
  Comparing two JSON files presents an issue when the two files have certain fields which are
  dynamically generated (e.g. timestamps), variable ordering, or other fields which need to be
  excluded or undergo specialized comparison for one reason or another. Enter custom-json-diff,
  which allows you to specify fields to ignore in the comparison and sorts all fields.



  `pip install custom-json-diff`



  Note, you may use `cjd` rather than `custom-json-diff` to run.

  ```
  usage: custom-json-diff [-h] [-v] -i INPUT INPUT [-o OUTPUT] [-c CONFIG] [-x EXCLUDE] [--debug] {preset-diff} ...

  positional arguments:
    {preset-diff}         subcommand help
      preset-diff         Compare CycloneDX BOMs or Oasis CSAFs

  options:
    -h, --help            show this help message and exit
    -v, --version         show program's version number and exit
    -i INPUT INPUT, --input INPUT INPUT
                          Two JSON files to compare - older file first.
    -o OUTPUT, --output OUTPUT
                          Export JSON of differences to this file.
    -c CONFIG, --config-file CONFIG
                          Import TOML configuration file (overrides commandline options).
    -x EXCLUDE, --exclude EXCLUDE
                          Exclude field(s) from comparison.
    --debug               Print debug messages.

  ```

  preset-diff usage
  ```
  usage: custom-json-diff preset-diff [-h] [--allow-new-versions] [--allow-new-data] [--type PRESET_TYPE] [-r REPORT_TEMPLATE] [--include-extra INCLUDE] [--include-empty] [--bom-profile BOM_PROFILE]

  options:
    -h, --help            show this help message and exit
    --allow-new-versions, -anv
                          BOM only - allow newer versions in second BOM to pass.
    --allow-new-data, -and
                          Allow populated values in newer BOM or CSAF to pass against empty values in original BOM/CSAF.
    --type PRESET_TYPE    Either bom or csaf
    -r REPORT_TEMPLATE, --report-template REPORT_TEMPLATE
                          Jinja2 template to use for report generation.
    --include-extra INCLUDE
                          BOM only - include properties/evidence/licenses/hashes/externalReferences (list which with comma, no space, inbetween).
    --include-empty, -e   Include keys with empty values in summary.
    --bom-profile BOM_PROFILE, -b BOM_PROFILE
                          Beta feature. Options: gn, gnv, nv -> only compare bom group/name/version.

  ```


  CJD offers advanced diffing for Cyclonedx BOM (v1.5 or v1.6) produced by
  [CycloneDx Cdxgen](https://github.com/CycloneDX/cdxgen) and Oasis CSAF v2 produced by
  [OWASP-dep-scan](https://github.com/OWASP-dep-scan/dep-scan).




  The `preset-diff --type bom` command compares CycloneDx BOM components, services, and dependencies, as well as data
  outside of these parts.

  Some component fields are excluded from the component comparison by default but can be explicitly
  specified for inclusion using `preset-diff --include-extra` and whichever field(s) you wish to include (e.g.
  `--include-extra properties,evidence,licenses`:
  - properties
  - evidence
  - licenses
  - hashes
  - externalReferences

  You can use the -x --exclude switch before the preset-diff command to exclude any of these
  (see [Specifying fields to exclude](#specifying-fields-to-exclude)) except for bom-ref, as that is needed for the comparison -
  if the bom-ref includes a version, that part can be excluded as needed (see
  [Allowing newer versions](#allowing-newer-versions)).

  Default included fields:

  bomFormat
  metadata
  specVersion
  version

  components:
  - author
  - bom-ref
  - description
  - group
  - name
  - publisher
  - purl
  - scope
  - type
  - version

  services
  - name
  - endpoints
  - authenticated
  - x-trust-boundary

  dependencies
  - dependsOn
  - ref

  vulnerabilities
  - advisories
  - affects
  - analysis
  - bom-ref
  - cwes
  - description
  - detail
  - id
  - properties
  - published
  - ratings
  - recommendation
  - references
  - source
  - updated




  CSAF diffing includes the following fields at this time. Only the vulnerabilities section uses the
  allows new data option. Fields can be excluded using the -x --exclude as described for bom diffing
  except for title as that is currently being populated by depscan with the bom-ref of the
  vulnerability as a unique id.

  document

  product_tree

  vulnerabilities
  - acknowledgements
  - cwe
  - cve
  - discovery_date
  - ids
  - notes
  - product_status
  - references
  - scores
  - title




  [Currently BOM only] The --allow-new-versions option attempts to parse component versions and
  ascertain if a discrepancy is attributable to an updated version. Dependency refs and dependents
  are compared with the version string removed rather than checking for a newer version.




  The --allow-new-data option allows for empty fields in the original BOM not to be reported as a
  difference when the data is populated in the second specified BOM. It also addresses when a field
  such as properties is expanded, checking that all original elements are still present but allowing
  additional elements in the newer BOM.

  The --components-only option only analyzes components, not services, dependencies, or other data.



  You may use the builtin report templates or create one of your own. The variables available to you
  for each preset type are as follows.

  **BOM**
  * common_lib
  * common_frameworks
  * common_services
  * common_deps
  * common_apps
  * common_other
  * common_vdrs
  * diff_lib_1
  * diff_lib_2
  * diff_frameworks_1
  * diff_frameworks_2
  * diff_apps_1
  * diff_apps_2
  * diff_other_1
  * diff_other_2
  * diff_services_1
  * diff_services_2
  * diff_deps_1
  * diff_deps_2
  * diff_vdrs_1
  * diff_vdrs_2
  * bom_1 (filename)
  * bom_2
  * stats (this is a statistic summary)
  * metadata (a bool to indicate if misc_data passed)
  * diff_status (integer representing the diff status)

  **CSAF**
  * common_document
  * common_product_tree
  * common_vulnerabilities
  * diff_document_1
  * diff_document_2
  * diff_product_tree_1
  * diff_product_tree_2
  * diff_vulnerabilities_1
  * diff_vulnerabilities_2
  * diff_status (integer representing the diff status)
  * csaf_1 (filename)
  * csaf_2




  To exclude fields from comparison, use the `-x` or `--exclude` flag and specify the field name(s)
  to exclude. The json will be flattened, so fields are specified using dot notation. For example:

  ```json
  {
      "field1": {
          "field2": "value",
          "field3": [
              {"a": "val1", "b": "val2"},
              {"a": "val3", "b": "val4"}
          ]
      }
  }
  ```

  is flattened to:
  ```json
  {
      "field1.field2": "value",
      "field1.field3.[0].a": "val1",
      "field1.field3.[0].b": "val2",
      "field1.field3.[1].a": "val3",
      "field1.field3.[1].b": "val4"
  }
  ```

  To exclude field2, you would specify `field1.field2`. To exclude the `a` field in the array of
  objects, you would specify `field1.field3.[].a` (do NOT include the array index, just do `[]`).
  Multiple fields may be specified separated by a comma (no space). To better understand what your fields should
  be, check out json-flatten, which is the package used for this function.



  custom-json-diff will sort the imported JSON alphabetically. If your JSON document contains arrays
  of objects, you will need to specify any keys you want to sort by in a toml file or use a preset.
  The first key located from the provided keys that is present in the object will be used, so order
  any keys provided accordingly.



  ```toml
  [settings]
  excluded_fields = []
  sort_keys = ["url", "content", "ref", "name", "value"]

  [preset_settings]
  type = "bom"
  allow_new_data = false
  allow_new_versions = true
  components_only = false
  include_extra = ["licenses", "properties", "hashes", "evidence", "externalReferences"]
  report_template = "custom_json_diff/bom_diff_template.j2"
  ```


pkgId: 428d1e8a7895203b3496e0736f747b8a1df810ce35fbfe7757166494b53681fe
name: python-custom-library-22
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: A utility library for S3 file management and helper functions
url: https://github.com/yourusername/custom-library
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-library-22-1.1.1-1.src.rpm
checksum_type: sha256
description:
  This library provides utility classes for managing S3 file uploads and helper functions.


  - Upload files to AWS S3.
  - Delete files from AWS S3.
  - Helper functions for file validation and secure filename generation.


  ```
  pip install custom-library
  ```


  ```python
  from custom_library import S3FileManager, HelperFunctions


  ```


  MIT


pkgId: a49886c1117ea5bd75da10f1ddc327f35947c3cb62dc8a7a2d2fc46b08558d3b
name: python-custom-literals
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A module implementing custom literal suffixes using pure Python
url: https://github.com/RocketRace/custom-literals
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-literals-0.1.4-1.src.rpm
checksum_type: sha256
description:
  A module implementing custom literal suffixes using pure Python. `custom-literals`
  mimics C++'s user-defined literals (UDLs) by defining literal suffixes that can
  be accessed as attributes of literal values, such as numeric constants, string
  literals and more.
  (c) RocketRace 2022-present. See LICENSE file for more.


pkgId: 603566f11d847f5bf1cb893712d2a159d2edc9b4b58effaa727bccddbab0b828
name: python-custom-python-matter-server
arch: src
version: 6.9.23
epoch: 0
release: 1
summary: Python Matter WebSocket Server with custom sensors
url: https://pypi.org/project/custom-python-matter-server/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-python-matter-server-6.9.23-1.src.rpm
checksum_type: sha256
description:
  This project implements a Matter Controller Server over WebSockets using the
  [official Matter (formerly CHIP) SDK](https://github.com/project-chip/connectedhomeip)
  as a base and provides both a server and client implementation.

  The goal of this project is primarily to have Matter support in Home Assistant
  but its universal approach makes it suitable to be used in other projects too.

  [![Python Matter Server - A library from the Open Home Foundation](https://www.openhomefoundation.org/badges/python-matter-server.png)](https://www.openhomefoundation.org/)



  Got questions?

  You have several options to get them answered:

  - The Home Assistant [Community Forum](https://community.home-assistant.io/).
  - The Home Assistant [Discord Chat Server](https://discord.gg/c5DvZ4e).
  - Join [the Reddit subreddit in /r/homeassistant](https://reddit.com/r/homeassistant).

  If you experience issues using Matter with Home Assistant, please open an issue
  report in the [Home Assistant Core repository](https://github.com/home-assistant/core/issues/new/choose).

  You may also open issues in this repository if you are absolutely sure that your
  issue is related to the Matter Server component.



  We strongly recommend using Home Assistant OS along with the official Matter
  Server add-on to use Matter with Home Assistant. The Matter integration
  automatically installs the Python Matter Server add-on. Please refer to the
  [Home Assistant documentation](https://www.home-assistant.io/integrations/matter/).
  Home Assistant OS has been tested and tuned to be used with Matter and Thread,
  which makes this combination the best tested and largely worry free
  environment.

  If you still prefer a self-managed container installation, we do offer an
  official container image. Please keep in mind that you might experience
  communication issues with Matter devices, especially Thread based devices.
  This is mostly because the container installation uses host networking, and
  relies on the networking managed by your operating system.



  Make sure you run the container on the host network. The host network
  interface needs to be in the same network as the Android/iPhone device
  you are using for commissioning. Matter uses link-local multicast protocols
  which do not work across different LANs or VLANs.

  The host network interface needs IPv6 support enabled.



  For communication through Thread border routers which are not running on the same
  host as the Matter Controller server to work, IPv6 routing needs to be properly
  working. IPv6 routing is largely setup automatically through the IPv6 Neighbor
  Discovery Protocol, specifically the Route Information Options (RIO). However,
  if IPv6 Neighbor Discovery RIO's are processed, and processed correctly depends on the network
  management software your system is using. There may be bugs and caveats in
  processing this Route Information Options.

  In general, make sure the kernel option `CONFIG_IPV6_ROUTER_PREF` is enabled and
  that IPv6 forwarding is disabled (sysctl variable `net.ipv6.conf.all.forwarding`).
  If IPv6 forwarding is enabled, the Linux kernel doesn't employ reachability
  probing (RFC 4191), which can lead to longer outages (up to 30min) until
  network changes are detected.

  If you are using NetworkManager, make sure to use at least NetworkManager 1.42.
  Previous versions lose track of routes and stale routes can lead to unreachable
  Thread devices. All current released NetworkManager versions can't handle
  multiple routes to the same network properly. This means if you have multiple
  Thread border routers, the fallback won't work immediately (see [NetworkManager
  issue #1232](https://gitlab.freedesktop.org/NetworkManager/NetworkManager/-/issues/1232)).

  We currently don't have experience with systemd-networkd. It seems to have its
  own IPv6 Neighbor Discovery Protocol handling.

  If you don't use NetworkManager or systemd-networkd, you can use the kernel's
  IPv6 Neighbor Discovery Protocol handling.

  Make sure the kernel options `CONFIG_IPV6_ROUTE_INFO` is enabled and the
  following sysctl variables are set:

  ```
  sysctl -w net.ipv6.conf.wlan0.accept_ra=1
  sysctl -w net.ipv6.conf.wlan0.accept_ra_rt_info_max_plen=64
  ```

  If your system has IPv6 forwarding enabled (not recommended, see above), you'll
  have to use `2` for the accept_ra variable. See also the [Thread Border Router - Bidirectional IPv6 Connectivity and DNS-Based Service Discovery codelab](https://openthread.io/codelabs/openthread-border-router#6).



  With the following command you can run the Matter Server in a container using
  Docker. The Matter network data (fabric information) are stored in a newly
  created directory `data` in the current directory. Adjust the command to
  choose another location instead.

  ```
  mkdir data
  docker run -d \
    --name matter-server \
    --restart=unless-stopped \
    --security-opt apparmor=unconfined \
    -v $(pwd)/data:/data \
    --network=host \
    ghcr.io/shaderhoth/custom-python-matter-server:stable
  ```

  > [!NOTE]
  > The container has a default command line set (see Dockerfile). If you intend to pass additional arguments, you have to pass the default command line as well.

  To use local commissioning with Bluetooth, make sure to pass the D-Bus socket as well:
  ```
  docker run -d \
    --name matter-server \
    --restart=unless-stopped \
    --security-opt apparmor=unconfined \
    -v $(pwd)/data:/data \
    -v /run/dbus:/run/dbus:ro \
    --network=host \
    ghcr.io/shaderhoth/custom-python-matter-server:stable --storage-path /data --paa-root-cert-dir /data/credentials --bluetooth-adapter 0
  ```



  ```sh
  docker compose up -d
  docker compose logs -f
  ```

  NOTE: Both Matter and this implementation are in an early state and features are probably missing or could be improved. See our [development notes](#development) how you can help out, with development and/or testing.



  This list is not intended to be complete, for a complete oversight see the client implementation.

  **Set WiFi credentials**

  Inform the controller about the WiFi credentials it needs to send when commissioning a new device.

  ```json
  {
    "message_id": "1",
    "command": "set_wifi_credentials",
    "args": {
      "ssid": "wifi-name-here",
      "credentials": "wifi-password-here"
    }
  }
  ```

  **Set Thread dataset**

  Inform the controller about the Thread credentials it needs to use when commissioning a new device.

  ```json
  {
    "message_id": "1",
    "command": "set_thread_dataset",
    "args": {
      "dataset": "put-credentials-here"
    }
  }
  ```

  **Commission with code**

  Commission a new device. For WiFi or Thread based devices, the credentials need to be set upfront, otherwise, commissioning will fail. Supports both QR-code syntax (MT:...) and manual pairing code as string.
  The controller will use bluetooth for the commissioning of wireless devices. If the machine running the Python Matter Server controller lacks Bluetooth support, commissioning will only work for devices already connected to the network (by cable or another controller).

  Matter QR-code
  ```json
  {
    "message_id": "2",
    "command": "commission_with_code",
    "args": {
      "code": "MT:Y.ABCDEFG123456789"
    }
  }
  ```

  Manual pairing code
  ```
  {
    "message_id": "2",
    "command": "commission_with_code",
    "args": {
      "code": "35325335079",
      "network_only": true
    }
  }
  ```

  **Open Commissioning window**

  Open a commissioning window to commission a device present on this controller to another.
  Returns code to use as discriminator.

  ```json
  {
    "message_id": "2",
    "command": "open_commissioning_window",
    "args": {
      "node_id": 1
    }
  }
  ```

  **Get Nodes**

  Get all nodes already commissioned on the controller.

  ```json
  {
    "message_id": "2",
    "command": "get_nodes"
  }
  ```

  **Get Node**

  Get info of a single Node.

  ```json
  {
    "message_id": "2",
    "command": "get_node",
    "args": {
      "node_id": 1
    }
  }
  ```

  **Start listening**

  When the start_listening command is issued, the server will dump all existing nodes. From that moment on all events (including node attribute changes) will be forwarded.

  ```json
  {
    "message_id": "3",
    "command": "start_listening"
  }
  ```

  **Send a command**

  Here is an example of turning on a switch (OnOff cluster)

  ```json
  {
    "message_id": "example",
    "command": "device_command",
    "args": {
      "endpoint_id": 1,
      "node_id": 1,
      "payload": {},
      "cluster_id": 6,
      "command_name": "On"
    }
  }
  ```

  **Python script to send a command**

  Because we use the datamodels of the Matter SDK, this is a little bit more involved.
  Here is an example of turning on a switch:

  ```python
  import json


  from chip.clusters import Objects as clusters


  from matter_server.common.helpers.util import dataclass_from_dict,dataclass_to_dict

  command = clusters.OnOff.Commands.On()
  payload = dataclass_to_dict(command)


  message = {
      "message_id": "example",
      "command": "device_command",
      "args": {
          "endpoint_id": 1,
          "node_id": 1,
          "payload": payload,
          "cluster_id": command.cluster_id,
          "command_name": "On"
      }
  }

  print(json.dumps(message, indent=2))
  ```
  You can also provide parameters for the cluster commands. Here's how to change the brightness for example:

  ```python
  command = clusters.LevelControl.Commands.MoveToLevelWithOnOff(
    level=int(value), # provide a percentage
    transitionTime=0, # in seconds
  )
  ```



  When communicating with Thread devices through a non-local Thread border router,
  your host must process ICMPv6 Router Advertisements. See the [openthread.io
  Bidirectional IPv6 Connectivity code labs](https://openthread.io/codelabs/openthread-border-router#6)
  on how-to setup your host correctly. Note that NetworkManager has its own ICMPv6
  Router Advertisement processing. A recent version of NetworkManager is
  necessary, and there are still known issues (see NetworkManager issue
  [#1232](https://gitlab.freedesktop.org/NetworkManager/NetworkManager/-/issues/1232)).

  The Home Assistant Operating System 10 and newer correctly processes ICMPv6
  Router Advertisements.



  Want to help out with development, testing, and/or documentation? Great! As both this project and Matter keeps evolving and more and more devices are available with actual Matter support, there will be a lot to improve. Reach out to us on discord if you want to help out.



  **For enabling Matter support within Home Assistant, please refer to the Home Assistant documentation. These instructions are for development only!**

  Development is only possible on a (recent) Linux or MacOS machine. Other operating systems are not supported.

  - Download/clone the repo to your local machine.
  - Set-up the development environment: `scripts/setup.sh`

  You can check out the example script in the scripts folder for generic directions to run the client and server.

  To just run the server, you can run: `python -m matter_server.server`

  The server runs a Matter Controller and includes all logic for storing node information, interviews and subscriptions. To interact with this controller we've created a small Websockets API with an RPC-like interface. The library contains a client as reference implementation which in turn is used by Home Assistant. Splitting the server from the client allows the scenario where multiple consumers can communicate to the same Matter fabric and the Matter fabric can keep running while the consumer (e.g. Home Assistant is down).



  There is also a Python client library hosted in this repository (used by Home Assistant), which consumes the Websockets API published from the server.

  The client library has a dependency on the chip/matter clusters package which contains all (Cluster) models and this package is os/platform independent. The server library depends on the Matter Core SDK (still named CHIP) which is architecture and OS specific. We build (and publish) wheels for Linux (amd64 and aarch64) to pypi but for other platforms (like Macos) you will need to build those wheels yourself using the exact same version of the SDK as we use for the clusters package. Take a look at our build script for directions: https://github.com/home-assistant-libs/chip-wheels/blob/main/.github/workflows/build.yaml

  To only install the client part: `pip install custom-python-matter-server`


pkgId: e879694c999e32178aa64cbf4f53b25278612f0c9b91d0398c600b5b20c48e79
name: python-custom-redis
arch: src
version: 3.2.2
epoch: 0
release: 1
summary: python实现简单redis，实现redis基本功能以及可插拔数据结构。
url: https://www.github.com/ShichaoMa/custom_redis
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-redis-3.2.2-1.src.rpm
checksum_type: sha256
description:
  python实现简单redis，实现redis基本功能以及可插拔数据结构<br>

  1 通过继承DataStore类，可以定制个性化数据类型，通过调用redis类的install方法安装数据类型，目前已实现的数据类型有str, set, queue, hash, <br/>
  2 Redis 的keys, expire, ttl, del等功能已实现<br/>
  3 数据持久化功能已实现<br/>

  ![](https://github.com/ShichaoMa/custom_redis/blob/master/resources/redis.jpg)

  ![](https://github.com/ShichaoMa/custom_redis/blob/master/resources/redis-server.jpg)



  ```bash
      git clone https://github.com/ShichaoMa/custom_redis.git
      sudo python setup.py install

      or

      sudo pip install custom-redis
  ```

  ```bash
      custom-redis-server
  ```


  ```bash
      custom-redis-client -c keys
      [u'a']
      custom-redis-client -c zcard a
      1
      custom-redis-client -c zpop a
      2
  ```

  ```bash
  >>> from custom_redis.client import Redis
  >>> r = Redis("127.0.0.1", 6379)
  >>> r.zadd('a', 3, 'aaa')
  ''
  >>> r.zadd('b', 4, 'bbb')
  ''
  >>> r.zadd('a', 1, 'ccc')
  ''
  >>> r.keys()
  [u'a', u'b']
  >>> r.expire('b', 10)
  ''
  >>> import time
  >>> time.sleep(10)
  >>> r.ttl('b')
  '-1'
  >>> r.keys()
  [u'a']
  ```

  ```python




  cr = CustomRedis.parse_args()
  cr.install(datatype=datatype())
  cr.start()
  ```

  ```python


  "hgetall":  # 指令名
  {
  "args": ["name"], # 指令所需参数
  "recv": lambda data: json.loads(data), # 转换函数，将接收到的报文转换成所需数据类型，若是简单字符串则无需提供
  }
  "hincrby": {
  "args": ["name", "key", "value"],
  "send": lambda *args:(args[0], json.dumps(dict([args[1:]]))),# 转换函数，返回key 和value组成的元组
  "default":[1] # 指令所需参数的默认值， 从后往前排列 如：1代表value的值
  },












  ```


pkgId: 9cbdb4c6717108cdf410165a1bf5570e4185cb874ce92d4d278c764f4365726e
name: python-custom-s3-utils
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A simple utility for handling S3 file uploads.
url: https://github.com/yourusername/custom-s3-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-custom-s3-utils-0.1.0-1.src.rpm
checksum_type: sha256
description:
  `custom-s3-utils` is a Python library for handling AWS S3 file uploads.



  ```bash
  pip install custom-s3-utils


pkgId: 6abb6e37d2777114062f2365561a736586382419c5a10bb8dde92cb0a689a41e
name: python-customdnn
arch: src
version: 1.1.4
epoch: 0
release: 1
description: README
url: https://github.com/singhmnprt01/Custom-Deep-Neural-Network
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customdnn-1.1.4-1.src.rpm
checksum_type: sha256
summary:
  A custom deep neural network package that gives the liberty to design a customized neural network (using NumPy only)


pkgId: 85e8868b36071c86802e4bfb8479f09fd2a927e992cbed509d6f3d60dea8b5fd
name: python-customerio-cdp-analytics
arch: src
version: 0.0.2
epoch: 0
release: 1
url: https://github.com/customerio/cdp-analytics-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customerio-cdp-analytics-0.0.2-1.src.rpm
checksum_type: sha256
summary:
  Customer.io Data Pipelines (CDP) is a customer data platform to improve decision-making with real-time updates and deliver personalized experiences.

description:
  Customer.io Data Pipelines (CDP) is a customer data platform to improve decision-making with real-time updates and deliver personalized experiences.

  This is the official python client that wraps the Customer.io Data Pipelines REST API (https://customer.io/docs/cdp/getting-started/cdp-getting-started/).


pkgId: b82fe4f88f09687556ebd09fc0f944d9b865869afce34262c3554c8121e9f401
name: python-customgpt-cli
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: No-code AI agent creation platform for enterprise knowledge automation
url: https://customgpt.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customgpt-cli-0.1.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/customgpt-cli.svg)](https://badge.fury.io/py/customgpt-cli)
  [![Python Support](https://img.shields.io/pypi/pyversions/customgpt-cli.svg)](https://pypi.org/project/customgpt-cli/)
  [![Documentation Status](https://readthedocs.org/projects/customgpt-cli/badge/?version=latest)](https://customgpt-cli.readthedocs.io/en/latest/?badge=latest)
  [![Coverage Status](https://codecov.io/gh/yourusername/customgpt-cli/branch/main/graph/badge.svg)](https://codecov.io/gh/yourusername/customgpt-cli)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Docker Pulls](https://img.shields.io/docker/pulls/yourusername/customgpt-cli.svg)](https://hub.docker.com/r/yourusername/customgpt-cli)

  🚀 A powerful command-line interface for CustomGPT SDK, enabling efficient project management and automation.



  - 🛠️ Full CustomGPT SDK integration
  - 🔐 Secure API key management
  - 📊 Project management and monitoring
  - 🤖 Conversation handling
  - 📄 Page management
  - 🐳 Docker support
  - 🔄 Bulk operations
  - 📊 Advanced filtering



  ```bash
  pip install customgpt-cli
  ```



  The CLI requires your CustomGPT API key. You can provide it in two ways:

  1. Environment Variable (recommended):
  ```bash
  export CUSTOMGPT_API_KEY=your_api_key
  customgpt-cli list-projects
  ```

  2. Command Line Argument:
  ```bash
  customgpt-cli --api-key YOUR_API_KEY list-projects
  ```

  Note: Command line argument takes precedence over environment variable if both are set.





  Create a project:
  ```bash

  export CUSTOMGPT_API_KEY=your_api_key


  customgpt-cli create-project --name "My Test Project With Sitemap" --sitemap "https://adorosario.github.io/small-sitemap.xml" --format id-only


  customgpt-cli create-project --name "My Test Project With File" --file /path/to/file.pdf --format json
  ```

  List projects with filtering:
  ```bash

  customgpt-cli list-projects


  customgpt-cli list-projects --name-filter "test.*project"


  customgpt-cli list-projects --inactive-days 30


  customgpt-cli list-projects --min-queries 100 --max-queries 1000


  customgpt-cli list-projects --format json
  customgpt-cli list-projects --format table
  customgpt-cli list-projects --format id-only
  ```

  Show a project details:
  ```bash
  customgpt-cli show-project --project-id PROJECT_ID --format json
  ```

  Update a project:
  ```bash
  customgpt-cli update-project --project-id PROJECT_ID --name "New Name" --is-shared 1 --format json
  ```

  Delete projects:
  ```bash

  customgpt-cli delete-projects --project-ids PROJECT_ID


  customgpt-cli delete-projects --project-ids "id1,id2,id3"


  customgpt-cli delete-projects --project-ids PROJECT_ID --dry-run


  customgpt-cli delete-projects --project-ids PROJECT_ID --force
  ```



  Create a conversation:
  ```bash
  customgpt-cli create-conversation --project-id PROJECT_ID --name "My Conversation"
  ```

  Send a message:
  ```bash

  customgpt-cli send-message --project-id PROJECT_ID --session-id SESSION_ID --prompt "Hello"


  customgpt-cli send-message --project-id PROJECT_ID --session-id SESSION_ID --prompt "Hello" --stream


  customgpt-cli send-message --project-id PROJECT_ID --session-id SESSION_ID --prompt "Hello" --persona "You are a helpful assistant"
  ```



  Get project pages:
  ```bash
  customgpt-cli get-pages --project-id PROJECT_ID
  ```

  Delete a page:
  ```bash
  customgpt-cli delete-page --project-id PROJECT_ID --page-id PAGE_ID
  ```

  Reindex a page:
  ```bash
  customgpt-cli reindex-page --project-id PROJECT_ID --page-id PAGE_ID
  ```



  Here is an examples of how to use the CLI in scripts:

  1. Export project IDs to a file and process them:
  ```bash

  export CUSTOMGPT_API_KEY=your_api_key


  customgpt-cli list-projects --name-filter "test" --format id-only > projects.txt


  customgpt-cli delete-projects --project-ids $(paste -s -d, projects.txt) --force
  ```



  The CLI supports multiple output formats for better integration with other tools:

  - `table`: Human-readable formatted table (default)
  - `json`: JSON format for parsing
  - `csv`: CSV format for stats data
  - `id-only`: Just the IDs, one per line (good for scripting)



  The CLI includes several safety features:

  - `--dry-run`: Shows what would be deleted without actually deleting
  - Confirmation prompts for destructive operations
  - `--force` flag to skip confirmations in scripts
  - Error handling with informative messages



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



  MIT License


pkgId: 78a8b155ca93234cb8b8f2e91216e5e6af9ec57eb2f3b607d4197ea5d97ec635
name: python-customgpt-client
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: A client library for accessing customgpt
url: https://pypi.org/project/customgpt-client/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customgpt-client-1.2.7-1.src.rpm
checksum_type: sha256
description:
  First, create a client:

  ```python
  from customgpt_client import CustomGPT

  CustomGPT.api_key="SuperSecretToken"
  ```

  Now you can access to all of our Models:
  Example Request will be like this:

  Creating a Project synchronously:

  ```python
  response = CustomGPT.Project.create(project_name='Test', sitemap_path='https://example.com/test.xml', file_data_retension=False, file=file)
  project_id = response.data.id
  ```

  Or do the same thing with an async version:

  ```python
  response = await CustomGPT.Project.acreate(project_name='Test', sitemap_path='https://example.com/test.xml', file_data_retension=False, file=file)
  project_id = response.data.id
  ```


pkgId: 690db8eb8959da7012b01a929c2c59ab098177ed90637f9fb106245aa104aff9
name: python-customidenticon
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Python3 library for generate a variety of identicons
url: https://github.com/lexserest/customidenticon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customidenticon-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ![image](https://user-images.githubusercontent.com/22620605/53684108-2c1c3180-3d1a-11e9-84ca-64547fb6ad51.png)

  Python library for generate a variety of identicons.

  [![image](https://travis-ci.org/LexSerest/customidenticon.svg?branch=master)](https://travis-ci.org/LexSerest/customidenticon)



  - 3 different types of identicons
  - change the final image size (size of elements, number of elements)
  - change border size
  - change background color
  - change the transparency of elements
  - change the output format (PNG, JPEG, etc.)
  - choice of hashing algorithm (including your own)




  `pip install customidenticon`


  End image size = size * block_size + border * 2
  ```python
  import customidenticon
  identicon = customidenticon.create(
      "Test data",            # Data
      type="pixels",          # Type of algorithm (pixels, blocks or layers)
      format="png",           # Output format
      salt="",                # salt for more variants
      background="#f0f0f0",   # background color
      block_visibility=140,   # transparency of elements in the image (0-255)
      block_size=30,          # size of elements (px)
      border=25,              # border (px)
      size=5,                 # number of elements
      hash_func=None          # hash function (auto)
  )

  ```


  ```python
  import customidenticon
  identicon = customidenticon.create("Test data", size=5)



  with open("identicon.png", "wb") as f:
      f.write(identicon)


  import io
  from PIL import Image
  image = Image.open(io.BytesIO(identicon))
  ```


  Use `hashlib` for change algorithm
  ```python
  import hashlib
  import customidenticon
  identicon = customidenticon.create("Test data", hash_func=hashlib.sha3_256)
  ```
  Example custom hash algorithm
  ```python
  import customidenticon
  class MySuperHashAlgorithm:
      def __init__(self, *args):
          pass
      def hexdigest(self):
          return "0"*200

  identicon = customidenticon.create("Test data", hash_func=MySuperHashAlgorithm)
  ```



  ```python
  import customidenticon

  identicon1 = customidenticon.create("Test") # 200x200px (default for all)

  identicon1 = customidenticon.create("Test", type="pixels")



  identicon2 = customidenticon.create("Test", size=6, block_size=25)



  identicon4 = customidenticon.create("Test", type="layers")



  identicon5 = customidenticon.create("Test", type="layers", size=8, block_size=20, border=20)


  identicon6 = customidenticon.create("Test", type="block", block_visibility=100)
  ```



  ![image](https://user-images.githubusercontent.com/22620605/53685533-0c423900-3d2d-11e9-89e0-e3cc7bfa7548.png)


pkgId: c18bc897179ff37e5973be1ca27588258f870e5e96d65b1f7ffb5e2ecbcba039
name: python-customisedLogs
arch: src
version: 1.5.1
epoch: 0
release: 1
url: https://github.com/BhaskarPanja93/customisedLogs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customisedLogs-1.5.1-1.src.rpm
checksum_type: sha256
summary:
  A well maintained program to have coloured logs on the terminal. This would help isolate errors and success messages from each other just by their colours.

description:
  ```pip install customisedlogs --upgrade```




  <br>To install:
  ```
  pip install customisedlogs --upgrade
  pip3 install customisedlogs --upgrade
  python -m pip install customisedlogs --upgrade
  python3 -m pip install customisedlogs --upgrade
  ```



  ```
  from customisedLogs import Manager as LogManager

  logger = LogManager()

  logger.fatal("SERVER", "Unhandled Exception", "Overloaded")
  logger.failed("SERVER", "Unable to connect..")
  logger.success("NETWORK", "Successfully connected", "Bi-directional", "lat: 1ms")
  logger.info("CLIENT", "Port reserved")
  logger.skip("PROGRAM", "Started...")
  ```
  And it would look like:
  ![output-readme.png](https://raw.githubusercontent.com/BhaskarPanja93/customisedLogs/master/output-readme.png?raw=True)



  * Let user change the default RGB values.
  * Add more verbose levels.
  * Customised verbose levels.
  * Skip same log if repeated within a time-frame.
  * Different formats. Compatible to render on HTML or any other stdout method.


pkgId: c312036fa6625d802e167206e792c51f6eb5974c1acc5afc027abd42f41a8c4a
name: python-customisedLogs
arch: src
version: 2.0.1
epoch: 0
release: 1
url: https://github.com/BhaskarPanja93/customisedLogs
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customisedLogs-2.0.1-1.src.rpm
checksum_type: sha256
summary:
  A well maintained package to have coloured logs on the terminal. This would help isolate errors and success messages from each other by their colours.

description:
  ```pip install customisedlogs --upgrade```




  <br>To install:
  ```
  pip install customisedlogs --upgrade
  pip3 install customisedlogs --upgrade
  python -m pip install customisedlogs --upgrade
  python3 -m pip install customisedlogs --upgrade
  ```



  ```
  from customisedLogs import CustomisedLogs
  logger = CustomisedLogs()

  logger.log(logger.Colors.blue, "Blue", "This is", "blue")
  logger.log(logger.Colors.red_100_accent, "Red", "This is", "red-100-accent")
  logger.log(logger.Colors.green_300, "Green", "This is green-300")
  logger.log(logger.Colors.cyan_700, "Cyan", "This is cyan-700")
  logger.log(logger.Colors.green_300, "Green", "This is green-300")
  logger.log(logger.Colors.black, "Black", "This is black")
  logger.log(logger.Colors.white, "White", "This is white")
  ```
  And it would look like:<br>
  ![output-readme.png](https://raw.githubusercontent.com/BhaskarPanja93/customisedLogs/master/output-readme.png?raw=True)

  The package contains all colours combinations from https://davidpiesse.github.io/tailwind-md-colours


  * Let user change the default RGB values.
  * Different formats. Compatible to render on HTML or any other stdout method.


pkgId: c79b61cd2db3ad618d51b24d2dd0048553164c7e4ece2e0e8ee7b9fb84d360bf
name: python-customized-table
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: Creates flexible tables in Jupyter Notebooks with lots of formatting options
url: https://github.com/jhagelback/customized_table
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customized-table-0.1.17-1.src.rpm
checksum_type: sha256
description:
  Creates flexible tables in Jupyter Notebooks with lots of formatting options such as changing font, font color, cell background, number formatting and much more. Tables can also be saved to csv or Excel files, or generated from csv data files.


pkgId: 8ce6df4c46762afb74fa275f21f8679e6d5ab5fd43fb34aaaafbce5e4140d3a1
name: python-customjson
arch: src
version: 2.13.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/ludeeus/customjson
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customjson-2.13.1-1.src.rpm
checksum_type: sha256
description:
  This tool generates the "master" files that are used for the [`custom_updater`][custom_updater] and the [`custom_component_store`][custom_component_store]

  For the [`custom_updater`][custom_updater] it generates and update these jsonfiles:

  - [`custom-cards/information`][custom-cards/information]
  - [`custom-components/information`][custom-components/information]

  For the [`custom_component_store`][custom_component_store] it generates and updates [`ludeeus/data/custom-component-store/V1`][ludeeus/data/custom-component-store/V1]



  **Require Python version 3.5.3+**

  ```bash
  python3 -m pip install -U customjson
  ```



  ```bash
  customjson --token aaabbbccc111222333 --mode component
  ```



  param | alias | description
  -- | -- | --
  `--token` | `-T` | An GitHub `access_token` with `repo` permissions.
  `--push` | `-P` | Push a new `repos.json` file to the information repo.
  `--mode` | `-M` | Must be `card` or `component`.
  `--version` | `-V` | Print the installed version.





  The easiest way to add additional resources is to reuse the json file used by ['custom_updater'][custom_updater] if yo have that.

  **Examples:**

  https://github.com/ludeeus/customjson/blob/f0fd9643a3a5af63c5dc02cd228dfad99796fe3e/customjson/components/custom_updater.py#L7-L16

  But there are other ways if you look in the `/customjson/components/` dir you can see different implementations that give more granular control.



  look in the `/customjson/cards/` dir to see different implementations

  ***

  [![BuyMeCoffee](https://camo.githubusercontent.com/cd005dca0ef55d7725912ec03a936d3a7c8de5b5/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6275792532306d6525323061253230636f666665652d646f6e6174652d79656c6c6f772e737667)](https://www.buymeacoffee.com/ludeeus)


  [custom_updater]: https://github.com/custom-components/custom_updater
  [custom_component_store]: https://github.com/ludeeus/custom-component-store
  [custom-cards/information]: https://github.com/custom-cards/information/blob/master/repos.json
  [custom-components/information]: https://github.com/custom-components/information/blob/master/repos.json
  [ludeeus/data/custom-component-store/V1]: https://github.com/ludeeus/data/blob/master/custom-component-store/V1/data.json


pkgId: 9546ca4eb9be31067a910e88cb68a6af2a8681fc40214893ae833d37416de27e
name: python-customtkinter
arch: src
version: 5.2.2
epoch: 0
release: 1
summary: Create modern looking GUIs with Python
url: https://customtkinter.tomschimansky.com
rpm_license: Creative Commons Zero v1.0 Universal
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customtkinter-5.2.2-1.src.rpm
checksum_type: sha256
description:
  A modern and customizable python UI-library based on Tkinter: https://customtkinter.tomschimansky.com


pkgId: 4067f9f957337d553b4f5ad2419ea8899af6f0bb40b12f74d9ad4c5da51900b4
name: python-customtkinterx
arch: src
version: 0.4.4
epoch: 0
release: 1
summary: extra widgets for customtkinter
url: https://pypi.org/project/customtkinterx/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-customtkinterx-0.4.4-1.src.rpm
checksum_type: sha256
description:
  > 解释器需Python3.7及以上

  `customtkinter`的扩展组件功能库，同时也采集了其他开发者制作的组件，并进行仅类型提示上的修改（源代码`__main__.py`上有标注）


  尚未完善设置，修改了`CTk` `CTkToplevel` `CTkFrame` `CTkButton` `CTKEntry` `CTkComboBox`等类。
  ```python
  from customtkinter import *
  from customtkinterx import *

  CTkFluentTheme()
  ```


  原窗口因标题栏与边框的限制，导致界面效果极差，但是仍可以通过一些方法自定义窗口`wm_overrideredirect`。
  平台支持`Windows` `MacOS` `Linux`，其中界面效果支持最好的是`Windows`，`MacOS` `Linux`无法使用透明色，完全消除边框使用圆角，
  及将图标保留至任务栏，采用置顶的方法保持窗口的显示。


  ```markdown
  | CTkCustom -> CTk
  |-->> __frame_border(mainframe): CTkFrame
  |-->> __frame_title(titlebar): CTkFrame
  |-->> __label_title(titlebar_title): CTkLabel
  |-->> __button_close(titlebar_closebutton): CTkButton
  |-->> __button_minimize(titlebar_minimizebutton): CTkButton
  ```


  ```python
  from customtkinter import *
  from customtkinterx import *

  root = CTkCustom()

  root.mainloop()
  ```


  你可以自定义一个主题，然后加上`CTkCustom`项
  ```json
  {
    ...
      "transparent_color": "#101010", // 为实现圆角边框而设置的透明色

      "closebutton_text_color": ["#000000", "#ffffff"],
      "closebutton_color": ["#f4f6f8", "#212b36"],
      "closebutton_hover_color": ["#b40d1b", "#b40d1b"],

      "minimizebutton_text_color": ["#000000", "#ffffff"],
      "minimizebutton_color": ["#f4f6f8", "#212b36"],
      "minimizebutton_hover_color": ["#dfe3e8", "#454f5b"]
    },
    ...
  }
  ```


  ```python
  CTKCustom.create_sizegrip()
  ```
  自定义手柄，将会使用库`pyautogui`。
  ```bash
  python -m pip install pyautogui
  ```
  ```python
  CTKCustom.create_sizegrip(True)
  ```

  ```python
  from customtkinter import *
  from customtkinterx import *

  root = CTkCustom()
  root.create_sizegrip()

  root.mainloop()
  ```

  ```python
  from customtkinter import *
  from customtkinterx import *

  root = CTkCustom()
  root.create_sizegrip(True)

  root.mainloop()
  ```



  ```markdown
  | CTkInforBar -> CTkFrame
  |-->> __label_title(title): CTkLabel
  |-->> __label_info(info): CTkLabel
  |-->> __button_close(close): CTkButton
  ```


  ```python
  from customtkinter import *
  from customtkinterx import *

  root = CTk()

  infobar = CTkInfoBar()
  infobar.show()

  root.mainloop()
  ```


  你可以自定义一个主题，然后加上`CTkInfoBar`项
  ```json
  {
    ...
    "CTkInfoBar": {
      "corner_radius": 8,
      "border_width": 0,

      "fg_color": ["#61f3f3", "#006c9c"],
      "fg_hover_color": ["#cafdf5", "#003768"], // 关闭按钮被鼠标捕捉时的颜色

      "border_color": ["#b0b2b2", "#424556"],

      "success_color": ["#86e8ab", "#1b806a"],  // 取自配色severity中NORMAL值
      "success_hover_color": ["#d8fbde", "#0a5554"],  // 取自配色severity中被鼠标捕捉时的NORMAL值
      "caution_color": ["#ffd666", "#b76e00"],  // 取自配色severity中CAUTION值
      "caution_hover_color": ["#fff5cc", "#7a4100"],  // 取自配色severity中被鼠标捕捉时的CAUTION值
      "critical_color": ["#ffac82", "#b71d18"],  // 取自配色severity中CRITICAL值
      "critical_hover_color": ["#ffe9d5", "#7a0916"]  // 取自配色severity中被鼠标捕捉时的CAUTION值

    },
    ...
  }
  ```


pkgId: f59f5b3462a78f57bec4ecfd331cacffc3c4a9868fd53639f304885666d7c810
name: python-cut-cross-entropy
arch: src
version: 24.11.4
epoch: 0
release: 1
summary: Code for cut cross entropy, a memory efficient implementation of linear-cross-entropy loss.
url: https://pypi.org/project/cut-cross-entropy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cut-cross-entropy-24.11.4-1.src.rpm
checksum_type: sha256
description:
  This software project accompanies the research paper:
  **[Cut Your Losses in Large-Vocabulary Language Models](https://arxiv.org/abs/2411.09009)**,
  *Erik Wijmans, Brody Huval, Alexander Hertzberg, Vladlen Koltun, and Philipp Krähenbühl*.

  ![](assets/cce_figure.png)

  As language models grow ever larger, so do their vocabularies. This has shifted the memory footprint of LLMs during training disproportionately to one single layer: the cross-entropy in the loss computation. Cross-entropy builds up a logit matrix with entries for each pair of input tokens and vocabulary items and, for small models, consumes an order of magnitude more memory than the rest of the LLM combined. We propose Cut Cross-Entropy (CCE), a method that computes the cross-entropy loss without materializing the logits for all tokens into global memory. Rather, CCE only computes the logit for the correct token and evaluates the log-sum-exp over all logits on the fly. We implement a custom kernel that performs the matrix multiplications and the log-sum-exp reduction over the vocabulary in flash memory, making global memory consumption for the cross-entropy computation negligible. This has a dramatic effect. Taking the Gemma 2 (2B) model as an example, CCE reduces the memory footprint of the loss computation from 24 GB to 1 MB, and the total training-time memory consumption of the classifier head from 28 GB to 1 GB. To improve the throughput of CCE, we leverage the inherent sparsity of softmax and propose to skip elements of the gradient computation that have a negligible (i.e., below numerical precision) contribution to the gradient. Experiments demonstrate that the dramatic reduction in memory consumption is accomplished without sacrificing training speed or convergence.



  **Requirements**

  1. Python 3.10+
  2. PyTorch 2.4+
  3. Triton 3.0+
  4. Ampere (or newer) GPU


  **Note:**  For operating systems that are not supported by Triton (e.g., MacOS), we include a highly optimized version of
  linear-cross-entropy using `torch.compile`. This implementation will be set to the default on MacOS.



  **Installation**
  ```bash
  pip install "cut-cross-entropy @ git+https://github.com/apple/ml-cross-entropy.git"
  ```

  **Usage**

  ```python
  from cut_cross_entropy import linear_cross_entropy

  embeddings = model.compute_embedding(inputs)
  classifier = model.get_classifier_weights()

  loss = linear_cross_entropy(embeddings, classifier, labels)
  ```

  In causal language modeling, it is common that the model embeddings and labels need to be shifted
  such that the model predicts the next token.

  ```python
  from cut_cross_entropy import linear_cross_entropy

  embeddings = model.compute_embedding(inputs)
  classifier = model.get_classifier_weights()

  shift_embeddings = embeddings[..., :-1, :].flatten(0, -2)
  shift_labels = labels[..., 1:]

  manual_shift_loss = linear_cross_entropy(shift_embeddings, classifier, shift_labels)
  ```

  Instead, pass `shift=True` to perform this computation without allocating the shift_embeddings matrix.
  ```python
  from cut_cross_entropy import linear_cross_entropy

  embeddings = model.compute_embedding(inputs)
  classifier = model.get_classifier_weights()


  auto_shift_loss = linear_cross_entropy(embeddings, classifier, labels, shift=True)
  ```

  We also provide a highly optimized implementation of linear-cross-entropy loss using `torch.compile`.
  This is a good option
  for scenarios where speed is the primary goal and the model has a relatively small vocabulary compared to its
  hidden dimension (when |V| >> D, `cce` will both save memory _and_ be faster).
  This option also works on the CPU and older GPUs, making it useful for testing.

  ```python
  from cut_cross_entropy import linear_cross_entropy

  embeddings = model.compute_embedding(inputs)
  classifier = model.get_classifier_weights()

  loss = linear_cross_entropy(embeddings, classifier, labels, ..., impl="torch_compile")
  ```



  **Installation**

  Install cut-cross-entropy with transformers dependencies
  ```bash
  pip install "cut-cross-entropy[transformers] @ git+https://github.com/apple/ml-cross-entropy.git"
  ```

  **Usage**

  If you are using transformers, you can patch transformers to use CCE directly. Note that
  logits will no longer be returned (`None` will be returned instead).
  ```python
  from cut_cross_entropy.transformers import cce_patch

  cce_patch("llama")



  model = ...
  model = cce_patch(model)
  ```

  We currently support the Llama, Phi3, Mistral, and Gemma2 families of models.

  `cce_patch` takes two options. The first is the linear-cross-entropy implementation to use. Currently `"cce"` or `"torch_compile"`.

  The second
  is the loss reduction. We support `"mean"`, `"sum"`, and `"none"`, that mirror their PyTorch counterpart.
  `"mean"` is the default and what the transformers trainer API expects.
  However,
  `"none"` in particular can enable for efficient computation of quantities based on the loss.

  For example, the following efficiently computes the perplexity of a batch of sequences:
  ```python
  import transformers

  from cut_cross_entropy.transformers import cce_patch


  model = transformers.AutoModelForCausalLM.from_pretrained(...)

  model = cce_patch(model, reduction="none")

  labels = input_ids.clone()
  labels[~attention_mask] = -100 # -100 is the ignore index for PyTorch and CCE.

  outputs = model(input_ids, attention_mask, labels=labels)

  loss = outputs[0] # A (B, T - 1) tensor because reduction="none". T - 1 because the first input token has


  ppl = torch.exp(
      
      loss.sum(1) / (labels[:, 1:] != -100).count_nonzero(dim=1)
  ).mean()  # Average perplexity over the batch
  ```





  We provide a training in `training/train.py`.

  **Installation**
  ```bash
  pip install "cut-cross-entropy[all] @ git+https://github.com/apple/ml-cross-entropy.git"
  ```

  **Training**

  Use `scripts/train.sh` to train a full model.

  **Benchmarking**

  The benchmark script can be run via `python -m benchmark`.

  Expected output with A100 SMX4, PyTorch 2.4.1, and CUDA 12.4.

  ```
            method        kind  runtime_ms  op_mem_mb test_data
  0            cce     loss-fw        46.4        1.1    gemma2
  1  torch_compile     loss-fw        49.9     4000.1    gemma2
  2       baseline     loss-fw        81.9    24000.0    gemma2
  3            cce     loss-bw        89.3     1163.0    gemma2
  4  torch_compile     loss-bw        92.3    12000.0    gemma2
  5       baseline     loss-bw       122.4    16000.0    gemma2
  6            cce  loss-fw-bw       134.8     1164.0    gemma2
  7  torch_compile  loss-fw-bw       144.0    16000.1    gemma2
  8       baseline  loss-fw-bw       208.8    28000.0    gemma2
  ```



  If dependencies are installed locally, `cut-cross-entropy` will work without a pip install as long as `python` is executed in the root path of the github repo.

  To install directly from the github repo, either use an (editable) install or manipulate PYTHONPATH, e.g.

  ```bash
  pip install -e ".[dev]"


  pip install ".[dev]"


  export PYTHONPATH=/path/to/ml-cross-entropy:${PYTHONPATH}
  ```



  ```
  @article{wijmans2024cut,
    author       = {Erik Wijmans and
                    Brody Huval and
                    Alexander Hertzberg and
                    Vladlen Koltun and
                    Philipp Kr\"ahenb\"uhl},
    title        = {Cut Your Losses in Large-Vocabulary Language Models},
    journal      = {arXiv},
    year         = {2024},
    url          = {https://arxiv.org/abs/2411.09009},
  }
  ```



  This sample code is released under the [LICENSE](LICENSE) terms.



  Our codebase is built using multiple opensource contributions, please see [Acknowledgements](ACKNOWLEDGEMENTS.md) for more details.

  Please check the paper for a complete list of references and datasets used in this work.


pkgId: 11428773a3fc2dc6e6daf2f044f9580b8d3bb025286ab6e797f7c4f3b09db257
name: python-cut-detector
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Automatic Cut Detector
url: https://github.com/15bonte/cut-detector
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cut-detector-1.4.0-1.src.rpm
checksum_type: sha256
description:
  This [napari] plugin was generated with [Cookiecutter] using [@napari]'s [cookiecutter-napari-plugin] template.
  <!--
  Don't miss the full getting started guide to set up your new package:
  https://github.com/napari/cookiecutter-napari-plugin#getting-started
  and review the napari docs for plugin developers:
  https://napari.org/stable/plugins/index.html
  -->
  <video width="640" height="480" controls>
    <source src="https://github.com/15bonte/cut-detector-models/blob/main/demo.mp4" type="video/mp4">
    Your browser does not support the video tag.
  </video>


  It is highly recommended to create a dedicated conda environment, by following these few steps:
  1. Install an [Anaconda] distribution of Python. Note you might need to use an anaconda prompt if you did not add anaconda to the path.
  2. Open an Anaconda prompt as admin to create a new environment using [conda]. We advice to use python 3.10 and conda 23.10.0, to get conda-libmamba-solver as default solver.
  ```
  conda create --name cut_detector python=3.10 conda=23.10.0
  conda activate cut_detector
  ```

  Once in a dedicated environment, our package can be installed via [pip]:
  ```
  pip install cut_detector
  ```
  Alternatively, you can clone the github repo to access to playground scripts.
  ```
  git clone https://github.com/15bonte/cut-detector.git
  cd cut-detector
  pip install -e .
  ```

  We highly recommend to use GPU to speed up segmentation. To use your NVIDIA GPU, the first step is to download the dedicated driver from [NVIDIA].
  Next we need to remove the CPU version of torch:
  ```
  pip uninstall torch
  ```
  The GPU version of torch to be installed can be found [here](https://pytorch.org/get-started/locally/). You may choose the CUDA version supported by your GPU, and install it with conda. This package has been developed with the version 11.6, installed with this command:
  ```
  conda install pytorch==1.12.1 torchvision pytorch-cuda=11.6 -c pytorch -c nvidia
  ```

  To update cut-detector to the latest version, open an Anaconda prompt and use the following commands:
  ```
  conda activate cut_detector
  pip install cut-detector --upgrade
  ```

  Each detected cell division is labeled with one of the following categories:
  - NORMAL: Division happening as expected, where (at least) 1 micro-tubule cut is detected.
  - NO_MID_BODY_DETECTED: Along the cell division, no mid-body was detected on the MKLP1 channel. This category encompasses different cases: the detection may have failed, the mid-body may not express the fluorescence, or this may not actually be a division.
  - MORE_THAN_TWO_DAUGHTER_TRACKS: Tripolar division. This category encompasses both actual tripolar divisions and wrong identifications of daughter cells (mainly caused by segmentation issues).
  - NEAR_BORDER: Division close to the border of the image, hence ignored as it is likely to be difficult to detect micro-tubule cuts. A division is classified as NEAR_BORDER as soon as the distance between 1 detected mid-body and the border of the image is less than 20px.
  - NO_CUT_DETECTED: Division whose mid-body was detected, but with all micro-tubule bridges classified as "No cut". Likely to be at the end of the video, cells dying before the end of division, or cells going out of frame.
  - TOO_SHORT_CUT: First micro-tubule cut detected before or at 50 minutes. Ignored as this is very unlikely, so it is probably caused by a wrong division detection.

  Contributions are very welcome. Tests can be run with [tox], please ensure
  the coverage at least stays the same before you submit a pull request.

  Distributed under the terms of the [BSD-3] license,
  "cut-detector" is free and open source software

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
  [file an issue]: https://github.com/15bonte/cut-detector/issues
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/
  [Anaconda]: https://www.anaconda.com/products/distribution
  [Fiji]: https://imagej.net/software/fiji/
  [NVIDIA]: https://www.nvidia.com/Download/index.aspx?lang=en-us
  [conda]: https://docs.conda.io/en/latest/


pkgId: 4e4641ce32bdbb2225522d27d7ffaa06463cc05add39531c5587fb40f698b922
name: python-cute-shm
arch: src
version: 1.2
epoch: 0
release: 1
summary: managing np arrays stored in the shared memory
url: https://github.com/MPI-IS/cute-shm
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cute-shm-1.2-1.src.rpm
checksum_type: sha256
description:
  [![Python package](https://github.com/MPI-IS/cute-shm/actions/workflows/tests.yml/badge.svg)](https://github.com/MPI-IS/cute-shm/actions/workflows/tests.yml)
  [![PyPI version](https://img.shields.io/pypi/v/cute-shm.svg)](https://pypi.org/project/cute-shm/)




  cute-shm is a convenience wrapper over Python's multiprocessing shared memory. It provides an easy-to-use API for managing shared memory numpy arrays and HDF5 files.
  Using the shared memory allows to share numpy arrays across multiple processes running on the same node.



    - [Requirements](#requirements)
    - [Installation](#installation)
    - [Usage](#usage)
      - [API](#api)
        - [sharing numpy arrays](#sharing-numpy-arrays)
        - [sharing content of hdf5 files](#sharing-content-of-hdf5-files)
        - [Logging](#logging)
        - [Typing hints](#typing-hints)
        - [Concurrent access](#concurrent-access)
      - [Under the hood](#under-the-hood)
      - [Command line executables](#command-line-executables)
      - ["Manual" cleaning of the shared memory](#manual-cleaning-of-the-shared-memory)
    - [Demos](#demos)
    - [Warnings](#warnings)
      - [Bus error](#bus-error)
      - [Garbage collection of the shared memory](#garbage-collection-of-the-shared-memory)
    - [Authorship, Copyright, and License](#authorship-copyright-and-license)




  Python 3.10 or later.



  You can install cute-shm using pip:

  ```
  pip install cute-shm
  ```







  ```python
  import numpy as np
  import cute_shm as cute


  a = np.array([[12, 0, 0], [0, 10, 0], [0, 0, 0]], dtype=np.int64)
  b1 = np.zeros(100, dtype=np.float32)
  b2 = np.zeros(300, dtype=np.float32)


  arrays = {"a": a, "b": {"b1": b1, "b2": b2}}


  project_name = "myproject"



  persistent = False



  overwrite = False # set to True if the shared memory should be overwritten if it already exists


  cute.arrays_to_shm(
      project_name,
      arrays,
      persistent=persistent,
      overwrite=overwrite,
  )




  shm_arrays = cute.shm_to_arrays(project_name, persistent=persistent)





  a: np.ndarray = shm_arrays["a"]["data"]





  a_meta: cute.SharedArrayMeta = shm_arrays["a"]["meta"]
  a_meta["shape"] # the shape of the array, same as a.shape
  a_meta["dtype"] # the data type of the array, same as str(a.dtype)
  a_meta["shm_name"] # the name of the shared memory segment
  a_meta["shm_private_name"] # the private name of the shared memory segment
  a_meta["shm"] # the shared memory segment (instance of shared_memory.SharedMemory)



  cute.unlink(project_name)
  ```
  You can also use the `unlinked_arrays_to_shm` context manager to
  ensure the shared memory and related metadata are cleaned up on exit.

  (if persistent is False, the python multiprocessing resource tracker will cleanup
  the shared memory automatically, but not the meta data).

  ```python


  with cute.unlinked_arrays_to_shm(project_name, arrays):

      
      
      shm_arrays = cute.shm_to_arrays(project_name)


  ```



  Content of hdf5 files can also be transferred to shared memory as a dictionary of numpy arrays.

  ```python
  from pathlib import Path
  import cute_shm as cute

  hdf5_path = Path("path/to/your/file.hdf5")

  project_name = "myproject"



  progress = True

  persistent = False
  overwrite = False


  hdf5_to_shm(
      hdf5_path, project_name, progress=progress, persistent=persistent, overwrite=overwrite
  )


  shm_arrays = cute.shm_to_arrays(project_name, persistent=persistent)


  a: np.ndarray = shm_arrays["a"]["data"]
  a_meta: cute.SharedArrayMeta = shm_arrays["a"]["meta"]
  a_meta["attrs"] # the attributes of the dataset

  ```

  A context manager is also provided:

  ```python
  with unlinked_hdf5_to_shm(
      hdf5_path, project_name, progress, overwrite
  ):
      shm_arrays = cute.shm_to_arrays(project_name, persistent=persistent)
  ```



  If in your own software using the cute-sh API you set the logging to level `DEBUG`, information related to
  the creation/deletion of shared memory segments will be provided.



  cute-shm provides and uses these type aliases:

  ```python


  ArrayDict: TypeAlias = dict[str, Union["ArrayDict", np.ndarray]]


  arrays: cute_shm.ArrayDict = {"a": np.zeros(10), "b": {"b1": np.zeros(10), "b2": np.zeros(10)}}
  cute_shm.arrays_to_shm("myproject", arrays)


  class SharedArray(TypedDict):
      meta: SharedArrayMeta
      data: np.ndarray


  class SharedArrayMeta(TypedDict, total=False):
      shm_name: str
      shm_private_name: str
      shm: shared_memory.SharedMemory
      shape: tuple[int, ...]
      dtype: str
      attrs: dict[str, Any]




  SharedArrayDict: TypeAlias = dict[str, Union[SharedArray, "SharedArrayDict"]]


  shm_arrays: cute_shm.SharedArrayDict = cute_shm.shm_to_arrays("myproject")
  a: cute_shm.SharedArray = shm_arrays["a"]
  a_data: np.ndarray = a["data"]
  a_meta: cute_shm.SharedArrayMeta = a["meta"]
  ```


  Once numpy arrays are transferred to the shared memory and no longer updated,
  they can be accessed by multiple processes concurrently without lock protection.

  If a process updates the values of the arrays, locking should be implemented using
  either the [`multiprocessing.Lock`](https://docs.python.org/3/library/multiprocessing.html#synchronization-between-processes)
  or a [`filelock`](https://py-filelock.readthedocs.io/en/latest/).

  See for example the `demo_server.py`  and the `demo_client.py` demos [here](demos/).



  - when the arrays are transferred to shared memory, a toml file is created in the `/tmp/cute-shm` directory. Its name is based on the project name.
  - this toml file contains all the metadata required for other processes to "cast" the shared memory to the proper dictionary structure.

  If you prefer to store the metadata in a different location, change the `root` attribute of the class `Project2Toml`:

  ```python
  import cute_shm as cute

  cute.Project2Toml.root = Path("/path/to/your/directory")
  ```



  To load the content of a hdf5 file to the shared memory via command line:

  ```bash
  cute-shm-hdf5 <project_name> <hdf5_path>
  ```
  for example:

  ```bash


  cute-shm-hdf5 myproject file.hdf5



  cute-shm-hdf5 myproject file.hdf5 -o


  cute-shm-hdf5 myproject file.hdf5 -no-progress



  cute-shm-hdf5 myproject file.hdf5 -v



  ```

  You can display about data hosted in the shared memory:

  ```bash

  cute-shm-list


  cute-shm-list -s
  ```

  Note that `cute-shm-list` will not only display the content of the shared memory created via `cute-shm-hdf5`, but also the content of
  the shared memory created via the python API (shared memory currently being transferred will not be listed).

  Shared memory can be cleaned up via the command `cute-shm-unlink <project_name>`:

  ```bash
  cute-shm-unlink myproject
  ```


  Alternatively to use the API or the command line to free the shared memory, you may either:

  - reboot the computer
  - delete files prefixed by `cute-shm` in the `/dev/shm` folder and related toml files in the `/tmp/cute-shm` folder.



  For examples: [demos](demos/).





  If the RAM of the computer gets full, transfer to the shared memory will not only fail, the process will also crash with a bus error.
  This is a system error that cannot be managed by the python exception handling.

  It has also been observed that the process becomes stuck when the RAM limit is exceeded.



  Shared memory numpy arrays buffers is a pointer to the buffer of a related instance of `shared_memory.SharedMemory`.
  This related instance needs to be loaded in the heap, i.e. it should not be garbage collected. If it is garbage collected,
  then a `SegmentationFault` will occur and the process will crash (not managed by python exception handling).

  The instance of the `shared_memory.SharedMemory` is located in the `meta` dictionary of the `SharedArrayMeta` instance.

  For example, one should not:

  ```python

  shm_arrays: cute_shm.SharedArrayDict = cute_shm.shm_to_arrays(project_name)


  shm_array = shm_arrays["a"]


  data: np.ndarray = shm_array["data"]


  meta: cute_shm.SharedArrayMeta = shm_array["meta"]



  del meta["shm"]


  print(data[0])
  ```

  or:

  ```python
  def get_np(project_name: str)->np.ndarray:

      
      shm_arrays: cute_shm.SharedArrayDict = cute_shm.shm_to_arrays(project_name)

      
      shm_array = shm_arrays["a"]
      data: np.ndarray = shm_array["data"]
      meta: cute_shm.SharedArrayMeta = shm_array["meta"]

      
      
      
      return data

  a: np.ndarray = get_np("myproject")

  print(a[0])
  ```

  > **Note:** When the shared memory instance is garbage collected:
  > - The data is not removed from the shared memory.
  > - Only the pointer to the data buffer is lost.
  > - This loss of pointer affects only the current process.



  **Author:** Vincent Berenz
  **Institution:** Max Planck Institute for Intelligent Systems, Tübingen, Germany
  **Copyright:** © 2024 Max Planck Gesellschaft
  **License:** [MIT License](https://opensource.org/licenses/MIT)


pkgId: edcb2838df422b8b793b773930190f2e8a127016c1816b069fe98cad047572cc
name: python-cutevariant
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: GUI to visualize and process variant data
url: https://github.com/labsquare/cutevariant
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cutevariant-0.4.5-1.src.rpm
checksum_type: sha256
description:
  **A standalone and free application to explore genetics variations from VCF file**

  Published in [Bioinformatics Advanced](https://academic.oup.com/bioinformaticsadvances/article/2/1/vbab028/6440032?login=true)
  Documentation available on [cutevariant.labsquare.org](https://cutevariant.labsquare.org/)

  [![Test](https://github.com/labsquare/cutevariant/actions/workflows/test.workflows.yml/badge.svg)](https://github.com/labsquare/cutevariant/actions/workflows/test.workflows.yml) [![codecov](https://codecov.io/gh/labsquare/cutevariant/branch/devel/graph/badge.svg?token=p5CNtiNIfD)](https://codecov.io/gh/labsquare/cutevariant)

  Cutevariant is a cross-plateform application dedicated to maniupulate and filter variation from annotated VCF file.
  When you create a project, data are imported into an sqlite database that cutevariant queries according your needs.
  Presently, SnpEff and VEP annotations are supported.
  Once your project is created, you can query variant using different gui controller or directly using the VQL language. This Domain Specific Language is specially designed for cutevariant and try to keep the same syntax than SQL for an easy use.

  ![](https://raw.githubusercontent.com/labsquare/cutevariant/master/screencast.gif)



  | | | |
  |:-------------------------:|:-------------------------:|:-------------------------:|
  |<img width="1604" alt="screen shot 2017-08-07 at 12 18 15 pm" src="https://raw.githubusercontent.com/labsquare/cutevariant/master/screenshot1.png"> |<img width="1604" alt="screen shot 2017-08-07 at 12 18 15 pm" src="https://raw.githubusercontent.com/labsquare/cutevariant/master/screenshot2.png">|<img width="1604" alt="screen shot 2017-08-07 at 12 18 15 pm" src="https://raw.githubusercontent.com/labsquare/cutevariant/master/screenshot4.png">|





  Standalone binary are available for windows:
  - [Download cutevariant 32 bit](https://github.com/labsquare/cutevariant/releases/latest/download/cutevariant-standalone-x86.zip)
  - [Download cutevariant 64 bit](https://github.com/labsquare/cutevariant/releases/latest/download/cutevariant-standalone-x64.zip)



  If you run Linux, then you can either use PyPI or install from source.
  But before you proceed to installation, make sure that running this command:
  ```bash
  sqlite3 --version
  ```
  returns at least `3.32`.
  If not, run:

  ```bash

  sudo apt remove sqlite3

  wget https://www.sqlite.org/2022/sqlite-autoconf-3380500.tar.gz

  tar -xvf sqlite-autoconf-3380500.tar.gz
  cd sqlite-autoconf-3380500
  ./configure

  make

  sudo make install

  echo "export LD_LIBRARY_PATH=/usr/local/lib" >> ~/.zshrc

  source ~/.zshrc

  sqlite3 --version


  ```


  Cutevariant is avaible from [Pypi](https://pypi.org/project/cutevariant/) :

      pip install cutevariant # install
      python -m cutevariant   # run


  - Python 3.7 or newer is required

  ```bash

  git clone https://github.com/labsquare/cutevariant.git
  cd cutevariant

  python3 -m virtualenv venv
  source venv/bin/activate

  python -m pip install -e

  python -m cutevariant # or `make run`

  python -m pytest tests
  ```


  You can follow this tutorial to familiarize yourself with cutevarant.
  https://github.com/labsquare/cutevariant/wiki/Usage-examples

  The VQL langage specification is available here :
  https://github.com/labsquare/cutevariant/wiki/VQL-language


  Cutevariant is a new project and all contributors are welcome

  If you found a bug or have a feature request, you can report it from the [Github isse trackers](https://github.com/labsquare/cutevariant/issues).


  Documentation to create a plugin is [available here](https://github.com/labsquare/cutevariant/wiki/Plugins)


  You can join us [on discord](https://discord.gg/7sSH4VSPKK). We are speaking french right now, but we can switch to english.


  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/gpl-3.0.txt.


pkgId: 80ecbd5bd44026446cbde3447be14b9927148f2cd44ff396d66a0b9f8c1891da
name: python-cutex
arch: src
version: 0.3.9
epoch: 0
release: 1
summary: PyCUDA based PyTorch Extension Made Easy
url: https://github.com/tjyuyao/cutex
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cutex-0.3.9-1.src.rpm
checksum_type: sha256
description:
  In a word, `cutex` bridges PyCUDA's just-in-time compilation with PyTorch's Tensor type.
  ``cutex.SourceModule`` extends pycuda's ``SourceModule`` in following ways:
  - Designed to work seemlessly with pytorch `Tensor` type, Data-Distributed Parallel (DDP), and `autograd.Function` API.
  - Support efficient **multi-dimensional `torch.Tensor` access with (efficient & optional) out-of-boundary check**.
  - Enhanced automatic type conversion and error messages.
  ``cutex.SourceModule`` works differently compared to [PyTorch's official cuda extension guide](https://pytorch.org/tutorials/advanced/cpp_extension.html) in following ways:
  - **It compiles lightning fast!** Especially suitable for rapidly developing your favorite new algorithm.
  - Without boilerplate cpp wrappers, **every user code goes within one python file**.
  - It use raw CUDA syntax so that PyTorch's c++ API is _not_ available, it is recommended to use either raw CUDA with cutex or python API with pytorch.

  This is a new high level API for writing custom kernels since v0.3.0. You omit the signature of the kernel function and `cutex.inline()` will compile and run it according to the context on the cuda device. This facillitates a fluent switching between pytorch and pycuda.
  ```py
  import cutex
  import torch
  from torch import Tensor
  def matmul(A:Tensor, B:Tensor):
      M, J = A.size()
      K, N = B.size()
      assert J == K
      gridDim = (cutex.ceildiv(N, 16), cutex.ceildiv(M, 16), 1)
      blockDim = (16, 16, 1)
      C = torch.empty((M, N), dtype=A.dtype, device=A.device)
      cutex.inline("""
      int m = blockIdx.y * blockDim.y + threadIdx.y;
      int n = blockIdx.x * blockDim.x + threadIdx.x;
      float v = 0.f;
      if (m >= M || n >= N) return;
      for (int k = 0; k < K; ++k) {
          v += A[m][k] * B[k][n];
      }
      C[m][n] = v;
      """, boundscheck=False)  # all local vars are captured into the kernel except for those with unknown types.
      return C
  def test():
      M, N, K = 4, 4, 1
      A = torch.rand((M, K), dtype=torch.float32).cuda()
      B = torch.rand((K, N), dtype=torch.float32).cuda()
      torch.testing.assert_close(matmul(A, B), torch.mm(A, B))
      print(matmul(A, B))
  test()
  ```
  Local variables of Tensor and common scalar types (`int`, `float`, etc.) and special ones `gridDim` and `blockDim` are captured into the inline execution, as if they were in the same scope. The order of defining them does not matter, only have to be assigned before the inline execution.
  Multiple inline execution in the same python function is legal. When doing so, make `gridDim` and `blockDim` update their value before the next execution.
  The tensors can be acccessed element-wise using multi-dimensional squared brackets `[]` as illustrated in the above example. It can be read and write, and the modifications would reflected directly to the pytorch tensor on cuda devices. By default, with the `boundscheck` option on, these brackets will check for out of bound error. While this is very useful for debugging novel algorithms, it will make use of more registers in the SM, so if you want to make full use of the SM register resources, e.g. using maximum block threads, you need to turn boundscheck off for best performance.
  Unless explicitly specified, the `float` type in the CUDA part will be automatically replaced to the same type as the first local Tensor variable with float dtype, in the above example, it would be aligned with `A`.

  The following example demonstrates a vanilla matrix multiplication implementation for pytorch tensor but written in pure cuda.
  As you may happily notice, pytorch is responsible for allocation of new Tensors instead of in the cuda code, and the elements of tensors can be read and modified inside the kernel function.
  ```python
  import torch
  import cutex
  M, N, K = 4, 4, 1
  a = torch.rand((M, K), dtype=torch.float32).cuda()
  b = torch.rand((K, N), dtype=torch.float32).cuda()
  c = torch.empty((M, N), dtype=torch.float32).cuda()
  kernels = cutex.SourceModule("""
  //cuda
  __global__ void matmul(Tensor<float, 2> a, Tensor<float, 2> b, Tensor<float, 2> c, int M, int N, int K) {
      int m = blockIdx.y * blockDim.y + threadIdx.y;
      int n = blockIdx.x * blockDim.x + threadIdx.x;
      float v = 0.f;
      if (m >= M || n >= N) return; // you can also write `a.size(0)` instead of `M`, `b.size(1)` instead of `N`
      for (int k = 0; k < K; ++k) { // you can also write `a.size(1)` instead of `K`
          v += a[m][k] * b[k][n]; // you can access tensor elements just like operating a multi-level array, with optional out-of-bound check.
      }
      c[m][n] = v; // the modification will be reflected in the torch tensor in place, no redundant data copying.
  }
  //!cuda
  """,
      float_bits=32,  # change to 16 to use half precision as `float` type in the above source code.
      boundscheck=True, # turning on for debug and off for performance (to use full threads of a block), default is on.
      )
  kernels.matmul(  # automatically discover the kernel function by its name (e.g. 'matmul'), just like a normal python module.
      a, b, c, M, N, K,  # directly pass tensors and scalars as arguments
      grid=(N // 16 + 1, M // 16 + 1),  # grid size (number of blocks to be executed)
      block=(16, 16, 1),  # block size (number of threads in each block)
  )
  assert torch.allclose(c, torch.mm(a, b))
  ```

  ```bash
  pip install -U cutex --index-url "https://pypi.org/simple/"
  ```
  **Note:**
  - You should install pytorch and nvcc manually, which are not automatically managed dependencies.
  - The `//cuda` and `//!cuda` comments are not mandatory, it works together with the VSCode [extension](https://marketplace.visualstudio.com/items?itemName=huangyuyao.pycuda-highlighter) for highlighting CUDA source in python docstring.

  ```


  v0.3.8+HEAD - add boundscheck option to inline execution
  v0.3.7+e48537 - bugfix: passing python float to a kernel that accept a __half type now works.
  v0.3.6+4e9b41 - bugfix: v0.3.5 uses regex to replace bool, this may be confused with Tensor with bool dtype, this version revert v0.3.5 and use the wrapper to convert scalar type.
  v0.3.5+8bdfbc - bugfix: bool scalar type automatically converted into int32_t.
  v0.3.4+07b6af - bugfix: error report in jupyter cell.
  v0.3.3+0dc015 - bugfix: error report should find in the whole file.
  v0.3.2+bc47ee - enhanced the error report, accurate lineno in the python file; ensure gridDim and blockDim to be integers.
  v0.3.1+b46561 - automatically send tensor to cuda in inline execution; scalars are const;
  v0.3.0+b93dc6 - !NEW FEATURE! inline execution of CUDA code
  v0.2.2+025fb1 - multiple enhancements.
      - [CUDA] fatal bug fixed checking OOB in `Tensor<Any,1>.size(dim:int)->int` function;
      - !NEW FEATURE! add `ceildiv(int, int)->int` API as a util function.
  v0.2.1+dc4373 - [CUDA] add `Tensor.size(dim:int)->int` API.
  v0.2.0+03c3c5 - [CUDA] !NEW FEATURE! declare Tensor type argument instead of its pointer.
  v0.1.1+d088de - core features
      - basic automatic cuda context management;
      - basic automatic tensor type argument via `pycuda.driver.PointerHolderBase`;
      - basic out-of-boundary check;
      - easy to use `SourceModule` API.
  ```


pkgId: 08fe5e4a66617ac462fdf282c8f014ddfe02aef213b373d154256faf9e34be59
name: python-cutil
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: A collection of useful functions
url: https://github.com/xtream1101/cutil
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cutil-3.0.3-1.src.rpm
checksum_type: sha256
description:
  This is what I call block printing. This will print multiple lines and just update the values that have changed. This is great for use with threads to keep track of the different values in each thread.
  This one requires a little bit of setup:
  ```python


  block_msg = {'title': ['Block print by Eddy - ', ''],
               'val_a': ['Value A', ''],
               'val_b': ['Value B', ''],
               }

  block_print_order = ['title', 'val_b', 'val_a']

  cutil.enable_bprint(block_msg, block_print_order)
  ```
  Then to use, all you need to do is:
  ```python
  cutil.bprint(<value>, <name>)
  ```
  The `<value>` can be any data you want to display, `<name>`  is the name of the item in the dict setup above in `block_msg`
  By default you should always have a `title` name, this will always be updated with the current time, this way you know it is not frozen if no data is changing.


pkgId: da5d15da391eb340cf841e091f618c0fc592c3fd471f4bf919c30a50481b8068
name: python-cutplace
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: validate data stored in CSV, PRN, ODS or Excel files
url: https://github.com/roskakori/cutplace
rpm_license: LGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cutplace-0.9.1-1.src.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/cutplace
      :target: https://pypi.org/project/cutplace/
      :alt: PyPI

  .. image:: https://readthedocs.org/projects/cutplace/badge/?version=latest
      :target: https://cutplace.readthedocs.io/
      :alt: Documentation

  .. image:: https://github.com/roskakori/cutplace/actions/workflows/build.yaml/badge.svg
      :target: https://travis-ci.org/roskakori/cutplace
      :alt: Build Status

  .. image:: https://coveralls.io/repos/roskakori/cutplace/badge.png?branch=master
      :target: https://coveralls.io/r/roskakori/cutplace?branch=master
      :alt: Test coverage

  .. image:: https://img.shields.io/badge/code%20style-black-000000.svg
      :target: https://github.com/psf/black
      :alt: Black

  Cutplace is a tool and API to validate that tabular data stored in CSV,
  Excel, ODS and PRN files conform to a cutplace interface definition (CID).

  As an example, consider the following ``customers.csv`` file that stores data
  about customers::

      customer_id,surname,first_name,born,gender
      1,Beck,Tyler,1995-11-15,male
      2,Gibson,Martin,1969-08-18,male
      3,Hopkins,Chester,1982-12-19,male
      4,Lopez,Tyler,1930-10-13,male
      5,James,Ana,1943-08-10,female
      6,Martin,Jon,1932-09-27,male
      7,Knight,Carolyn,1977-05-25,female
      8,Rose,Tammy,2004-01-12,female
      9,Gutierrez,Reginald,2010-05-18,male
      10,Phillips,Pauline,1960-11-09,female

  A CID can describe such a file in an easy to read way. It consists of
  three sections. First, there is the general data format:

  ==  ==============  ===========
  ..  Property        Value
  ==  ==============  ===========
  D   Format          Delimited
  D   Encoding        UTF-8
  D   Header          1
  D   Line delimiter  LF
  D   Item delimiter  ,
  ==  ==============  ===========

  Next there are the fields stored in the data file:

  ==  =============  ==========  =====  ======  ========  ==============================
  ..  Name           Example     Empty  Length  Type      Rule
  ==  =============  ==========  =====  ======  ========  ==============================
  F   customer_id    3798                       Integer   0...99999
  F   surname        Miller             ...60
  F   first_name     John        X      ...60
  F   date_of_birth  1978-11-27                 DateTime  YYYY-MM-DD
  F   gender         male        X              Choice    female, male
  ==  =============  ==========  =====  ======  ========  ==============================

  Optionally you can describe conditions that must be met across the whole file:

  ==  =======================  ========  ===========
  ..  Description              Type      Rule
  ==  =======================  ========  ===========
  C   customer must be unique  IsUnique  customer_id
  ==  =======================  ========  ===========

  The CID can be stored in common spreadsheet formats, in particular
  Excel and ODS, for example ``cid_customers.ods``.

  Cutplace can validate that the data file conforms to the CID::

      $ cutplace cid_customers.ods customers.csv

  Now add a new line with a broken ``date_of_birth``::

      73921,Harris,Diana,04.08.1953,female

  Cutplace rejects this file with the error message:

      customers.csv (R12C4): cannot accept field 'date_of_birth': date must
      match format YYYY-MM-DD (%Y-%m-%d) but is: '04.08.1953'

  Additionally, cutplace provides an easy to use API to read and write
  tabular data files using a common interface without having to deal with
  the intrinsic of data format specific modules. To read and validate the
  above example::

      import cutplace
      import cutplace.errors

      cid_path = 'cid_customers.ods'
      data_path = 'customers.csv'
      try:
          for row in cutplace.rows(cid_path, data_path):
              pass  # We could also do something useful with the data in ``row`` here.
      except cutplace.errors.DataError as error:
          print(error)

  For more information, read the documentation at
  http://cutplace.readthedocs.org/ or visit the project at
  https://github.com/roskakori/cutplace.


pkgId: 299821f2fb27c5134dd5df8b373ffcc8c7a60086da76629a955b45e7c47137ca
name: python-cutseq
arch: src
version: 0.0.54
epoch: 0
release: 1
summary: Automatically cut adapter / barcode / UMI from NGS data
url: https://github.com/y9c/cutseq
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cutseq-0.0.54-1.src.rpm
checksum_type: sha256
description:
  To solve this by using cutadapt, we can run multiple cutadpat insitent sequentially or pipe multiple commands together. But this waste lots of IO and computational resource. I am thinking there a more eligent API to make things easy. Then comes this toy project.
  -- **What you need is only one parameter which spcific what the library would looks like.**
  CutSeq overcomes these limitations by enabling multiple operations in a automatical manner to ensure accuracy and efficiency.

  ```bash
  pip install cutseq
  ```

  Execute adapter trimming by providing a single parameter and your input files:
  ```bash
  cutseq -A TAKARAV3 test_R1.fq.gz test_R2.fq.gz
  ```
  Alternatively, you can specify a custom adapter sequence:
  `cutseq -a "ACACGACGCTCTTCCGATCTXXX<XXXXXXNNNNNNNNAGATCGGAAGAGCACACGTC"`
  ![](https://raw.githubusercontent.com/y9c/cutseq/main/docs/explain_library.png)
  The customized scheme can be explained by diagram above.
  - The outmost parts on both ends are the Illumina adapters.
  - The first inner parts are inline barcode sequence or customized PCR primers in the library construction step. These are also fixed DNA sequence, and will be represented by by sequence within `(` and `)`.
  - The second inner parts are the UMI sequence, which is a random sequence and will be represented by `N`.
  - The innermost parts are sequnce to be masked, which will be represented by `X`. This can be random tail in the library construction step, caused by template switching or other reasons.
  - The center parts are the actual library sequence, which will be represented by `>` , `<` or `-`. `>` means that sequence is forward, `<` means that sequence is reverse, `-` means that sequence orientation is unknown.
  More details can be found in the [document](https://cutseq.yech.science)

  [ ] support more library scheme


pkgId: 136cce9185b94001d1174752a0be7d61e4c742a4b68374711dcaaa67167e572f
name: python-cutty
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: cutty
url: https://github.com/cjolowicz/cutty
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cutty-0.18.0-1.src.rpm
checksum_type: sha256
description:
  |PyPI| |Status| |Python Version| |License| |Read the Docs| |Tests| |Codecov|
  An experimental Cookiecutter clone :construction:


pkgId: d5af7ec99020e139eaa42afdc30c6d65218dc74b220541bff300afaea6ef2cd9
name: python-cv
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Check version of a Python module
url: https://github.com/mdrachuk/cv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cv-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cv)][pypi]
  [![Downloads](https://img.shields.io/pypi/dm/cv)][pypi]
  [![Build Status](https://img.shields.io/azure-devops/build/misha-drachuk/cv/9)](https://dev.azure.com/misha-drachuk/cv/_build/latest?definitionId=9&branchName=master)
  [![Test Coverage](https://img.shields.io/coveralls/github/mdrachuk/cv/master)](https://coveralls.io/github/mdrachuk/cv)
  [![Supported Python](https://img.shields.io/pypi/pyversions/cv)][pypi]

  Check version of a Python module.

  Raises an error if the `<module>.__version__`:
  - already present on PyPI or custom warehouse deployment;
  - does not match [PEP 440](https://www.python.org/dev/peps/pep-0440);
  - or does not match specified type: alpha/beta/rc/dev/release.

  All of this comes in handy during CI.

  And one more thing: No runtime dependencies!


  Available from [PyPI][pypi]:
  ```shell
  pip install cv
  ```


  With a \<module\> present on PyPI and `<module>.py` in current directory:
  ```python
  __version__ = '7.7.7'

  ...
  ```

  Simply run:
  ```shell
  cv <module>
  ```

  If `7.7.7` version of \<module\> is on PyPI already you’ll get a `VersionExists` error:
  ```plain
  __main__.VersionExists: Package "<module>" with version "7.7.7" already exists on PyPI.
  Change the "<module>.__version__" to fix this error.
  ```


  Packages work in the same way as modules except `__version__` is defined in `<module>/__init__.py`



  ```plain
  $ cv --help
  usage: cv [-h] [-w WAREHOUSE] [--alpha] [--beta] [--rc] [--dev] [--release]
            [--dry]
            module

  Check version of a Python package or module.

  positional arguments:
    module                the package/module with "__version__" defined

  optional arguments:
    -h, --help            show this help message and exit
    -w WAREHOUSE, --warehouse WAREHOUSE
                          package index to use, default is
                          "https://pypi.org/pypi"
    --alpha               check that version is an alpha, e.g. 1.0.0a1
    --beta                check that version is a beta, e.g. 1.0.0b2
    --rc                  check that version is a release candidate, e.g.
                          1.0.0rc
    --dev                 check that version is in development, e.g. 1.0.0.dev3
    --release             check that version is a release without modifiers,
                          e.g. 1.0.0
    --dry                 make no request to PyPI
  ```

  [pypi]: https://pypi.org/project/cv/


pkgId: 61ecce72c4910553180a8974361d47134485e4e4d00d39e58a90fbc606d2fb11
name: python-cv-io
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A collection of I/O scripts for computer vision formats.
url: https://github.com/saeid-h/Computer-Vision-IO.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cv-io-1.1.0-1.src.rpm
checksum_type: sha256
description:
  *.png, *.jpg, ... | All normal images
  *.flo | Middleburry optical flow
  *.dpt | Middleburry floating point depth
  *.pfm | Freiburg floating point disparity
  *.exr | OpenXR hdr format
  *.jxr | MicroSoft JPEG-XR hdr format


pkgId: fac8ad6c732e55ba4100177e424cde8277070d38e355093e3925e8b51919441c
name: python-cv-net-library
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A library of complex-valued neural networks
url: https://github.com/maple18661959396/ISAR_CV_NET
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cv-net-library-0.0.4-1.src.rpm
checksum_type: sha256
description:
  The idea of this library is  to implement Complex class,
  everything else stays the same as any PyTorch code.
  I am basically working with Complex-Valued Neural Networks.  In the need of making our coding more dynamic we build this
  library not to have to repeat the same code over and over and accelerate the speed of coding.


  Only use complex-valued neural networks library:
  `pip install cv-net-library`

  Useful if you want to modify the source code and view the relevant tests:


pkgId: aa39bcb3942670cc5ee22c71c65754d0aef2d8b2941702b1b95659e3cabc7a4a
name: python-cv2-tools
arch: src
version: 2.4.0
epoch: 0
release: 1
url: https://github.com/fernaper/opencv-draw-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cv2-tools-2.4.0-1.src.rpm
checksum_type: sha256
summary:
  Library to help the drawing process with OpenCV. Thought to add labels to the images. Classification of images, etc.

description:
  Library to help the drawing process with OpenCV. Thought to add labels to the images. Classification of images, etc.

  ![cv2-tools](https://user-images.githubusercontent.com/18369529/56097027-839fe680-5eef-11e9-9c35-9d20f92b595e.png)

  **Image generated with face_recognition and drawed with cv2-tools version 2.0.2**





  You will need to install:

  * opencv >= 3.6.2
  * numpy >= 1.13.3
  * python-constraint >= 1.4.0

  You can simply execute:
  `pip install -r requirements.txt`

  Finally you can install the library with:

  `pip install cv2-tools`

  When you install `cv2-tools`, it will automatically download `numpy` but not opencv becouse in some cases you will need another version.



  ```
  import cv2_tools

  print('Name: {}\nVersion:{}\nHelp:{}'.format(cv2_tools.name,cv2_tools.__version__,cv2_tools.help))
  webcam_test()
  ```





  ```
  from cv2_tools.Management import ManagerCV2
  ```

  If you want to work with video or stream, this class will help you mantain your code cleaner while you get more features.

  For example:
   - Open a a stream (your webcam).
   - Reproduce it on real time with max FPS equals to 24.
   - Press `esc` to finish the program.
   - At the end print average FPS.

  ```
  from cv2_tools.Managment import ManagerCV2
  import cv2


  manager_cv2 = ManagerCV2(cv2.VideoCapture(0), is_stream=True, keystroke=27, wait_key=1, fps_limit=60)

    
    for frame in manager_cv2:
        cv2.imshow('Example easy manager', frame)
    cv2.destroyAllWindows()
    print(manager_cv2.get_fps())
  ```

  If you want to use another button and you don't know the ID, you can check easily using the following code:

  ```
  from cv2_tools.Managment import ManagerCV2
  import cv2


  manager_cv2 = ManagerCV2(cv2.VideoCapture(0), is_stream=True, keystroke=27, wait_key=1, fps_limit=60)

    
    for frame in manager_cv2:
        
        last_keystroke = manager_cv2.get_last_keystroke()
        if last_keystroke != -1:
          print(last_keystroke)
        cv2.imshow('Easy button checker', frame)
    cv2.destroyAllWindows()
  ```



  Firstly create a SelectorCV2 object. You can pass it optional parameters to configure the output.
  ```
  from cv2_tools.Selection import SelectorCV2
  selector = SelectorCV2(color=(200,90,0), filled=True)
  ```

  Also you can configure it later using the method (all optional parameters):
  ```
  selector.set_properties()
  ```

  Now, each time you want to add a selected zone call the method:
  ```
  """
  Coordinates:

  (x1,y1)____(x2,y1)
     |          |
     |          |
  (x1,y2)____(x2,y2)

  Tags (optional parameter):
  * It could be a normal string
  * A string with '\n'
  * A list of strings
  * None / '' / [] / False
  """
  selector.add_zone((x1,y1,x2,y2),tags=tag)
  ```

  Finally, when you want to draw all the rectangles execute:
  ```
  edited_frame = selector.draw(frame)
  ```

  If you want to use the same object multiple times you can easily change the content inside it:
  ```

  selector.set_range_valid_rectangles( origin, destination)



  set_valid_rectangles(indexes)
  ```

  If you want, you can see the example [detect_faces.py](examples/detect_faces.py), it also use an open source library called `face_recognition`.


pkgId: 98cfe45b905182924eecc844722c22227ac8b0182704ab199d038933449fd023
name: python-cv2box
arch: src
version: 0.5.9
epoch: 0
release: 1
summary: cv toolbox
url: https://github.com/ykk648/cv2box
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cv2box-0.5.9-1.src.rpm
checksum_type: sha256
description:
  ```shell

  pip install cv2box


  pip install cv2box --no-dependencies


  pip install cv2box[full]


  git clone git@github.com:ykk648/cv2box.git --depth 1
  ```

  ```python

  from cv2box import CVImage
  img_in = 'img path' # or img_in = cv2.imread('img path')
  img_bgr = CVImage(img_in).bgr
  CVImage(img_in).resize(256,256).show()
  ```

  A gather of tools or funcs frequently using in my work.

  Now including these functions:


  - [CVBbox](./cv_ops#cvbox) , different bbox filter.
  - [CVCamera](./cv_ops#cvcamera) , load [multical](https://github.com/makerdao/multicall) calibrate result and give any format of camera matrix.
  - [CVExcel](./cv_ops#cvexcel) , basic ops for insert data to excel file.
  - [CVFile](./cv_ops#cvfile) , for multi-class file io.
  - [CVFolder](./cv_ops) , higher level folder op to do batch file operate.
  - [CVImage](./cv_ops#cvimage) , a image class support multi format convert.
  - [CVQueue](./cv_ops#cvqueue) , queue-like high-level class which can be used for two different python projects communicate on same host machine.
  - [CVRotate](./cv_ops) , under dev.
  - [CVVideo](./cv_ops#cvvideo), a video class support multi kinds of ops.




  Now supports mode switch from multi-thread/multi-process/torch-process.

  - [CV threads base](./cv_gears#CV-Threads-Base) , fast construct your multithread AI program.
  - [CV video thread](./cv_gears#CV-Video-Thread) , give a video path to get a frame thread.
  - [CV multi video thread](./cv_gears#CV-Multi-Video-Thread) , give multical video path to get a multi frame thread.




  - batch uncompress script support different types(zip tar 7z etc.)



  - fps counter
  - apscheduler
  - math (cal distances


pkgId: a981253fd8ce6c5fa6064b5d6840033d4d2c88303ccc8963a9023f1df2860c2d
name: python-cv2ext
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: Extended functionality on top of OpenCV
url: https://github.com/justincdavis/cv2ext
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cv2ext-0.0.25-1.src.rpm
checksum_type: sha256
description:
  https://cv2tools.readthedocs.io/en/latest/
  See Also:
  https://pypi.org/project/cv2ext/

  Compared to the naive solution implemented in Python,
  by using the tools in cv2ext you can achieve an 8x speedup
  on reading and displaying videos.
  ![Performance](benchmarks/visual/showplot.png)


pkgId: bd5d3c9887513a11a59277bcc744ccfd11428ba23a8b86ba428cd3e118e12ab3
name: python-cvasl-gui
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A GUI for the cvasl package
url: https://pypi.org/project/cvasl-gui/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvasl-gui-0.1.3-1.src.rpm
checksum_type: sha256
description:
  This is a GUI for the cvasl package, currently a work-in-progress.




  ```bash
  pip install cvasl-gui
  cvasl-gui
  ```



  The application will look for the following environment variables:

  ```bash
  CVASL_DEBUG_MODE  # True for development, False for production. Debug mode will show the Dash debug console on the page. In production mode, the browser will be automatically opened.
  CVASL_PORT        # The port the server runs on, default is 8767
  ```



  ```bash
  poetry install
  poetry run cvasl-gui
  ```


pkgId: 010bd778ecedbb3ef177ba3caa5811e43b1a9eb62caaac6fec9084274129c0ba
name: python-cvat-manifest-builder
arch: src
version: 0.0.224
epoch: 0
release: 1
summary: Builds a CVAT manifest file from a directory of images.
url: https://github.com/fsai-dev/fsai-cli-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvat-manifest-builder-0.0.224-1.src.rpm
checksum_type: sha256
description:
  ```shell

  > pip install cvat-manifest-builder

  > cvat-manifest-builder --help
  usage: cvat-manifest-builder [-h] --output_manifest_file OUTPUT_MANIFEST_FILE --input_data_path
                               INPUT_DATA_PATH

  Builds a CVAT manifest file from a directory of images.

  optional arguments:
    -h, --help            show this help message and exit
    --output_manifest_file OUTPUT_MANIFEST_FILE
                          Path to the output manifest file.
    --input_data_path INPUT_DATA_PATH
                          Path to the data directory.
  ```


pkgId: ddc8f72fe4f8aade19f4b15809e219c143b6b9c61fc0548cc2a81ee37394a909
name: python-cvat-sdk
arch: src
version: 2.21.0
epoch: 0
release: 1
summary: CVAT REST API
url: https://github.com/cvat-ai/cvat
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvat-sdk-2.21.0-1.src.rpm
checksum_type: sha256
description:
  This package provides a Python client library for CVAT server. It can be useful for
  workflow automation and writing custom CVAT server clients.

  The SDK API includes several layers:

  - Server API wrappers (`ApiClient`). Located in at `cvat_sdk.api_client`.
  - High-level tools (`Core`). Located at `cvat_sdk.core`.
  - PyTorch adapter. Located at `cvat_sdk.pytorch`.
  * Auto-annotation support. Located at `cvat_sdk.auto_annotation`.

  Package documentation is available [here](https://docs.cvat.ai/docs/api_sdk/sdk).



  To install a prebuilt package, run the following command in the terminal:

  ```bash
  pip install cvat-sdk
  ```

  To use the PyTorch adapter, request the `pytorch` extra:

  ```bash
  pip install "cvat-sdk[pytorch]"
  ```

  To install from the local directory, follow [the developer guide](https://docs.cvat.ai/docs/api_sdk/sdk/developer_guide).

  After installation you can import the package:

  ```python
  import cvat_sdk
  ```


pkgId: 37a072507d8ae142b75fe6a46dbbd2d06b8955ccde19d8d7a50b115dcd01fb0c
name: python-cvat-sdk
arch: src
version: 2.23.1
epoch: 0
release: 1
summary: CVAT REST API
url: https://github.com/cvat-ai/cvat
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvat-sdk-2.23.1-1.src.rpm
checksum_type: sha256
description:
  This package provides a Python client library for CVAT server. It can be useful for
  workflow automation and writing custom CVAT server clients.

  The SDK API includes several layers:

  - Server API wrappers (`ApiClient`). Located in at `cvat_sdk.api_client`.
  - High-level tools (`Core`). Located at `cvat_sdk.core`.
  - PyTorch adapter. Located at `cvat_sdk.pytorch`.
  * Auto-annotation support. Located at `cvat_sdk.auto_annotation`.

  Package documentation is available [here](https://docs.cvat.ai/docs/api_sdk/sdk).



  To install a prebuilt package, run the following command in the terminal:

  ```bash
  pip install cvat-sdk
  ```

  To use the `cvat_sdk.masks` module, request the `masks` extra:

  ```bash
  pip install "cvat-sdk[masks]"
  ```

  To use the PyTorch adapter or the built-in PyTorch-based auto-annotation functions,
  request the `pytorch` extra:

  ```bash
  pip install "cvat-sdk[pytorch]"
  ```

  To install from the local directory, follow [the developer guide](https://docs.cvat.ai/docs/api_sdk/sdk/developer_guide).

  After installation you can import the package:

  ```python
  import cvat_sdk
  ```


pkgId: 4c0408f2a114d14c1fa0e0171ef8ccddc1bebb71a48a642afc93894611165947
name: python-cvbase
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Utils for computer vision research
url: https://github.com/hellock/cvbase
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvbase-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/cvbase.svg)](https://pypi.python.org/pypi/cvbase)
  [![Python Version](https://img.shields.io/pypi/pyversions/cvbase.svg)]()
  [![Build Status](https://travis-ci.org/hellock/cvbase.svg?branch=master)](https://travis-ci.org/hellock/cvbase)
  [![Coverage Status](https://codecov.io/gh/hellock/cvbase/branch/master/graph/badge.svg)](https://codecov.io/gh/hellock/cvbase)


  `cvbase` is a miscellaneous set of tools which maybe helpful for computer vision research.
  It comprises the following parts.

  - IO helpers
  - Image/Video operations
  - OpenCV wrappers for python2/3 and opencv 2/3
  - Timer
  - Progress visualization
  - Plotting tools
  - Object detection utils

  Try and start with

  ```shell
  pip install cvbase
  ```

  See [documentation](http://cvbase.readthedocs.io/en/latest) for more features and usage.


  There are some popular features such as progress visualization, timer, video to frames/frames to videos.


  - Progress visualization

      If you want to apply a method to a list of items and track the progress, `track_progress`
      is a good choice. It will display a progress bar to tell the progress and ETA.

      ```python
      import cvbase as cvb

      def func(item):
          
          pass

      tasks = [item_1, item_2, ..., item_n]

      cvb.track_progress(func, tasks)
      ```

      The output is like the following.
      ![progress](docs/_static/progress.gif)

      There is another method `track_parallel_progress`, which wraps multiprocessing and
      progress visualization.

      ```python
      import cvbase as cvb

      def func(item):
          
          pass

      tasks = [item_1, item_2, ..., item_n]

      cvb.track_parallel_progress(func, tasks, 8)
      
      ```

  - Timer

      It is convinient to computer the runtime of a code block with `Timer`.

      ```python
      import time

      with cvb.Timer():
          
          time.sleep(1)
      ```

      Or try a more flexible way.

      ```python
      timer = cvb.Timer()
      
      print(timer.since_start())
      
      print(timer.since_last_check())
      print(timer.since_start())
      ```

  - Video/Frames conversion

      To split a video into frames.

      ```python
      video = cvb.VideoReader('video_file.mp4')
      video.cvt2frames('frame_dir')
      ```
      Besides `cvt2frames`, `VideoReader` wraps many other useful methods to operate a video like a list object, like

      ```
      video = cvb.VideoReader('video_file.mp4')
      len(video)  # get total frame number
      video[5]  # get the 6th frame
      for img in video:  # iterate over all frames
          print(img.shape)
      ```

      To generate a video from frames, use the `frames2video` method.

      ```python
      video = cvb.frames2video('frame_dir', 'out_video_file.avi', fps=30)
      ```

  - Video editing (needs ffmpeg)

      To cut a video.

      ```python
      cvb.cut_video('input.mp4', 'output.mp4', start=3, end=10)
      ```

      To join two video clips.

      ```python
      cvb.concat_video(['clip1.mp4', 'clip2.mp4'], 'output.mp4')
      ```

      To resize a video.

      ```python
      cvb.resize_video('input.mp4', 'resized.mp4', (360, 240))
      
      cvb.resize_video('input.mp4', 'resized.mp4', ratio=2)
      ```

      To convert the format of a video.

      ```python
      cvb.convert_video('input.avi', 'output.mp4', vcodec='h264')
      ```


pkgId: 3f787330b51f74cc245a60e9472e352a380dfb410e9ee389ba5b7ec364d4b5ae
name: python-cvbot
arch: src
version: 3.1.7
epoch: 0
release: 1
summary: Visual based desktop automation toolbox. Supports mouse & keyboard control
url: https://github.com/Runeste3/cvbot
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvbot-3.1.7-1.src.rpm
checksum_type: sha256
description:
  - [x] Mouse & keyboard control.
  - [x] Control windows and get their position.
  - [x] OpenCV image wrapper `Image class` to easily crop, resize, show, and convert images.
  - [x] Flexible digits & numbers recognition/matching.
  - [x] Powerful image search on screen or a local file.
  - [x] Implements sophisticated image search techniques like SIFT.
  - [x] Color based object detection.
  - [x] Very fast screenshot grab.
  - [x] Accurate OCR integrated with `Image class`.
  - [x] Artificial Intelligence based object detection support using Yolov7.

  - [ ] Better documentation.
  - [ ] More QOL functions and classes.


pkgId: 579b00424f9b2cc39274629a3f76f2b237a3a782843f8bb0d40d9d7726760db8
name: python-cvbuilder
arch: src
version: 0.4.54
epoch: 0
release: 1
summary: Package for building OpenCV 4.5.4 including Python 3 bindings from the official sources.
url: https://pypi.org/project/cvbuilder/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvbuilder-0.4.54-1.src.rpm
checksum_type: sha256
description:
  **Unofficial** OpenCV builder for Python.

  This package aims at building OpenCV 4.5.4 with Python bindings from the official sources.
  It provides a simple command line interface for starting the process of downloading the
  official sources, configuring the build dependencies, compiling and installing the resulting
  CV2 shared object within a virtual environment.

  In contrast to [opencv-python](https://github.com/skvark/opencv-python) it will not provide any
  wheels and therefore the installation / build process will be by far slower (depending on the
  actual system performance).

  **IMPORTANT NOTE**

  Depending on the usage and system dependencies, the on-the-fly build output can
  contain video and GUI functionality and the contrib package.




  * builds against Python >= 3.6
  * runs and builds inside virtual environment
  * includes video support
  * supports OpenCV check (import, build information)
  * compiles with many flags enabled (which???)



  * Debian Jessie, Stretch
  * Ubuntu 18.04
  * LinuxMint 18.2
  * Manjaro
  * Arch
  * Raspbian 9 (Stretch)




  * CPython 3.6, 3.7, 3.8, 3.9
  * PyPy (not yet)

  **Note:** PyPy (7.3.0) is not supported yet due to missing path variables in module `sysconfig`.



  1. Use a Python's [virtual environment](https://docs.python.org/3/library/venv.html)
  or even better add the package via [poetry](https://github.com/sdispater/poetry): `poetry add cvbuilder`
  1. Follow instructions below




  After installing the package via `pip` / `pipenv` / `poetry`, you can manually invoke `cvbuilder` commands.



  ```bash
  cvbuilder system --enable-gui --enable-video
  ```



  The `do-it-all` command is:

  ```bash
  cvbuilder build
  ```

  or if you already downloaded the source zip files in the default temporary
  directory or need to rerun the process in a clean way:

  ```bash
  cvbuilder build --clean
  ```




  If you need to run the individual steps (i.e. for debugging) the following
  commands are provided.



  ```bash
  cvbuilder download
  ```



  ```bash
  cvbuilder configure [--tmpdir XYZ]
  ```



  ```bash
  cvbuilder make
  ```



  ```bash
  cvbuilder install
  ```



  ```bash
  cvbuilder dump
  ```



  You can run the check command:

  ```bash
  cvbuilder check
  ```

  in order to check whether the build process and installation worked.




  Now everything should be up and running and you should be able to work with OpenCV:

  1. Start a python REPL: `poetry run python`
  1. Import the CV package: `import cv2`
  1. Read [OpenCV documentation](http://docs.opencv.org/)


pkgId: 914cd19c08724ec0d8c927604705cce1d72c05fecf4c877ecbcc70447d12e121
name: python-cvdast
arch: src
version: 1.48.18
epoch: 0
release: 1
url: https://pypi.org/project/cvdast/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvdast-1.48.18-1.src.rpm
checksum_type: sha256
summary:
  To regenerate pytest fixtures and test methods dynamically from OpenAPI spec and Cloudvector APIShark events

description:
  CV-DAST is a Python library for regenerating the pytest fixtures and test cases dynamically from Open API Spec and Cloudvector APIShark events

  Visit https://www.cloudvector.com/api-shark-free-observability-security-monitoring-tool/#apishark



  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install foobar.

  ```bash
  pip install cv-dast
  ```



  ```python cv-dast

  ****************************************************************************************************
  CloudVector CommunityEdition - Coverage analysis plugin
  ****************************************************************************************************

  Enter CommunityEdition(CE) host in format <host>:<port> : x.x.x.x:y
  Enter your CommunityEdition(CE) username : sandeep
  CommunityEdition(CE) password:
  Enter absolute path to Old API SPEC: ../input.json
  Enter absolute path to new API SPEC : ../input1.json
  Do you want to process only diff? (Y/N) :
  Enter absolute path to input parameteres json(press Enter for None):
  ```

  instead of giving inputs every single time you can also alternatively create a file called my_cesetup.yaml in the path from where you are running the tool

  ```yaml
  ce_host:
  ce_username:
  ```
  you can have multiple such my_cesetup.yaml for different CE setup or different recordings and run them from specific paths for its corresponding reports


  [MIT](https://choosealicense.com/licenses/mit/)


pkgId: 446c284c76815d3bccee6dd25db28e3b01363f32cfd85993a054640f64752fef
name: python-cvdupdate
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: ClamAV Private Database Mirror Updater Tool
url: https://github.com/Cisco-Talos/cvdupdate
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cvdupdate-1.1.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">A tool to download and update clamav databases and database patch files
  for the purposes of hosting your own database mirror.
  <p align="center"><em>Copyright (C) 2021-2022 Cisco Systems, Inc. and/or its affiliates. All rights reserved.</em></p>

  <p align="center">
  <a href="https://pypi.org/project/cvdupdate/">
    <img src="https://badge.fury.io/py/cvdupdate.svg" alt="PyPI version" height="18">
  </a>
  <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/cvdupdate" height="18">
  <a href="https://discord.gg/6vNAqWnVgw"><img src="https://img.shields.io/discord/636023333074370595.svg?logo=discord" height="18"/></a>
  <a href="https://twitter.com/clamav"><img src="https://abs.twimg.com/favicons/twitter.ico" width="18" height="18"></a>
  </p>



  This tool downloads the latest ClamAV databases along with the latest database patch files.

  This project replaces the `clamdownloader.pl` Perl script by Frederic Vanden Poel, formerly provided here: https://www.clamav.net/documents/private-local-mirrors

  Run this tool as often as you like, but it will only download new content if there is new content to download. If you somehow manage to download too frequently (eg: by using `cvd clean all` and `cvd update` repeatedly), then the official database server may refuse your download request, and one or more databases may go on cool-down until it's safe to try again.



  - Python 3.6 or newer.
  - An internet connection with DNS enabled.
  - The following Python packages.  These will be installed automatically if you use `pip`, but may need to be installed manually otherwise:
    - `click` v7.0 or newer
    - `coloredlogs` v10.0 or newer
    - `colorama`
    - `requests`
    - `dnspython` v2.1.0 or newer
    - `rangehttpserver`



  You may install `cvdupdate` from PyPI using `pip`, or you may clone the project Git repository and use `pip` to install it locally.

  Install `cvdupdate` from PyPI:

  ```bash
  python3 -m pip install --user cvdupdate
  ```



  Use the `--help` option with any `cvd` command to get help.

  ```bash
  cvd --help
  ```

  > _Tip_: You may not be able to run the `cvd` or `cvdupdate` shortcut directly if your Python Scripts directory is not in your `PATH` environment variable. If you run into this issue, and do not wish to add the Python Scripts directory to your path, you can run CVD-Update like this:
  >
  > ```bash
  > python -m cvdupdate --help
  > ```

  (optional) You may wish to customize where the databases are stored:

  ```bash
  cvd config set --dbdir <your www path>
  ```

  Run this to download the latest database and associated CDIFF patch files:

  ```bash
  cvd update
  ```

  Downloaded databases will be placed in `~/.cvdupdate/database` unless you customized it to use a different directory.

  Newly downloaded databases will replace the previous database version, but the CDIFF patch files will accumulate up to a configured maximum before it starts deleting old CDIFFs (default: 30 CDIFFs). You can configure it to keep more CDIFFs by manually editing the config (default: `~/.cvdupdate/config.json`). The same behavior applies for CVD-Update log rotation.

  Run this to serve up the database directory on `http://localhost:8000` so you can test it with FreshClam.

  ```bash
  cvd serve
  ```

  > _Disclaimer_: The `cvd serve` feature is not intended for production use, just for testing. You probably want to use a more robust HTTP server for production work.

  Install ClamAV if you don't already have it and, in another terminal window, modify your `freshclam.conf` file. Replace:
  ```
  DatabaseMirror database.clamav.net
  ```

  ... with:
  ```
  DatabaseMirror http://localhost:8000
  ```

  > _Tip_: A default install on Linux/Unix places `freshclam.conf` in `/usr/local/etc/freshclam.conf`. If one does not exist, you may need to create it using `freshclam.conf.sample` as a template.

  Now, run `freshclam -v` or `freshclam.exe -v` to see what happens. You should see FreshClam successfully update it's own database directory from your private database server.

  Run `cvd update` as often as you need.  Maybe put it in a `cron` job.

  > _Tip_: Each command supports a `--verbose` (`-V`) mode, which often provides more details about what's going on under the hood.



  Cron is a popular choice to automate frequent tasks on Linux / Unix systems.

  1. Open a terminal running as the user which you want CVD-Update to run under, do the following:

     ```bash
     crontab -e
     ```

  2. Press `i` to insert new text, and add this line:

     ```bash
     30 */4 * * * /bin/sh -c "~/.local/bin/cvd update &> /dev/null"
     ```

     Or instead of `~/`, you can do this, replacing `username` with your user name:

     ```bash
     30 */4 * * * /bin/sh -c "/home/username/.local/bin/cvd update &> /dev/null"
     ```

  3. Press <Escape>, then type `:wq` and press <Enter> to write the file to disk and quit.

  **About these settings**:

  I selected `30 */4 * * *` to run at minute 30 past every 4th hour. CVD-Update uses a DNS check to do version checks before it attempts to download any files, just like FreshClam. Running CVD-Update more than once a day should not be an issue.

  CVD-Update will write logs to the `~/.cvdupdate/logs` directory, which is why I directed `stdout` and `stderr` to `/dev/null` instead of a log file. You can use the `cvd config set` command to customize the log directory if you like, or redirect `stdout` and `stderr` to a log file if you prefer everything in one log instead of separate daily logs.





  DNS is required for CVD-Update to function properly (to gather the TXT record containing the current definition database version). You can select a specific nameserver to ensure said nameserver is used when querying the TXT record containing the current database definition version available

  1. Set the nameserver in the config. Eg:

     ```bash
     cvd config set --nameserver 208.67.222.222
     ```

  2. Set the environment variable `CVDUPDATE_NAMESERVER`. Eg:

     ```bash
     CVDUPDATE_NAMESERVER="208.67.222.222" cvd update
     ```

  The environment variable will take precedence over the nameserver config setting.

  Note:  Both options can be used to provide a comma-delimited list of nameservers to utilize for resolution.



  Depending on your type of proxy, you may be able to use CVD-Update with your proxy by running CVD-Update like this:

  First, set a custom domain name server to use the proxy:

  ```bash
  cvd config set --nameserver <proxy_ip>
  ```

  Then run CVD-Update like this:

  ```bash
  http_proxy=http://<proxy_ip>:<proxy_port> https_proxy=http://<proxy_ip>:<proxy_port> cvd update -V
  ```

  Or create a script to wrap the CVD-Update call. Something like:

  ```bash

  http_proxy=http://<proxy_ip>:<proxy_port>
  export http_proxy
  https_proxy=http://<proxy_ip>:<proxy_port>
  export https_proxy
  cvd update -V
  ```

  > _Disclaimer_: CVD-Update doesn't support proxies that require authentication at this time. If your network admin allows it, you may be able to work around it by updating your proxy to allow HTTP requests through unauthenticated if the User-Agent matches your specific CVD-Update user agent. The CVD-Update User-Agent follows the form `CVDUPDATE/<version> (<uuid>)` where the `uuid` is unique to your installation and can be found in the `~/.cvdupdate/state.json` file (or `~/.cvdupdate/config.json` for cvdupdate <=1.0.2). See https://github.com/Cisco-Talos/cvdupdate/issues/9 for more details.
  >
  > Adding support for proxy authentication is a ripe opportunity for a community contribution to the project.



  This tool is to creates the following directories:
   - `~/.cvdupdate`
   - `~/.cvdupdate/logs`
   - `~/.cvdupdate/databases`

  This tool creates the following files:
   - `~/.cvdupdate/config.json`
   - `~/.cvdupdate/state.json`
   - `~/.cvdupdate/databases/<database>.cvd`
   - `~/.cvdupdate/databases/<database>-<version>.cdiff`
   - `~/.cvdupdate/logs/<date>.log`

  > _Tip_: You can set custom `database` and `logs` directories with the `cvd config set` command. It is likely you will want to customize the `database` directory to point to your HTTP server's `www` directory (or equivalent). Bare in mind that if you already downloaded the databases to the old directory, you may want to move them to the new directory.

  > _Important_: If you want to use a custom config path, you'll have to use it in every command. If you're fine with having it go in `~/.cvdupdate/config.json`, don't worry about it.





  Familiarize yourself with the various commands using the `--help` option.

  ```bash
  cvd --help
  cvd config --help
  cvd update --help
  cvd clean --help
  ```

  Print out the current list of databases.

  ```bash
  cvd list -V
  ```

  Print out the config to see what it looks like.

  ```bash
  cvd config show
  ```



  Do an update, use "verbose mode" to so you can get a feel for how it works.

  ```bash
  cvd update -V
  ```

  List out the databases again:

  ```bash
  cvd list -V
  ```

  The print out the config again so you can see what's changed.

  ```bash
  cvd config show
  ```

  And maybe take a peek in the database directory as well to see it for yourself.

  ```bash
  ls ~/.cvdupdate/database
  ```

  Have a look at the logs if you wish.

  ```bash
  ls ~/.cvdupdate/logs

  cat ~/.cvdupdate/logs/*
  ```



  Test out your mirror with FreshClam on the same computer.

  This tool includes a `--serve` feature that will host the current database directory on http://localhost (default port: 8000).

  You can test it by running `freshclam` or `freshclam.exe` locally, where you've configured `freshclam.conf` with:

  ```
  DatabaseMirror http://localhost:8000
  ```



  We'd love your help. There are many ways to contribute!



  Join the ClamAV community on the [ClamAV Discord chat server](https://discord.gg/sGaxA5Q).



  If you find an issue with CVD-Update or the CVD-Update documentation, please submit an issue to our [GitHub issue tracker](https://github.com/Cisco-Talos/cvdupdate/issues).  Before you submit, please check to if someone else has already reported the issue.



  If you find a bug and you're able to craft a fix yourself, consider submitting the fix in a [pull request](https://github.com/Cisco-Talos/cvdupdate/pulls). Your help will be greatly appreciated.

  If you want to contribute to the project and don't have anything specific in mind, please check out our [issue tracker](https://github.com/Cisco-Talos/cvdupdate/issues).  Perhaps you'll be able to fix a bug or add a cool new feature.

  _By submitting a contribution to the project, you acknowledge and agree to assign Cisco Systems, Inc the copyright for the contribution. If you submit a significant contribution such as a new feature or capability or a large amount of code, you may be asked to sign a contributors license agreement comfirming that Cisco will have copyright license and patent license and that you are authorized to contribute the code._



  The following steps are intended to help users that wish to contribute to development of the CVD-Update project get started.

  1. Create a fork of the [CVD-Update git repository](https://github.com/Cisco-Talos/cvdupdate), and then clone your fork to a local directory.

      For example:

      ```bash
      git clone https://github.com/<your username>/cvdupdate.git
      ```

  2. Make sure CVD-Update is not already installed.  If it is, remove it.

      ```bash
      python3 -m pip uninstall cvdupdate
      ```

  3. Use pip to install CVD-Update in "edit" mode.

      ```bash
      python3 -m pip install -e --user ./cvdupdate
      ```

  Once installed in "edit" mode, any changes you make to your clone of the CVD-Update code will be immediately usable simply by running the `cvdupdate` / `cvd` commands.



  This project has not selected a specific Code-of-Conduct document at this time. However, contributors are expected to behave in professional and respectful manner. Disrespectful or inappropriate behavior will not be tolerated.



  CVD-Update is licensed under the Apache License, Version 2.0 (the "License"). You may not use the CVD-Update project except in compliance with the License.

  A copy of the license is located [here](LICENSE), and is also available online at [apache.org](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: b7270b42522c7eab6843e6cc23209c4eb55699f35e01c6583c500410896d9785
name: python-cve-bin-tool
arch: src
version: 3.4
epoch: 0
release: 1
summary: CVE Binary Checker Tool
url: https://github.com/intel/cve-bin-tool
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cve-bin-tool-3.4-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://github.com/intel/cve-bin-tool/actions/workflows/cve_bin_tool_action.yml/badge.svg?branch=main&event=push)](https://github.com/intel/cve-bin-tool/actions)
  [![codecov](https://codecov.io/gh/intel/cve-bin-tool/branch/main/graph/badge.svg)](https://codecov.io/gh/intel/cve-bin-tool)
  [![Gitter](https://badges.gitter.im/cve-bin-tool/community.svg)](https://gitter.im/cve-bin-tool/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
  [![On ReadTheDocs](https://readthedocs.org/projects/cve-bin-tool/badge/?version=latest&style=flat)](https://cve-bin-tool.readthedocs.io/en/latest/)
  [![On PyPI](https://img.shields.io/pypi/v/cve-bin-tool)](https://pypi.org/project/cve-bin-tool/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/5380/badge)](https://bestpractices.coreinfrastructure.org/projects/5380)
  [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/intel/cve-bin-tool/badge)](https://securityscorecards.dev/viewer/?uri=github.com/intel/cve-bin-tool)

  The CVE Binary Tool is a free, open source tool to help you find known vulnerabilities in software, using data from the [National Vulnerability Database](https://nvd.nist.gov/) (NVD) list of [Common Vulnerabilities and Exposures](<https://en.wikipedia.org/wiki/Common_Vulnerabilities_and_Exposures#:~:text=Common%20Vulnerabilities%20and%20Exposures%20(CVE)%20is%20a%20dictionary%20of%20common,publicly%20known%20information%20security%20vulnerabilities.>) (CVEs) as well as known vulnerability data from [Redhat](https://access.redhat.com/hydra/rest/securitydata), [Open Source Vulnerability Database (OSV)](https://osv.dev/), [Gitlab Advisory Database (GAD)](https://advisories.gitlab.com/), and [Curl](https://curl.se/docs/vuln.json).

  CVE Binary Tool uses the NVD API but is not endorsed or certified by the NVD.

  The tool has two main modes of operation:

  1. A binary scanner which helps you determine which packages may have been included as part of a piece of software. There are <!-- NUMBER OF CHECKERS START-->365<!--NUMBER OF CHECKERS END--> checkers.  Our initial focus was on common, vulnerable open source components such as openssl, libpng, libxml2 and expat.

  2. Tools for scanning known component lists in various formats, including .csv, several linux distribution package lists, language specific package scanners and several Software Bill of Materials (SBOM) formats.

  It is intended to be used as part of your continuous integration system to enable regular vulnerability scanning and give you early warning of known issues in your supply chain.  It can also be used to auto-detect components and create SBOMs.

  What CVE Binary Tool does when it runs:

  ![Diagram of cve-bin-tool's workflow, described in text with more detail below.](https://raw.githubusercontent.com/intel/cve-bin-tool/main/doc/images/cve-bin-tool-workflow-800px.png)

  1. Download CVE Data (from NVD, Redhat, OSV, Gitlab, and Curl).
     - This happens once per day by default, not every time a scan is run.
     - On first run, downloading all data can take some time.
  2. Create/read a component list. There are two modes of operation:
     1. Creates a component list (including versions) using a combination of binary checkers and language component lists (such as python's requirements.txt).
     2. Read SBOM (use an existing component list in a standardized Software Bill of Materials format.)
  3. Create CVE List
     - This looks up all components found or read from an existing bill of materials and reports back any known issues associated with them
  4. Include triage/additional data
     - There are several options for adding triage/notes, information from previous reports to track vulnerability change over time, or known fix data
  5. Generate report in one or more formats (console, json, csv, html, pdf)

  For more details, see our [documentation](https://cve-bin-tool.readthedocs.io/en/latest/) or this [quickstart guide](https://cve-bin-tool.readthedocs.io/en/latest/README.html)

  - [CVE Binary Tool quick start / README](#cve-binary-tool-quick-start--readme)
    - [Installing CVE Binary Tool](#installing-cve-binary-tool)
    - [Most popular usage options](#most-popular-usage-options)
      - [Finding known vulnerabilities using the binary scanner](#finding-known-vulnerabilities-using-the-binary-scanner)
      - [Scanning an SBOM file for known vulnerabilities](#scanning-an-sbom-file-for-known-vulnerabilities)
      - [Generating an SBOM](#generating-an-sbom)
      - [Generating a VEX](#generating-a-vex)
      - [Triaging vulnerabilities](#triaging-vulnerabilities)
      - [Using the tool offline](#using-the-tool-offline)
      - [Using CVE Binary Tool in GitHub Actions](#using-cve-binary-tool-in-github-actions)
    - [Output Options](#output-options)
    - [Configuration](#configuration)
    - [Auto-detection of components](#auto-detection-of-components)
      - [Binary checker list](#binary-checker-list)
      - [Language Specific checkers](#language-specific-checkers)
      - [Supported Archive Formats](#supported-archive-formats)
    - [Additional Requirements](#additional-requirements)
    - [Limitations](#limitations)
    - [Feedback \& Contributions](#feedback--contributions)
    - [Security Issues](#security-issues)
    - [Full option list](#full-option-list)



  CVE Binary Tool can be installed using pip:

  ```console
  pip install cve-bin-tool
  ```

  If you want to try the latest code from
  [the cve-bin-tool github](https://github.com/intel/cve-bin-tool) or do development, you can also `pip install --user -e .` to install a local copy from a directory.  The [Contributor Documentation](https://github.com/intel/cve-bin-tool/blob/main/CONTRIBUTING.md) covers how to set up for local development in more detail.

  Pip will install the python requirements for you, but for some types of extraction we use system libraries. If you have difficulties extracting files, you may want to look at our [additional Requirements lists for Linux and Windows](#additional-requirements).

  On first usage (and by default, once per day) The tool will download vulnerability data from [a set of known vulnerability data sources](https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#data-sources).  Due to reliability issues with NVD, as of release 3.3 we will be using our own NVD mirror at [https://cveb.in/](https://cveb.in/) by default rather than contacting NVD directly.  If you wish to get data directly from the NVD servers you must [provide your own NVD_API_KEY](https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--nvd-api-key-nvd_api_key) to use their API.

  If you are using a release prior to 3.3 that does not use our mirror, please use an NVD_API_KEY as described above.





  To run the binary scanner on a directory or file:

  ```bash
  cve-bin-tool <directory/file>
  ```

  > **Note**: That this option will also use any [language specific checkers](#language-specific-checkers) to find known vulnerabilities in components.

  By default, the tool assumes you are attempting to scan a whole directory, but if you provide it with a single .csv or .json file that lists dependencies it will treat it as a bill of materials.  You can also specify bill of materials files directly using [the `--input-file` option](https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-i-input_file---input-file-input_file) or scan SBOMs with the instructions below.



  To scan a software bill of materials file (SBOM):

  ```bash
  cve-bin-tool --sbom <sbom_filetype> --sbom-file <sbom_filename>
  ```

  Valid SBOM types are [SPDX](https://spdx.dev/specifications/),
  [CycloneDX](https://cyclonedx.org/specification/overview/), and [SWID](https://csrc.nist.gov/projects/software-identification-swid/guidelines).
  Scanning of product names within an SBOM file is case insensitive.

  The [SBOM scanning how-to guide](https://github.com/intel/cve-bin-tool/blob/main/doc/how_to_guides/sbom.md) provides additional SBOM scanning examples.



  As well as scanning SBOMs, CVE Binary Tool can be used to generate an SBOM from a scan as follows:

  ```bash
  cve-bin-tool  --sbom-type <sbom_type> --sbom-format <sbom-format> --sbom-output <sbom_filename> <other scan options as required>
  ```

  Valid SBOM types are [SPDX](https://spdx.dev/specifications/) and [CycloneDX](https://cyclonedx.org/specification/overview/).

  The generated SBOM will include product name, version and supplier (where available). License information is not provided.

  The [SBOM generation how-to guide](https://github.com/intel/cve-bin-tool/blob/main/doc/how_to_guides/sbom_generation.md) provides additional SBOM generation examples.



  As well as scanning VEX, CVE Binary Tool can be used to generate an VEX from a scan as follows:

  ```bash
  cve-bin-tool  --vex-type <vex_type> --vex-output <vex_filename> <other scan options as required>
  ```

  Valid VEX types are [CSAF](https://oasis-open.github.io/csaf-documentation/), [CycloneDX](https://cyclonedx.org/capabilities/vex/) and [OpenVEX](https://edu.chainguard.dev/open-source/sbom/what-is-openvex/).


  The [VEX generation how-to guide](https://github.com/intel/cve-bin-tool/blob/main/doc/how_to_guides/vex_generation.md) provides additional VEX generation examples.



  The `--vex-file` option can be used to add extra triage data like remarks, comments etc. while scanning a directory so that output will reflect this triage data and you can save time of re-triaging (Usage: `cve-bin-tool --vex-file test.json /path/to/scan`).
  The supported format is the [CycloneDX](https://cyclonedx.org/capabilities/vex/),[CSAF](https://oasis-open.github.io/csaf-documentation/) and [OpenVEX](https://edu.chainguard.dev/open-source/sbom/what-is-openvex/) VEX format which can be generated using the `--vex-output` option.

  Typical usage:

  1. Generate triage file using `cve-bin-tool /path/to/scan --vex-output triage.json`
  2. Edit triage.json with your favourite text editor to provide triage information on the vulnerabilities listed.
  3. Use this triage file for future scans as follows: `cve-bin-tool /path/to/scan --vex-file triage.json`

  For better usage guide refer this [link](https://cve-bin-tool.readthedocs.io/en/latest/triaging_process.html) .

  It should be possible to share triage data across different runs of cve-bin-tool or with other tools that support the CycloneDX VEX, OpenVEX and CSAF format.  This would be particularly useful for teams that scan related products or containers, teams that need to use multiple tools for compliance reasons, companies that have a central security policy group that provides guidance on vulnerability triage, and more.



  Specifying the `--offline` option when running a scan ensures that cve-bin-tool doesn't attempt to download the latest database files or to check for a newer version of the tool.

  Note that you will need to obtain a copy of the vulnerability data before the tool can run in offline mode. [The offline how-to guide contains more information on how to set up your database.](https://github.com/intel/cve-bin-tool/blob/main/doc/how_to_guides/offline.md)



  If you want to integrate cve-bin-tool as a part of your github action pipeline, you can use cve-bin-tool's official GitHub Action. Find more details [here](https://github.com/intel/cve-bin-tool-action/#cve-binary-tool-github-action). The GitHub Action provide reports on the security tab, which is available to open source projects as well as GitHub customers who have paid for that access.

  We also provide an example [GitHub action](https://github.com/intel/cve-bin-tool/blob/main/doc/how_to_guides/cve_scanner_gh_action.yml) if you wish to use the tool directly.  This may be a good choice for teams who want to store reports in an evidence locker or those who don't have access to the GitHub Security tab.



  The CVE Binary Tool provides console-based output by default. If you wish to provide another format, you can specify this and a filename on the command line using `--format`. The valid formats are CSV, JSON, JSON2, console, HTML and PDF. The output filename can be specified using the `--output-file` flag.

  You can also specify multiple output formats by using comma (',') as separator:

  ```bash
  cve-bin-tool file -f csv,json,json2,html -o report
  ```

  Note: You must not use spaces between the commas (',') and the output formats.

  The reported vulnerabilities can additionally be reported in the
  Vulnerability Exploitability  eXchange (VEX) format by specifying `--vex-output` with type defined using `--vex-type` command line option.
  The generated VEX file can then be used as a `--vex-file` to support
  a triage process.

  If you wish to use PDF support, you will need to install the `reportlab`
  library separately.

  If you intend to use PDF support when you install cve-bin-tool you can specify it and report lab will be installed as part of the cve-bin-tool install:

  ```console
  pip install cve-bin-tool[PDF]
  ```

  If you've already installed cve-bin-tool you can add reportlab after the fact
  using pip:

  ```console
  pip install --upgrade reportlab
  ```

  Note that reportlab was taken out of the default cve-bin-tool install because
  it has a known CVE associated with it
  ([CVE-2020-28463](https://nvd.nist.gov/vuln/detail/CVE-2020-28463)). The
  cve-bin-tool code uses the recommended mitigations to limit which resources
  added to PDFs, as well as additional input validation. This is a bit of a
  strange CVE because it describes core functionality of PDFs: external items,
  such as images, can be embedded in them, and thus anyone viewing a PDF could
  load an external image (similar to how viewing a web page can trigger external
  loads). There's no inherent "fix" for that, only mitigations where users of
  the library must ensure only expected items are added to PDFs at the time of
  generation.

  Since users may not want to have software installed with an open, unfixable CVE
  associated with it, we've opted to make PDF support only available to users who
  have installed the library themselves. Once the library is installed, the PDF
  report option will function.



  You can use `--config` option to provide configuration file for the tool. You can still override options specified in config file with command line arguments. See our sample config files in the
  [test/config](https://github.com/intel/cve-bin-tool/blob/main/test/config/)



  CVE Binary tool attempts to do auto-detection of components using binary checkers, supported language component lists, and file extraction methods.  The supported tools for auto-detection are listed below.



  The following checkers are available for finding components in binary files:

  <!--CHECKERS TABLE BEGIN-->
  |   |  |  | Available checkers |  |  |  |
  |--------------- |------------- |------------------ |--------------- |----------------- |-------------- |--------------- |
  | accountsservice |acpid |apache_http_server |apcupsd |apparmor |asn1c |assimp |
  | asterisk |atftp |avahi |axel |bash |bind |binutils |
  | bird |bison |bluez |boinc |botan |bro |bubblewrap |
  | busybox |bwm_ng |bzip2 |c_ares |capnproto |ceph |chess |
  | chrony |civetweb |clamav |collectd |commons_compress |connman |coreutils |
  | cpio |cronie |cryptsetup |cups |curl |cvs |darkhttpd |
  | dav1d |davfs2 |dbus |debianutils |dhclient |dhcpcd |dhcpd |
  | dmidecode |dnsmasq |docker |domoticz |dosfstools |dotnet |dovecot |
  | doxygen |dpkg |dropbear |e2fsprogs |ed |elfutils |emacs |
  | enscript |exfatprogs |exim |exiv2 |f2fs_tools |faad2 |fastd |
  | ffmpeg |file |firefox |flac |fluidsynth |freeradius |freerdp |
  | fribidi |frr |gawk |gcc |gdal |gdb |gdk_pixbuf |
  | ghostscript |gimp |git |glib |glibc |gmp |gnomeshell |
  | gnupg |gnutls |go |gpgme |gpsd |graphicsmagick |grep |
  | grub2 |gstreamer |gupnp |gvfs |gzip |haproxy |harfbuzz |
  | haserl |hdf5 |heimdal |hostapd |hunspell |hwloc |i2pd |
  | icecast |icu |iperf3 |ipmitool |ipsec_tools |iptables |irssi |
  | iucode_tool |iwd |jack2 |jacksondatabind |janus |jasper |jhead |
  | jq |json_c |kbd |keepalived |kerberos |kexectools |kodi |
  | kubernetes |ldns |lftp |libarchive |libass |libbpg |libcoap |
  | libconfuse |libcurl |libdb |libde265 |libebml |libevent |libexpat |
  | libgcrypt |libgd |libgit2 |libheif |libical |libidn2 |libinput |
  | libjpeg |libjpeg_turbo |libksba |liblas |libmatroska |libmemcached |libmicrohttpd |
  | libmodbus |libnss |libopenmpt |libpcap |libraw |librsvg |librsync |
  | libsamplerate |libseccomp |libsndfile |libsolv |libsoup |libsrtp |libssh |
  | libssh2 |libtasn1 |libtiff |libtomcrypt |libupnp |libuv |libvips |
  | libvirt |libvncserver |libvorbis |libvpx |libxslt |libyaml |lighttpd |
  | linux_kernel |lldpd |logrotate |lrzip |lua |luajit |lxc |
  | lynx |lz4 |mailx |mariadb |mbedtls |mdadm |memcached |
  | micropython |minetest |mini_httpd |minicom |minidlna |miniupnpc |miniupnpd |
  | moby |modsecurity |monit |mosquitto |motion |mp4v2 |mpg123 |
  | mpv |msmtp |mtr |mupdf |mutt |mysql |nano |
  | nasm |nbd |ncurses |neon |nessus |netatalk |netdata |
  | netkit_ftp |netpbm |nettle |nghttp2 |nginx |ngircd |nmap |
  | node |ntfs_3g |ntp |ntpsec |open_iscsi |open_vm_tools |openafs |
  | opencv |openjpeg |openldap |opensc |openssh |openssl |openswan |
  | openvpn |p7zip |pango |patch |pcre |pcre2 |pcsc_lite |
  | perl |php |picocom |pigz |pixman |png |polarssl_fedora |
  | poppler |postgresql |ppp |privoxy |procps_ng |proftpd |protobuf_c |
  | pspp |pure_ftpd |putty |python |qemu |qpdf |qt |
  | quagga |radare2 |radvd |raptor |rauc |rdesktop |readline |
  | rpm |rsync |rsyslog |rtl_433 |rtmpdump |runc |rust |
  | samba |sane_backends |sdl |seahorse |shadowsocks_libev |snapd |sngrep |
  | snort |socat |sofia_sip |speex |spice |sqlite |squashfs |
  | squid |sslh |stellarium |strongswan |stunnel |subversion |sudo |
  | suricata |sylpheed |syslogng |sysstat |systemd |tar |tcpdump |
  | tcpreplay |terminology |tesseract |thrift |thttpd |thunderbird |timescaledb |
  | tinyproxy |tor |tpm2_tss |traceroute |transmission |trousers |ttyd |
  | twonky_server |u_boot |udisks |unbound |unixodbc |upx |util_linux |
  | varnish |vim |vlc |vorbis_tools |vsftpd |webkitgtk |wget |
  | wireshark |wolfssl |wpa_supplicant |xerces |xml2 |xscreensaver |xwayland |
  | yasm |zabbix |zchunk |zeek |zlib |znc |zsh |
  | zstandard | | | | | | |
  <!--CHECKERS TABLE END-->

  All the checkers can be found in the checkers directory, as can the
  [instructions on how to add a new checker](https://github.com/intel/cve-bin-tool/blob/main/cve_bin_tool/checkers/README.md).
  Support for new checkers can be requested via
  [GitHub issues](https://github.com/intel/cve-bin-tool/issues).



  A number of checkers are available for finding vulnerable components in specific language packages.

  | Language   | Files supported                                 |
  | ---------- | ----------------------------------------------- |
  | Dart         | `pubspec.lock` |
  | Go         | `Go.mod` |
  | Java       | `pom.xml`; JAR, WAR and EAR archives |
  | JavaScript | `package-lock.json`, `yarn.lock` |
  | Rust       | `Cargo.lock` |
  | Ruby       | `Gemfile.lock` |
  | R          | `renv.lock` |
  | Swift      | `Package.resolved` |
  | Python     | `requirements.txt`, `PKG-INFO`, `METADATA`; .whl and .egg files |
  | Perl       | `cpanfile` |

  More information on [language-specific checkers](https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#language-specific-checkers) can be found in the [CVE Binary Tool manual](https://cve-bin-tool.readthedocs.io/en/latest/MANUAL.html).



  The following archive formats are currently supported by the auto-extractor:

  | Archive Format | File Extension                                 |
  | -------------- | ---------------------------------------------- |
  | zip            | .zip, .exe, .jar, .msi, .egg, .whl, .war, .ear |
  | tar            | .tar, .tgz, .tar.gz, .tar.xz, .tar.bz2         |
  | deb            | .deb, .ipk                                     |
  | rpm            | .rpm                                           |
  | cab            | .cab                                           |
  | apk            | .apk                                           |
  | zst            | .zst                                           |
  | pkg            | .pkg                                           |



  To use the auto-extractor, you may need the following utilities depending on the type of [supported archive formats](#supported-archive-formats) you need to extract.

  The utilities below are required to run the full test suite on Linux:

  - `file`
  - `strings`
  - `tar`
  - `unzip`
  - `rpm2cpio`
  - `cpio`
  - `ar`
  - `cabextract`

  Most of these are installed by default on many Linux systems, but `cabextract` and
  `rpm2cpio` in particular might need to be installed.

  On windows systems, you may need:

  - `ar`
  - `7z`
  - `Expand`
  - `pdftotext`

  Windows has `Expand` installed by default, but `ar` and `7z` might need to be installed.
  If you want to run our test-suite or scan a zstd compressed file, We recommend installing this [7-zip-zstd](https://github.com/mcmilk/7-Zip-zstd)
  fork of 7zip. We are currently using `7z` for extracting `jar`, `apk`, `msi`, `exe` and `rpm` files.
  To install `ar` you can install MinGW (which has binutils as a part of it) from [here](https://www.mingw-w64.org/downloads/#msys2) and run the downloaded .exe file.

  If you get an error about building libraries when you try to install from pip,
  you may need to install the Windows build tools. The Windows build tools are
  available for free from
  <https://visualstudio.microsoft.com/visual-cpp-build-tools/>

  If you get an error while installing brotlipy on Windows, installing the
  compiler above should fix it.

  `pdftotext` is required for running tests. (users of cve-bin-tool may not need it, developers likely will.) The best approach to install it on Windows involves using [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/windows.html) (click [here](https://anaconda.org/conda-forge/pdftotext) for further instructions).

  You can check [our CI configuration](https://github.com/intel/cve-bin-tool/blob/main/.github/workflows/testing.yml) to see what versions of python we're explicitly testing.



  This scanner does not attempt to exploit issues or examine the code in greater
  detail; it only looks for library signatures and version numbers. As such, it
  cannot tell if someone has backported fixes to a vulnerable version, and it
  will not work if library or version information was intentionally obfuscated.

  This tool is meant to be used as a quick-to-run, easily-automatable check in a
  non-malicious environment so that developers can be made aware of old libraries
  with security issues that have been compiled into their binaries.

  The tool does not guarantee that any vulnerabilities reported are actually present or exploitable, neither is it able to find all present vulnerabilities with a guarantee.

  Users can add triage information to reports to mark issues as false positives, indicate that the risk has been mitigated by configuration/usage changes, and so on.

  Triage details can be re-used on other projects so, for example, triage on a Linux base image could be applied to multiple containers using that image.

  For more information and usage of triage information with the tool kindly have a look [here](https://cve-bin-tool.readthedocs.io/en/latest/triaging_process.html).

  If you are using the binary scanner capabilities, be aware that we only have a limited number of binary checkers (see table above) so we can only detect those libraries. Contributions of new checkers are always welcome! You can also use an alternate way to detect components (for example, a bill of materials tool such as [tern](https://github.com/tern-tools/tern)) and then use the resulting list as input to cve-bin-tool to get a more comprehensive vulnerability list.

  The tool uses a vulnerability database in order to detect the present vulnerabilities, in case the database is not frequently updated (specially if the tool is used in offline mode), the tool would be unable to detect any newly discovered vulnerabilities. Hence it is highly advised to keep the database updated.

  The tool does not guarantee that all vulnerabilities are reported as the tool only has access to a limited number of publicly available vulnerability databases.
  Contributions to introduce new sources of data to the tool are always welcome.

  Whilst some validation checks are performed on the data within the vulnerability database, the tool is unable to assert the quality of the data or correct any
  discrepancies if the data is incomplete or inconsistent. This may result, for example, in some vulnerability reports where the severity is reported as UNKNOWN.



  Bugs and feature requests can be made via [GitHub
  issues](https://github.com/intel/cve-bin-tool/issues). Be aware that these issues are
  not private, so take care when providing output to make sure you are not
  disclosing security issues in other products.

  Pull requests are also welcome via git.

  - New contributors should read the [contributor guide](https://github.com/intel/cve-bin-tool/blob/main/CONTRIBUTING.md) to get started.
  - Folk who already have experience contributing to open source projects may not need the full guide but should still use the [pull request checklist](https://github.com/intel/cve-bin-tool/blob/main/CONTRIBUTING.md#checklist-for-a-great-pull-request) to make things easy for everyone.

  CVE Binary Tool contributors are asked to adhere to the [Python Community Code of Conduct](https://www.python.org/psf/conduct/). Please contact [Terri](https://github.com/terriko/) if you have concerns or questions relating to this code of conduct.



  Security issues with the tool itself can be reported to Intel's security
  incident response team via
  [https://intel.com/security](https://intel.com/security).

  If in the course of using this tool you discover a security issue with someone
  else's code, please disclose responsibly to the appropriate party.




  Usage:
  `cve-bin-tool <directory/file to scan>`

  <pre>
  options:
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-h---help">-h, --help</a>            show this help message and exit
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-e-exclude---exclude-exclude">-e EXCLUDE, --exclude</a> EXCLUDE
                          Comma separated Exclude directory path
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-v---version">-V, --version</a>         show program's version number and exit
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--disable-version-check">--disable-version-check</a>
                          skips checking for a new version
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--disable-validation-check">--disable-validation-check</a>
                          skips checking xml files against schema
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--offline">--offline</a>             operate in offline mode
    --detailed            add CVE description in csv or json report (no effect on console, html or pdf)

  CVE Data Download:
    Arguments related to data sources and Cache Configuration

    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-n-json-nvdjson-mirrorapiapi2---nvd-json-nvdjson-mirrorapiapi2">-n {api,api2,json,json-mirror,json-nvd}, --nvd {api,api2,json,json-mirror,json-nvd}</a>
                          choose method for getting CVE lists from NVD
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-u-nowdailyneverlatest---update-nowdailyneverlatest">-u {now,daily,never,latest}, --update {now,daily,never,latest}</a>
                          update schedule for data sources and exploits database (default: daily)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--nvd-api-key-nvd_api_key">--nvd-api-key NVD_API_KEY</a>
                          Specify NVD API key (used to improve NVD rate limit).
                          Set to `no` to ignore any keys in the environment.
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-d-nvdosvgadcurl-nvdosvgadcurl----disable-data-source-nvdosvgadcurl-nvdosvgadcurl-">-d DISABLE_DATA_SOURCE, --disable-data-source DISABLE_DATA_SOURCE</a>
                          comma-separated list of data sources (CURL, EPSS, GAD, NVD, OSV, PURL2CPE, REDHAT, RSD) to disable (default: NONE)

    --use-mirror USE_MIRROR
                          use an mirror to update the database

  Input:
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#directory-positional-argument">directory</a>             directory to scan
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-i-input_file---input-file-input_file">-i INPUT_FILE, --input-file INPUT_FILE</a>
                          provide input filename
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-c-config---config-config">-C CONFIG, --config CONFIG</a>
                          provide config file
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-l-package_list---package-list-package_list">-L PACKAGE_LIST, --package-list PACKAGE_LIST</a>
                          provide package list
    --sbom {spdx,cyclonedx,swid}
                          specify type of software bill of materials (sbom) (default: spdx)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--sbom-file-sbom_file">--sbom-file SBOM_FILE</a>
                          provide sbom filename
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#d--vex-file-vex_file">--vex-file VEX_FILE</a>
                          provide vulnerability exploitability exchange (vex) filename for triage processing


  Output:
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#quiet-mode">-q, --quiet</a>           suppress output
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#logging-modes">-l {debug,info,warning,error,critical}, --log {debug,info,warning,error,critical}</a>
                          log level (default: info)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-o-output_file---output-file-output_file">-o OUTPUT_FILE, --output-file OUTPUT_FILE</a>
                          provide output filename (default: output to stdout)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--html-theme-html_theme">--html-theme HTML_THEME</a>
                          provide custom theme directory for HTML Report
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-f-csvjsonconsolehtml---format-csvjsonconsolehtml">-f {csv,json,json2,console,html,pdf}, --format {csv,json,json2,console,html,pdf}</a>
                          update output format (default: console)
                          specify multiple output formats by using comma (',') as a separator
                          note: don't use spaces between comma (',') and the output formats.
    --generate-config {yaml,toml,yaml,toml,toml,yaml}
                          generate config file for cve bin tool in toml and yaml formats.
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-c-cvss---cvss-cvss">-c CVSS, --cvss CVSS</a>  minimum CVSS score (as integer in range 0 to 10) to report (default: 0)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-s-lowmediumhighcritical---severity-lowmediumhighcritical">-S {low,medium,high,critical}, --severity {low,medium,high,critical}</a>
                          minimum CVE severity to report (default: low)
    --metrics
                          check for metrics (e.g., EPSS) from found cves
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--epss-percentile">--epss-percentile EPSS_PERCENTILE</a>
                          minimum epss percentile of CVE range between 0 to 100 to report. Automatically enables `--metrics`
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--epss-probability">--epss-probability EPSS_PROBABILITY</a>
                          minimum epss probability of CVE range between 0 to 100 to report. Automatically enables `--metrics`
    --no-0-cve-report     only produce report when CVEs are found
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-a-distro_name-distro_version_name---available-fix-distro_name-distro_version_name">-A [<distro_name>-<distro_version_name>], --available-fix [<distro_name>-<distro_version_name>]</a>
                          Lists available fixes of the package from Linux distribution
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-b-distro_name-distro_version_name---backport-fix-distro_name-distro_version_name">-b [<distro_name>-<distro_version_name>], --backport-fix [<distro_name>-<distro_version_name>]</a>
                          Lists backported fixes if available from Linux distribution
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--affected-versions">--affected-versions</a>   Lists versions of product affected by a given CVE (to facilitate upgrades)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--sbom-output-sbom_output">--sbom-output SBOM_OUTPUT</a>
                          provide software bill of materials (sbom) filename to generate
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--sbom-type">--sbom-type {spdx,cyclonedx}</a>
                          specify type of software bill of materials (sbom) to generate (default: spdx)
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--sbom-format">--sbom-format {tag,json,yaml}</a>
                          specify format of software bill of materials (sbom) to generate (default: tag)

  Vex Output:
    Arguments related to Vex output document.

    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--vex-output-vex_output">--vex-ouptput VEX_OUTPUT</a>
                          Provide vulnerability exploitability exchange (vex) filename to generate
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--vex-type">--vex-type {cyclonedx, csaf, openvex}</a>
                          specify type of vulnerability exploitability exchange (vex) to generate (default: cyclonedx)
    --product PRODUCT     Product Name
    --release RELEASE     Release Version
    --vendor VENDOR       Vendor/Supplier of Product
    -rr REVISION_REASON, --revision-reason REVISION_REASON
                          a reason for the update to the vex document should be specified in double quotes
    --filter-triage       Filter cves based on triage data from Vex file

  Merge Report:
    Arguments related to Intermediate and Merged Reports

    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-a-intermediate_path---append-intermediate_path">-a [APPEND], --append [APPEND]</a>
                          save output as intermediate report in json format
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-t-tag---tag-tag">-t TAG, --tag TAG</a>     add a unique tag to differentiate between multiple intermediate reports
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-m-intermediate_reports---merge-intermediate_reports">-m MERGE, --merge MERGE</a>
                          comma separated intermediate reports path for merging
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-f-tags---filter-tags">-F FILTER, --filter FILTER</a>
                          comma separated tag string for filtering intermediate reports

  Checkers:
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-s-skips---skips-skips">-s SKIPS, --skips SKIPS</a>
                          comma-separated list of checkers to disable
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-r-checkers---runs-checkers">-r RUNS, --runs RUNS</a>  comma-separated list of checkers to enable

  Database Management:
    --import-json IMPORT_JSON
                          import database from json files chopped by years
    --ignore-sig          do not verify PGP signature while importing json data
    --log-signature-error
                          when the signature doesn't match log the error only instead of halting (UNSAFE)
    --verify PGP_PUBKEY_PATH
                          verify PGP sign while importing json files
    --export-json EXPORT_JSON
                          export database as json files chopped by years
    --pgp-sign PGP_PRIVATE_KEY_PATH
                          sign exported json files with PGP
    --passphrase PASSPHRASE
                          required passphrase for signing with PGP
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--export-export">--export EXPORT</a>       export database filename
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--import-import">--import IMPORT</a>       import database filename

  Exploits:
    --exploits            check for exploits from found cves

  Deprecated:
    --triage-input-file TRIAGE_INPUT_FILE
                          replaced by --vex-file
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#-x---extract">-x, --extract</a>         autoextract compressed files
    <a href="https://github.com/intel/cve-bin-tool/blob/main/doc/MANUAL.md#--report">--report</a>              Produces a report even if there are no CVE for the respective output format
  </pre>

  For further information about all of these options, please see [the CVE Binary Tool user manual](https://cve-bin-tool.readthedocs.io/en/latest/MANUAL.html).


