# packages

pkgId: 0b905eefa0cd6eb55a0e8020a47b6bb52fd9067bcf68f66dd8010d6299cf97a9
name: python-chuy
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Set alias to long commands and speed up your workflow.
url: https://github.com/UltiRequiem/chuy
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chuy-1.4.0-1.src.rpm
checksum_type: sha256
description:
  ![CodeQL](https://github.com/UltiRequiem/chuy/workflows/CodeQL/badge.svg)
  ![PyTest](https://github.com/UltiRequiem/chuy/workflows/PyTest/badge.svg)
  ![Pylint](https://github.com/UltiRequiem/chuy/workflows/Pylint/badge.svg)
  [![Code Style](https://img.shields.io/badge/Code%20Style-Black-000000.svg)](https://github.com/psf/black)
  [![PyPi Version](https://img.shields.io/pypi/v/chuy)](https://pypi.org/project/chuy)
  ![Repo Size](https://img.shields.io/github/repo-size/ultirequiem/chuy?style=flat-square&label=Repo)
  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
  ![Lines of Code](https://img.shields.io/tokei/lines/github.com/UltiRequiem/chuy?color=blue&label=Total%20Lines)

  Set alias to long commands and speed up your workflow,
  inspired in tools like [yarn](https://yarnpkg.com) and [npm](https://github.com/npm/cli).

  Although Chuy is written in Python, it can be used for projects of any language,
  and even folders that are not projects!

  **Note:** this tool is actively used by its primary author.
  He's happy to review pull requests / respond to issues you may discover.



  You can install [Chuy](https://pypi.org/project/chuy) from PyPI like any other package:

  ```bash
  pip install chuy
  ```

  To get the last version:

  ```bash
  pip install git+https:/github.com/UltiRequiem/chuy
  ```

  If you use Linux, you may need to install this with sudo to
  be able to access the command throughout your system.



  Using `JSON` format:

  ```json
  {
    "format": "poetry run black .",
    "lint": "poetry run pylint chuy tests",
    "tests": "poetry run pytest",
    "package": "poetry build && poetry publish"
  }
  ```

  > Example: [`chuy.json`](./chuy.json)

  Using `TOML` format:

  ```toml
  [chuy]
  format = "poetry run black ."
  lint = "poetry run pylint chuy tests"
  tests = "poetry run pytest"
  package = "poetry build && poetry publish"
  ```

  > Example: [`chuy.toml`](./chuy.toml)

  Using `pyproject.toml` file:

  ```toml
  [tool.chuy]
  format = "poetry run black ."
  lint = "poetry run pylint chuy tests"
  tests = "poetry run pytest"
  package = "poetry build && poetry publish"
  ```

  > Example: [`pyproject.toml`](./pyproject.toml)

  Usually the configuration file goes in the root of your project but it can really go anywhere.



  After having defined the commands in the [chuy.json](#example-configuration-file) file,
  you can now execute them as follows:

  ```bash
  chuy format
   $ poetry run black .
   ....
  ```

  This varies depending on the commands you
  have written in the [chuy file](#example-configuration-file).

  ```bash
  chuy lint
   $ poetry run pylint chuy tests
   ....
  ```

  You can also pass multiple commands:

  ```bash
  chuy lint format tests
   $ poetry run pylint chuy tests
   ....

   $ poetry run black .
   ....

   $ poetry run pytest
   ....
  ```



  If you do not pass any command, you will get a menu with all the available commands,
  then you will be asked which of them you want to execute,
  here you can pass more than one command if you want.

  If you want to integrate this tool with Poetry, try: [UltiRequiem/poetry-chuy-plugin](https://github.com/UltiRequiem/poetry-chuy-plugin)



  Normal usage:

  ![Screenshot Normal Usage](https://i.imgur.com/sOu86gu.png)

  And if you don't pass any command:

  ![Screenshot Menu](https://i.imgur.com/nFd4Bz9.png)



  Chuy is licensed under the [MIT License](./LICENSE).


pkgId: 0d7b789d7843f9e1fc79ad0fc2d2685a5c082317bb999ff57ccdf9f57edd5a4f
name: python-chuyya-library
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: A Python library for generating shipment invoices in PDF
url: https://github.com/your_username/my_library
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chuyya-library-1.0.4-1.src.rpm
checksum_type: sha256
description:
  My Library is a Python library for generating shipment invoices in PDF format. It supports custom fonts, logos, and dynamic data insertion.



  ```bash
  pip install my_library


pkgId: 5d2b1b73df6ca4eac0df7c4ed880163795f4dd86bb4b6427f1e67effa9c4ca8f
name: python-ci
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Easily run common CI tasks for Python builds.
url: https://github.com/rossmacarthur/python-ci
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/ci.svg?style=flat-square&colorB=4c1)][pypi]
  [![Build Status](https://img.shields.io/travis/rossmacarthur/python-ci/master.svg?style=flat-square)][travis]
  [![Code Coverage](https://img.shields.io/codecov/c/github/rossmacarthur/python-ci.svg?style=flat-square)][codecov]

  Easily run common CI tasks for Python builds.



  Install this package with

  ```bash
  pip install ci
  ```



  Here are some examples of how you would use the `ci` tool.

  Run `flake8` on Python 2.7 only
  ```
  ci --skip 2.7 flake8
  ```

  Run `pip install codecov` on Python 3.x.x only
  ```
  ci --only 3 pip install codecov
  ```

  Run `codecov` on Python 3.7.2 only
  ```
  ci --only 3.7.2 codecov
  ```

  If for some reason you are running a command that takes the same options as this
  tool then you can use two dashes `--` to specify that this tool should no longer
  match options:
  ```
  ci --only 3 -- git --version
  ```



  This project is licensed under the MIT License. See the [LICENSE] file.

  [LICENSE]: LICENSE
  [pypi]: https://pypi.org/project/ci/
  [travis]: https://travis-ci.org/rossmacarthur/python-ci
  [codecov]: https://codecov.io/gh/rossmacarthur/python-ci


pkgId: 914773e803d810738702e4f49640fe34e86000b24343e2d3597e3366a03335ca
name: python-ci-buildbot
arch: src
version: 0.11.3
epoch: 0
release: 1
summary: Slack client for reporting on CodePipeline runs
url: https://pypi.org/project/ci-buildbot/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-buildbot-0.11.3-1.src.rpm
checksum_type: sha256
description:
  `ci-buildbot` is a command line tool to do slack messaging from CodePipelines.  `ci-buildbot` acts as a Slack App in
  order to do its work.

  To install:

  ```bash
  pyenv virtualenv 3.8.5 ci-buildbot
  pyenv local ci-buildbot
  pip install -r requirements.txt
  pip install -e .
  ```

  Now set up the environment:

  ```bash
  cp etc/environment.text .env
  ```

  You'll need to know two things:

  * `SLACK_API_TOKEN`: this your Slack app's Oath token
  * `CHANNEL`: this is the channel you want `ci-buildbot` to post into.  Note that if this is a private channel, you'll need to invite the `ci-buildbot` app into that channel before you'll see any messages.

  Now you can run the main command, `buildbot`:

  ```bash
  buildbot --help
  ```



  I get the icons for the Slack messages here: https://iconmonstr.com.

  Get them as .pngs, 64x64px, name them appropriately to the build steps they're going to be used in, and save them to `./icons/`

  For the gray icons (`foo-start.png`), use #909090 as the icon color.
  For the green icons (`foo-success.png`), use #0D6B19 as the icon color.
  For the red icons (`foo-failure.png`), use #801B0B as the icon color.

  `ci-buildbot` tells slack to retrieve the icons from an S3 bucket: ads-utils-icons.s3.amanzonaws.com.  Do this to sync `./icons` to S3:

  ```bash
  make icons
  ```



  ```bash
  export CODEBUILD_START_TIME=1594856732.3577878
  export CODEBUILD_VPC_AZ=us-west-2b
  export CODEBUILD_LAST_EXIT=0
  export CODEBUILD_START_TIME=1538752095466
  export CODEBUILD_BMR_URL=https://CODEBUILD_AGENT:3000
  export CODEBUILD_SOURCE_VERSION=arn:aws:s3:::bucket/pipeline/App/OGgJCVJ.zip
  export CODEBUILD_KMS_KEY_ID=arn:aws:kms:us-west-2:000000011111:alias/aws/s3
  export CODEBUILD_BUILD_ID=codebuild-project:40b92e01-706b-422a-9305-8bdb16f7c269
  export OLDPWD=/codebuild/output/src00011222/src
  export CODEBUILD_GOPATH=/codebuild/output/src084981953
  export CODEBUILD_RESOLVED_SOURCE_VERSION=9e0d29404ee30b7b63258414ecccc996bbeb55c6
  export CODEBUILD_BUILD_SUCCEEDING=1
  export CODEBUILD_BUILD_ARN=arn:aws:codebuild:us-west-2:000000001111:build/codebuild-project:40b92e01-706b-422a-9305-8bdb16f7c269
  export AWS_CONTAINER_CREDENTIALS_RELATIVE_URI=/v2/credentials/e5f23b9f-c72e-4384-9ba1-37d08aa052b7
  export CODEBUILD_INITIATOR=codepipeline/pipeline-name
  export AWS_DEFAULT_REGION=us-west-2
  export CODEBUILD_LOG_PATH=40b92e01-706b-422a-9305-8bdb16f7c269
  export CODEBUILD_BUILD_IMAGE=000011112222.dkr.ecr.us-west-2.amazonaws.com/codebuild:docker-image
  export AWS_REGION=us-west-2
  export CODEBUILD_SRC_DIR=/codebuild/output/src00011222/src
  export CODEBUILD_AUTH_TOKEN=0730f0ab-5299-4235-a2c2-bb1f6ad07033
  ```


pkgId: 33a78929a2231e13fdb6e469b5d9384f5812840ae9fd30b69a2379bc869a385c
name: python-ci-helper
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Get info on how a package should be built on CI
url: https://github.com/chrisjbillington/ci-helper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-helper-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Output information to help build a Python package in CI



  This tool exists to address certain issues of bit-rot and deployment of GitHub Actions
  workflows (though the problem exists for CI generally) that build Python packages.

  It looks up what current Python versions are supported so you can target them in your
  builds without having to maintain a curated list. It determines whether building on
  multiple OSs or Python versions is needed for a Python package, allowing you to deploy a
  generic CI configuration for different types of packages without having to modify it for
  each one specifically when they only vary in this way.

  Specifically:

  * It lists all stable and supported Python versions so your CI can target all supported
  versions of Python without having to curate a manual list.

  * It tells you what the second-most-recent minor version of Python is, so you can use that
  as a sensible default for tools that require a recent-ish Python but are likely not to
  work immediately after a new Python is released.

  * It tells you whether a Python package is pure Python or not, so that your CI knows
  whether it needs to build on multiple OSs/Python versions.

  * It tells you whether a Python package's dependencies have environment markers or not, so
  that your CI knows whether it needs to build on multiple OSs/Python versions, for
  package formats that don't support environment markers in dependencies (e.g. conda
  packages).

  These functions are all serving the goals of:

  * Minimising how often you need to modify your CI configs just because a new version of
    Python came our or an old version reached end-of-life
  * Minimising (ideally to zero) how much you need to customise an otherwise generic CI
    config when you re-use it for different types of Python packages (e.g. pure vs impure)



  This package is available on PyPI, install it to your current Python environemnt with
  ```bash
  pip install ci-helper
  ```



  ```bash

  $ ci-helper pythons
  3.9,3.10,3.11,3.12,3.13


  $ ci-helper pythons --cibw
  cp39-* cp310-* cp311-* cp312-* cp313-*



  $ ci-helper defaultpython
  3.12





  $ ci-helper distinfo .
  {
      "name": "ci-helper",
      "version": "0.1.dev1+g5043fb5.d20241202",
      "is_pure": true,
      "has_env_markers": false
  }


  $ ci-helper distinfo name .
  ci-helper
  $ ci-helper distinfo version .
  0.1.0
  $ ci-helper distinfo is_pure .
  true
  $ ci-helper distinfo has_env_markers .
  false
  ```



  ```shell
  $ ci-helper -h
  usage: ci-helper [-h] [--version] {pythons,defaultpython,distinfo} ...

  positional arguments:
    {pythons,defaultpython,distinfo}
                          Action to perform
      pythons             Output list of stable Python versions that have not yet reached end of life, see `ci-helper pythons -h`
      defaultpython       Output the second-latest stable Python version in X.Y format, useful as a good choice for a default python version
      distinfo            Output info about the distribution, see `ci-helper distinfo -h`

  options:
    -h, --help            show this help message and exit
    --version             show program's version number and exit
  ```

  ```shell
  $ ci-helper pythons -h
  usage: ci-helper pythons [-h] [--cibw]

  options:
    -h, --help  show this help message and exit
    --cibw      Output as a space-separated list in the format `cpXY-* cpXY-*` as appropriate for the CIBW_BUILD environment variable to build for all
                stable CPython versions, otherwise versions are output as a comma-separated list in the format X.Y,X.Y
  ```

  ```shell
  $ ci-helper default_python -h
  usage: ci-helper defaultpython [-h]

  options:
    -h, --help  show this help message and exit
  ```

  ```shell
  $ ci-helper distinfo -h
  usage: ci-helper distinfo [-h]
                            [{name,version,is_pure,has_env_markers}]
                            project_directory

  positional arguments:
    {name,version,is_pure,has_env_markers}
                          Name of field to output as a single json value, if not
                          given, all info is output as json
    project_directory     Directory of Python project

  options:
    -h, --help            show this help message and exit
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Christopher Billington  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: 9e6354f4cbbdb39b3dfd62e4c6966860971dea97b49289c00f3bb6c2f48c73a7
name: python-ci-info
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Continuous Integration Information
url: https://github.com/mgxd/ci-info
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-info-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/ci-info.svg)](https://badge.fury.io/py/ci-info)
  [![Build Status](https://travis-ci.org/mgxd/ci-info.svg?branch=master)](https://travis-ci.org/mgxd/ci-info)

  A Python implementation of [watson/ci-info](https://github.com/watson/ci-info).
  Get details about the current Continuous Integration environment.

  Please [open an issue](https://github.com/mgxd/ci-info/issues/new)
  if your CI server isn't properly detected :)




  Officially supported CI servers:

  | Name                                                                            | isPR |
  | ------------------------------------------------------------------------------- | ---- |
  | [AWS CodeBuild](https://aws.amazon.com/codebuild/)                              | 🚫   |
  | [AppVeyor](http://www.appveyor.com)                                             | ✅   |
  | [Azure Pipelines](https://azure.microsoft.com/en-us/services/devops/pipelines/) | ✅   |
  | [Appcircle](https://appcircle.io/)                                              | 🚫   |
  | [Bamboo](https://www.atlassian.com/software/bamboo) by Atlassian                | 🚫   |
  | [Bitbucket Pipelines](https://bitbucket.org/product/features/pipelines)         | ✅   |
  | [Bitrise](https://www.bitrise.io/)                                              | ✅   |
  | [Buddy](https://buddy.works/)                                                   | ✅   |
  | [Buildkite](https://buildkite.com)                                              | ✅   |
  | [CircleCI](http://circleci.com)                                                 | ✅   |
  | [Cirrus CI](https://cirrus-ci.org)                                              | ✅   |
  | [Codefresh](https://codefresh.io/)                                              | ✅   |
  | [Codeship](https://codeship.com)                                                | 🚫   |
  | [Drone](https://drone.io)                                                       | ✅   |
  | [dsari](https://github.com/rfinnie/dsari)                                       | 🚫   |
  | [Expo Application Services](https://expo.dev/eas)                               | 🚫   |
  | [GitHub Actions](https://github.com/features/actions/)                          | ✅   |
  | [GitLab CI](https://about.gitlab.com/gitlab-ci/)                                | ✅   |
  | [GoCD](https://www.go.cd/)                                                      | 🚫   |
  | [Hudson](http://hudson-ci.org)                                                  | 🚫   |
  | [Jenkins CI](https://jenkins-ci.org)                                            | ✅   |
  | [LayerCI](https://layerci.com/)                                                 | ✅   |
  | [Magnum CI](https://magnum-ci.com)                                              | 🚫   |
  | [Netlify CI](https://www.netlify.com/)                                          | ✅   |
  | [Nevercode](http://nevercode.io/)                                               | ✅   |
  | [Render](https://render.com/)                                                   | ✅   |
  | [Sail CI](https://sail.ci/)                                                     | ✅   |
  | [Screwdriver](https://screwdriver.cd/)                                          | ✅   |
  | [Semaphore](https://semaphoreci.com)                                            | ✅   |
  | [Shippable](https://www.shippable.com/)                                         | ✅   |
  | [Solano CI](https://www.solanolabs.com/)                                        | ✅   |
  | [Strider CD](https://strider-cd.github.io/)                                     | 🚫   |
  | [TaskCluster](http://docs.taskcluster.net)                                      | 🚫   |
  | [TeamCity](https://www.jetbrains.com/teamcity/) by JetBrains                    | 🚫   |
  | [Travis CI](http://travis-ci.org)                                               | ✅   |
  | [Vercel](https://vercel.com/)                                                   | 🚫   |
  | [Visual Studio App Center](https://appcenter.ms/)                               | 🚫   |




  ```
  pip install ci-info
  ```



  ```python
  import ci_info
  if ci_info.is_ci():
      print(ci_info.name())

  "My CI Name"
  ```






  Returns a string containing name of the CI server the code is running on.
  If CI server is not detected, it returns `None`.

  Don't depend on the value of this string not to change for a specific
  vendor.



  Returns a boolean. Will be `True` if the code is running on a CI server,
  otherwise `False`.

  Some CI servers not listed here might still trigger the `ci_info.is_ci()`
  boolean to be set to `True` if they use certain vendor neutral
  environment variables. In those cases `ci_info.name()` will be `None` and no
  vendor specific boolean will be set to `True`.



  Returns a boolean if PR detection is supported for the current CI server. Will
  be `True` if a PR is being tested, otherwise `False`. If PR detection is
  not supported for the current CI server, the value will be `None`.



  Returns a dictionary of all above values in key/value pairs.



  [MIT](LICENSE)


pkgId: 467a007efe7bb5a437e4ec93811672bd831b322d230f3cd41d3c5a82f3e2cd3d
name: python-ci-py
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Python toolkit for working with Continuous Integration services.
url: https://github.com/grantmcconnaughey/ci.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-py-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/grantmcconnaughey/ci.py.svg?branch=master)](https://travis-ci.org/grantmcconnaughey/ci.py)

  A Python library for working with Continuous Integration services. For Python 2.7 and 3.5+.



  First, `pip` install ci.py:

      $ pip install ci-py



  ```python
  import ci

  ci.is_ci()  # True/False
  ci.is_pr()  # True/False
  ci.name()  # "Travis CI"
  ci.pr()  # "38"
  ci.repo()  # "grantmcconnaughey/ci.py"
  ci.commit_sha()  # "246249bab34e78a020efc67b626efd6052e754d9"
  ```



  ci.py works with the following CI services:

  - Travis CI
  - Circle CI
  - GitHub Actions
  - Drone CI
  - AppVeyor
  - Shippable
  - Semaphore
  - AWS CodeBuild
  - Azure DevOps



  To run tests, install `tox` and run it from the command line:

  ```
  > tox
  ```

  This will run tests against all of the Python versions defined in `tox.ini`. Note that all of these versions of Python will need to be installed. You can use `pyenv` to install these different versions.


pkgId: 83658fc315ae1399f349a5d1d6a0027f3566de5db979391941581e554085599c
name: python-ci-sdr
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A sample Python project
url: https://github.com/fgnt/ci_sdr
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-sdr-0.0.2-1.src.rpm
checksum_type: sha256
description:
  ![Run python tests](https://github.com/fgnt/ci_sdr/workflows/Run%20python%20tests/badge.svg)
  [![PyPI](https://img.shields.io/pypi/v/ci_sdr)](https://pypi.org/project/ci-sdr)
  [![codecov.io](https://codecov.io/github/fgnt/ci_sdr/coverage.svg?branch=main)](https://codecov.io/github/fgnt/ci_sdr?branch=main)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/ci_sdr)](https://pypi.org/project/ci-sdr)
  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/fgnt/ci_sdr/blob/master/LICENSE)

  <!-- ![Run python dependency test](https://github.com/fgnt/ci_sdr/workflows/Run%20python%20dependency%20test/badge.svg) -->


  This repository contains an implementation for the `Convolutive transfer function Invariant Signal-to-Distortion Ratio` objective for PyTorch as described in the publication `Convolutive Transfer Function Invariant SDR training criteria for Multi-Channel Reverberant Speech Separation` ([link arXiv][arXiv]).

  Here, a small example, how you can use this CI-SDR objective in your own source code:

  ```python
  import torch
  import ci_sdr

  reference: torch.tensor = ...


  estimation: torch.tensor = ...


  sdr = ci_sdr.pt.ci_sdr_loss(estimation, reference)

  ```

  The idea of this objective function is based in the theory from `E. Vincent, R. Gribonval and C. Févotte, Performance measurement in blind audio source separation, IEEE Trans. Audio, Speech and Language Processing`, known as
  `BSSEval`.
  The original author provided MATLAB source code ([link](http://bass-db.gforge.inria.fr/bss_eval/)) and the package `mir_eval` ([link](http://craffel.github.io/mir_eval/#module-mir_eval.separation)) contains a python port. Some peoble refer to these implementations as `BSSEval v3` ([link](https://github.com/sigsep/bsseval)).

  The PyTorch code in this package is tested to yield the same `SDR` values as `mir_eval` with the default parameters.

  > **NOTE:** If you want to use `BSSEval v3 SDR` as metric, I recomment to use `mir_eval.separation.bss_eval_sources` and use as reference the clean/unreverberated source signals. The implementation in this repository has minor difference that makes it problematic to compare SDR values accorss different publications (e.g. here the permutation is calculated on the SDR, while `mir_eval` computes it based on the `SIR`.).





  Install it directly with Pip, if you just want to use it:

  ```bash
  pip install ci-sdr
  ```

  or to get the recent version:

  ```bash
  pip install git+https://github.com/fgnt/ci_sdr.git
  ```

  If you want to install it with `all` dependencies (test and doctest dependencies), run:

  ```bash
  pip install git+https://github.com/fgnt/ci_sdr.git#egg=ci_sdr[all]
  ```

  When you want to change the code, clone this repository and install it as `editable`:

  ```bash
  git clone https://github.com/fgnt/ci_sdr.git
  cd ci_sdr
  pip install --editable .

  ```



  To cite this implementation, you can cite the following paper ([link][arXiv]):
  ```
  @article{boeddeker2020convolutive,
    title   = {Convolutive Transfer Function Invariant {SDR} training criteria for Multi-Channel Reverberant Speech Separation},
    author  = {Boeddeker, Christoph and Zhang, Wangyou and Nakatani, Tomohiro and Kinoshita, Keisuke and Ochiai, Tsubasa and Delcroix, Marc and Kamo, Naoyuki and Qian, Yanmin and Haeb-Umbach, Reinhold},
    journal = {arXiv preprint arXiv:2011.15003},
    year    = {2020}
  }
  ```



  [arXiv]: https://arxiv.org/abs/2011.15003


pkgId: 4ebc6ec37f21e47f71c14c41a805e7039a10c8aaa15c7778018eff471c0293f5
name: python-ci-test-toolkit
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A framework for static analysis testing of CI configurations.
url: https://github.com/ekohilas/ci-test
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-test-toolkit-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A framework for static analysis testing of CI configurations.



  Install using `pipx install ci-test-toolkit` to add `ci-test` to your PATH.

  The tool can be run either via `ci-test` once installed or `python -m ci_test` from within the `src` folder.



  `ci-test gitlab rule-snapshot <path_to_json>` will create a snapshot of your ci configuration, by listing all rulesets and the jobs that will run for each of them.

  This snapshot can then be used to generate diffs of the linking between jobs and their rules.



  Currently the tool is setup to take input of the following form:

  ```json
  [
      {
          "name": "job-name",
          "rules": [
              {
                  "if": "$CI_PIPELINE_SOURCE == 'push'"
              },
              {
                  "if": "$CI_PIPELINE_SOURCE == 'merge_request_event'",
                  "changes": [
                      "**/*.py"
                  ]
              },
          ]
      }
  ]
  ```

  This is easiest made using [gitlab-ci-local](https://github.com/firecow/gitlab-ci-local)

  With `node` installed, run `npx gitlab-ci-local --list-json > gitlab-ci-local.json` in a project directory with a `.gitlab-ci.yml` file.

  Then, run `ci-test gitlab rule-snapshot gitlab-ci-local.json` to create a collated snapshot.



  - Remove the dependency on `gitlab-ci-local`
  - Support GitHub configurations
  - Add more testing commands
  - Add better CLI
  - Add linting/formatting
  - Clean up for best practices



  Please see `CONTRIBUTING.md` for a head start.

  Pull requests welcome!


pkgId: 20769f886c7bc839ad618756b7ac9938926c40a13e7089a25cd3a6728c1fc6e9
name: python-ci-watson
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: CI helper for STScI Jenkins
url: https://github.com/spacetelescope/ci_watson
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ci-watson-0.7.0-1.src.rpm
checksum_type: sha256
description:
  [![CI Status](https://github.com/spacetelescope/ci_watson/workflows/CI/badge.svg)](https://github.com/spacetelescope/ci_watson/actions)
  [![Documentation Status](https://readthedocs.org/projects/ci-watson/badge/?version=latest)](https://ci-watson.readthedocs.io/en/latest/?badge=latest)

  CI helper for STScI Jenkins.
  If you ask nicely, it might also help you solve crimes.

  Nightly regression test results are available only from within the STScI
  network at this time.
  https://plwishmaster.stsci.edu:8081/job/RT/job/ci_watson/test_results_analyzer/



  With `pip`::

      pip install ci-watson


pkgId: 4c78597d16729b51dfda884098a847945c69618d430ebb0a9fe8972b074bcf6f
name: python-cialign
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: Toolkit for cleaning and interpreting multiple sequence alignments
url: https://github.com/KatyBrown/CIAlign
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cialign-1.1.4-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/KatyBrown/CIAlign/actions/workflows/main.yml/badge.svg)

  CIAlign documentation is now available via [ReadTheDocs](https://cialign.readthedocs.io/en/latest/)



  **Requirements**

  * python >= 3.6
  * matplotlib >= 2.1.1
  * numpy >= 1.16.3
  * scipy >= 1.3.0

  The easiest way to install CIAlign is using conda or pip3.

  **Conda**

  `conda install -c bioconda cialign`

  [link](https://anaconda.org/bioconda/cialign)

  **pip3**
  `pip3 install cialign`

  [link](https://pypi.org/project/cialign/)

  **Download**
  The current release of CIAlign can also be downloaded directly using [this link](https://github.com/KatyBrown/CIAlign/releases/latest),

  If you download the package directly, you will also need to add the CIAlign directory to your PATH environment variable as described [here](https://gist.github.com/nex3/c395b2f8fd4b02068be37c961301caa7)


  CIAlign allows the user to:


  **Clean**

  * Remove sources of noise from an MSA
    * Remove sequences above a threshold level percentage of divergence from the majority.
    * Remove insertions which are not present in the majority of sequences.
    * Crop poorly aligned  sequence ends.
    * Remove short sequences below a threshold number of bases or amino acids.
    * Remove columns containing only gaps.
    * Remove either end of an alignment where columns don't meet a minimum identity threshold and coverage level.

  **Visualise**

  * Visualise alignments.
    * Generate image files summarising the alignment.
    * Label these images to show how CIAlign has affected the alignment.
    * Draw sequence logos
    * Plot alignment statistics - visualise coverage and conservation at each position in the alignment.


  **Interpret**

  * Generate consensus sequences.
  * Generate position frequency, position probability and position weight matrices
  * Format these matrices to be used as input for the BLAMM and MEME motif analysis tools.
  * Generate a similarity matrix showing the percentage identity between each sequence pair.

  **Edit**

  * Extract a section of the alignment.
  * Unalign the alignment.
  * Replace U with T, or T with U in a nucleotide alignment.

  CIAlign is designed to be highly customisable, allowing users to specify exactly which functions to run and which settings to use.

  It is also transparent, generating a clear log file and alignment markup showing exactly how the alignment has changed and what has been removed by which function.


  If you found CIAlign useful, please cite:

  Tumescheit C, Firth AE, Brown K. 2022. CIAlign: A highly customisable command line tool to clean, interpret and visualise multiple sequence alignments. PeerJ 10:e12983 https://doi.org/10.7717/peerj.12983


  Sign up here for updates when a new feature is added to CIAlign


pkgId: 58eb467fc498c86a976ea17fa1ba895bc0d024291b359bb0e3cc7b9de573651b
name: python-cibuildwheel
arch: src
version: 2.21.1
epoch: 0
release: 1
summary: Build Python wheels on CI with minimal configuration.
url: https://github.com/pypa/cibuildwheel
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cibuildwheel-2.21.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cibuildwheel.svg)](https://pypi.python.org/pypi/cibuildwheel)
  [![Documentation Status](https://readthedocs.org/projects/cibuildwheel/badge/?version=stable)](https://cibuildwheel.pypa.io/en/stable/?badge=stable)
  [![Actions Status](https://github.com/pypa/cibuildwheel/workflows/Test/badge.svg)](https://github.com/pypa/cibuildwheel/actions)
  [![Travis Status](https://img.shields.io/travis/com/pypa/cibuildwheel/main?logo=travis)](https://travis-ci.com/pypa/cibuildwheel)
  [![Appveyor status](https://ci.appveyor.com/api/projects/status/gt3vwl88yt0y3hur/branch/main?svg=true)](https://ci.appveyor.com/project/joerick/cibuildwheel/branch/main)
  [![CircleCI Status](https://img.shields.io/circleci/build/gh/pypa/cibuildwheel/main?logo=circleci)](https://circleci.com/gh/pypa/cibuildwheel)
  [![Azure Status](https://dev.azure.com/joerick0429/cibuildwheel/_apis/build/status/pypa.cibuildwheel?branchName=main)](https://dev.azure.com/joerick0429/cibuildwheel/_build/latest?definitionId=4&branchName=main)
  [Documentation](https://cibuildwheel.pypa.io)
  <!--intro-start-->
  Python wheels are great. Building them across **Mac, Linux, Windows**, on **multiple versions of Python**, is not.
  `cibuildwheel` is here to help. `cibuildwheel` runs on your CI server - currently it supports GitHub Actions, Azure Pipelines, Travis CI, AppVeyor, CircleCI, and GitLab CI - and it builds and tests your wheels across all of your platforms.


pkgId: 63ecfbb4449a51be6b351691d223c7bf3ef21fc57b245d8daf628a53067d8f76
name: python-cibuildwheel
arch: src
version: 2.22.0
epoch: 0
release: 1
summary: Build Python wheels on CI with minimal configuration.
url: https://github.com/pypa/cibuildwheel
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cibuildwheel-2.22.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cibuildwheel.svg)](https://pypi.python.org/pypi/cibuildwheel)
  [![Documentation Status](https://readthedocs.org/projects/cibuildwheel/badge/?version=stable)](https://cibuildwheel.pypa.io/en/stable/?badge=stable)
  [![Actions Status](https://github.com/pypa/cibuildwheel/workflows/Test/badge.svg)](https://github.com/pypa/cibuildwheel/actions)
  [![Travis Status](https://img.shields.io/travis/com/pypa/cibuildwheel/main?logo=travis)](https://travis-ci.com/github/pypa/cibuildwheel)
  [![Appveyor status](https://ci.appveyor.com/api/projects/status/gt3vwl88yt0y3hur/branch/main?svg=true)](https://ci.appveyor.com/project/joerick/cibuildwheel/branch/main)
  [![CircleCI Status](https://img.shields.io/circleci/build/gh/pypa/cibuildwheel/main?logo=circleci)](https://circleci.com/gh/pypa/cibuildwheel)
  [![Azure Status](https://dev.azure.com/joerick0429/cibuildwheel/_apis/build/status/pypa.cibuildwheel?branchName=main)](https://dev.azure.com/joerick0429/cibuildwheel/_build/latest?definitionId=4&branchName=main)
  [Documentation](https://cibuildwheel.pypa.io)
  <!--intro-start-->
  Python wheels are great. Building them across **Mac, Linux, Windows**, on **multiple versions of Python**, is not.
  `cibuildwheel` is here to help. `cibuildwheel` runs on your CI server - currently it supports GitHub Actions, Azure Pipelines, Travis CI, AppVeyor, CircleCI, and GitLab CI - and it builds and tests your wheels across all of your platforms.


pkgId: a9dbb4d238b7a6e2d37e741452dd00e41f91ca22e96e60e45cacdb8f605c3732
name: python-cic-cli
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Generic cli tooling for the CIC token network
url: https://git.grassecon.net/cicnet/cic-cli
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cic-cli-0.5.5-1.src.rpm
checksum_type: sha256
description:
  [![Status](https://ci.grassecon.net/api/badges/cicnet/cic-cli/status.svg)](https://ci.grassecon.net/grassrootseconomics/cic)
  [![Version](https://img.shields.io/pypi/v/cic-cli?color=green)](https://pypi.org/project/cic/)

  CIC-CLI provides tooling to generate and publish metadata in relation to
  token deployments.

  ```shell
  pip install cic-cli[eth]
  ```


  First make sure that you edit the configs below to add your paths for `[auth]keyfile_path` and `[wallet]keyfile`
  The configs are located in `~/.config/cic/cli/config/`
  ```

  cic wizard ./somewhere -c ~/.config/cic/cli/config/docker


  cic wizard ./somewhere -c ~/.config/cic/cli/config/testnet
  ```

  Some of the concepts described below assume familiarity with base
  concepts of the CIC architecture. Please refer to the appropriate
  documentation for more information.

  To initialize a new token deployment for the EVM:

  ```shell
  cic init --target eth --name <token_name> --symbol <token_symbol> --precision <token_value_precision> <settings_folder>
  ```

  To automatically fill in settings detected in the network for the EVM:

  ```shell
  cic ext --registry <contract_registry_address> -d <settings_folder> -i <chain_spec> -p <rpc_endpoint> eth
  ```




  ![image](./doc/sphinx/components.svg)

  CIC-CLI is designed to interface any network type backend. The current
  state of the package contains interface to EVM only. Thus, the examples
  below are limited to the context of the EVM.



   - Install [poetry](https://python-poetry.org/docs/#installation)



  ```
   poetry install -E eth
  ```



  ```bash
   poetry run cic -h
  ```

  ```bash
   poetry run cic wizard ./somewhere -c ./config/docker
  ```

  - Export the accounts private key [Instructions](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key)
  - Save the private key to a file
  - Run `eth-keyfile -k <file> > ~/.config/cic/keystore/keyfile.json`


  <details>
  <summary>Install Kubectl</summary>

  ```bash
  sudo apt-get update
  sudo apt-get install -y apt-transport-https ca-certificates curl
  sudo curl -fsSLo /usr/share/keyrings/kubernetes-archive-keyring.gpg https://packages.cloud.google.com/apt/doc/apt-key.gpg
  echo "deb [signed-by=/usr/share/keyrings/kubernetes-archive-keyring.gpg] https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
  sudo apt-get update
  sudo apt-get install -y kubectl
  ```
  </details>

  - Download testnet cluster config from https://cloud.digitalocean.com/kubernetes/clusters
  - Move the config to `$HOME/.kube/`
  - Run `kubectl -n grassroots --kubeconfig=$HOME/.kube/<config_file_name>.yaml get pods`
  - Copy the name of the meta pod (e.g `cic-meta-server-67dc7c6468-8rhdq`)
  - Port foward the meta pod to the local machine using `kubectl port-forward pods/<name_of_meta_pod> 6700:8000 -n grassroots --kubeconfig=$HOME/.kube/<config_file_name>.yaml`
  - Clone this repository to your local machine
  - Run `poetry install -E eth` in the repo root
  - Open `./cic/config/testnet/config.ini` and change
    - [auth]keyfile_path
    - [wallet]key_file
  - Open a new terminal and run `poetry run cic wizard -c ./cic/config/testnet ./somewhere`


  ```
  poetry run pytest
  ```


pkgId: 24f38612cc6cdff15f847c93ac3219a894313919ac13a3e9f6baad483eed343f
name: python-cicflowmeter
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: CICFlowMeter Python Implementation
url: https://github.com/hieulw/cicflowmeter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cicflowmeter-0.2.0-1.src.rpm
checksum_type: sha256
description:
  > This project is not maintained actively by me. If you found something wrong (bugs, incorrect results) feel free to create issues or pull requests.



  ```sh
  git clone https://github.com/hieulw/cicflowmeter
  cd cicflowmeter
  poetry install
  ```



  ```sh
  usage: cicflowmeter [-h] (-i INPUT_INTERFACE | -f INPUT_FILE) (-c | -u) [--fields FIELDS] [-v] output

  positional arguments:
    output                output file name (in csv mode) or url (in url mode)

  options:
    -h, --help            show this help message and exit
    -i INPUT_INTERFACE, --interface INPUT_INTERFACE
                          capture online data from INPUT_INTERFACE
    -f INPUT_FILE, --file INPUT_FILE
                          capture offline data from INPUT_FILE
    -c, --csv             output flows as csv
    -u, --url             output flows as request to url
    --fields FIELDS       comma separated fields to include in output (default: all)
    -v, --verbose         more verbose
  ```

  Convert pcap file to flow csv:

  ```
  cicflowmeter -f example.pcap -c flows.csv
  ```

  Sniff packets real-time from interface to flow request: (**need root permission**)

  ```
  cicflowmeter -i eth0 -u http://localhost:8080/predict
  ```



  1. https://www.unb.ca/cic/research/applications.html#CICFlowMeter
  2. https://github.com/ahlashkari/CICFlowMeter


pkgId: 2abe4ffe9cb5b250951e44b3250604edd5bed6faf08d07016beb4a715a0b2da5
name: python-cici-tools
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Power tools for CI/CD.
url: https://pypi.org/project/cici-tools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cici-tools-0.7.0-1.src.rpm
checksum_type: sha256
description:
  <!-- BADGIE TIME -->

  [![pipeline status](https://img.shields.io/gitlab/pipeline-status/buildgarden/tools/cici-tools?branch=main)](https://gitlab.com/buildgarden/tools/cici-tools/-/commits/main)
  [![coverage report](https://img.shields.io/gitlab/pipeline-coverage/buildgarden/tools/cici-tools?branch=main)](https://gitlab.com/buildgarden/tools/cici-tools/-/commits/main)
  [![latest release](https://img.shields.io/gitlab/v/release/buildgarden/tools/cici-tools)](https://gitlab.com/buildgarden/tools/cici-tools/-/releases)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)](https://github.com/pre-commit/pre-commit)
  [![code style: black](https://img.shields.io/badge/code_style-black-000000.svg)](https://github.com/psf/black)
  [![imports: isort](https://img.shields.io/badge/imports-isort-1674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![Checked with mypy](https://img.shields.io/badge/mypy-checked-2a6db2)](https://mypy-lang.org/)
  [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://github.com/prettier/prettier)

  <!-- END BADGIE TIME -->

  Power tools for CI/CD.

  > Do not use this software unless you are an active collaborator on the
  > associated research project.
  >
  > This project is an output of an ongoing, active research project. It is
  > published without warranty, is subject to change at any time, and has not been
  > certified, tested, assessed, or otherwise assured of safety by any person or
  > organization. Use at your own risk.





  Flatten `extends` keywords to make zero-dependency GitLab CI/CD files.

  ```bash
  cici bundle
  ```

  ```console
  $ cici bundle
  ⚡ python-autoflake.yml
  ⚡ python-black.yml
  ⚡ python-build-sdist.yml
  ⚡ python-build-wheel.yml
  ⚡ python-import-linter.yml
  ⚡ python-isort.yml
  ⚡ python-mypy.yml
  ⚡ python-pyroma.yml
  ⚡ python-pytest.yml
  ⚡ python-setuptools-bdist-wheel.yml
  ⚡ python-setuptools-sdist.yml
  ⚡ python-twine-upload.yml
  ⚡ python-vulture.yml
  ```



  Normalize the style of your GitLab CI/CD files:

  ```bash
  cici fmt
  ```

  ```console
  $ cici fmt
  .gitlab-ci.yml formatted
  ```



  Update to the latest GitLab CI/CD `include` versions available.

  ```bash
  cici update
  ```

  ```console
  $ cici update
  updated buildgarden/pipelines/python to 0.5.1
  updated buildgarden/pipelines/gitlab from 0.1.0 to 0.2.2
  ```


pkgId: cabec3ae9792ad36cca18ad0652e80aaa39857adc9ae440fc84a08c8d8364ca5
name: python-cico-tunnel
arch: src
version: 1.1.5
epoch: 0
release: 1
summary: Expose your localhost to the web. Like a Ngrok
url: https://github.com/hugosantoslisboa/cico-tunnel
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cico-tunnel-1.1.5-1.src.rpm
checksum_type: sha256
description:
  O **Cicotunnel** é uma ferramenta que utiliza SSH para expor portas locais para a internet de forma segura e fácil. Com o Cico Tunnel, você pode criar um túnel SSH para acessar seu servidor local a partir de qualquer lugar.



  Antes de começar, certifique-se de que você possui:

  1. **Acesso SSH**: Você precisa de um servidor SSH ao qual você tenha acesso e permissão para criar túneis.
     * Você pode usar seu próprio servidor, mas precisará:
        - Criar um usuário SSH.
        - Permitir login sem senha.
        - Permitir o forwarding e o gateway.
     * Ou você pode usar o servidor fornecido pelo Cico Tunnel para um acesso rápido.

  2. **Python**: Certifique-se de que o Python está instalado no seu sistema. Você pode baixar a versão mais recente do Python em [python.org](https://www.python.org/).

  3. **Acesso à Internet**: É necessário para criar o túnel SSH e acessar o servidor.



  1. **Instale via pip**:

     ```bash
     pip install cico-tunnel
     ```



  Para usar o Cico Tunnel, siga estas etapas:

  1. **Execute o comando `cicotunnel`, passando a porta local que deseja expor**:

     ```bash
     cicotunnel 80
     ```

     Isso irá iniciar o Cico Tunnel e criar um túnel para a porta 80 do seu localhost.
     Se você quiser usar um servidor SSH diferente do padrão, use a flag `-r` ou `--remote` seguido do endereço do seu servidor. Por exemplo:

     ```bash
     cicotunnel 80 -r usuario@meu.servidor.com
     ```

  2. **Visualize a URL**:
     O Cico Tunnel exibirá a URL pública para o seu servidor local através do túnel SSH no terminal. Use essa URL para acessar seu servidor local de qualquer lugar na internet.



  * Expor a porta do MySQL do localhost no cicotunnel:

    ```bash
    cicotunnel 3306
    ```

  * Expor a porta do MySQL do localhost utilizando um servidor SSH específico:

    ```bash
    cicotunnel 3306 -r usuario@meu.servidor.com
    ```




  Sinta-se à vontade para contribuir com o projeto! Você pode fazer isso de várias maneiras:

  - **Dar Estrelas**: Se você gostou do Cicotunnel e acha que ele é útil, considere dar uma estrela ⭐ no [repositório](https://github.com/hugosantoslisboa/cico-tunnel). Isso ajuda a apoiar o projeto e mostra que você aprecia o trabalho!

  - **Relatar Problemas**: Se você encontrar algum problema ou bug, por favor, abra uma [issue](https://github.com/hugosantoslisboa/cico-tunnel/issues) no repositório.

  - **Enviar Pull Requests**: Se você tem melhorias ou correções, envie um pull request para o repositório.

  - **Feedback**: Qualquer feedback é bem-vindo para ajudar a melhorar o Cico Tunnel.


pkgId: c97a9452be6abca18cb2f029e83564e0e21e8945c265fce9eb854cffb943dd76
name: python-cicsim
arch: src
version: 0.1.13
epoch: 0
release: 1
summary: Custom IC Creator Simulation Tools
url: https://github.com/wulffern/cicsim
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cicsim-0.1.13-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/wulffern/cicsim/actions/workflows/main.yml/badge.svg)](https://github.com/wulffern/cicsim/actions/workflows/main.yml)



  This is a script package I use to control ngspice, it can

  - Run corner simulations
  - Create IPs (used in  [wulffern/aicex](https://github.com/wulffern/aicex) )
  - Create simulation directories
  - View waveforms



  | Version | Comment                                         |
  |:--------|:------------------------------------------------|
  | 0.0.1   | First version of cicsim                         |
  | 0.0.3   | All in on open source tools                     |
  | 0.1.2   | First version on pipy                           |
  | 0.1.3   | github action update                            |
  | 0.1.4   | Added waveform viewer                           |
  | 0.1.5   | Update waveform viewer                          |
  | 0.1.6   | wave: added search. Added docs                  |
  | 0.1.7   | Bugfix: ngraw deprecated float_                 |
  | 0.1.8   | Added template command                          |
  | 0.1.9   | Bugfix: allow absolute path in template command |
  | 0.1.11  | Added directory name option (dname) to template |
  | 0.1.12  | Added sndrfs and enobfs to fftWithHanning       |







  If you want to follow the latest and greatest
  ``` sh
  git clone https://github.com/wulffern/cicsim
  cd cicsim
  python3 -m pip install --user -e .
  ```

  If you want the latest stable

  ``` bash
  python3 -m pip install cicsim
  ```


  Head over to [Open source analog integrated circuit flow on Skywater
  130nm](https://analogicus.com/rply_ex0_sky130nm/tutorial) to see cicsim in action.



  Make sure you install a python version with tk. On my mac it was

  ``` bash
  brew install python-tk
  ```

  Once installed, I do

  ``` bash
  cicsim wave output_tran/tran_SchGtTtKffVh_*
  ```

  ![](wave.png)




  ```
  Usage: cicsim [OPTIONS] COMMAND [ARGS]...

    Custom IC Creator Simulator Tools

    This package provides helper scripts for simulating integrated circuits

  Options:
    --help  Show this message and exit.

  Commands:
    plot         Plot from rawfile
    portreplace  Replace ${PORTS} and ${VPORTS} with the subcircuit ports...
    results      Results of single runfile
    run          Run a ngspice simulation of TESTBENCH
    simcell      Create a ngspice simulation directory for a Cell
    srun         Run a spectre simulation of TESTBENCH
    summary      Generate simulation summary for results
    wave         Open waveform viewer
  ```


pkgId: c837f60d21bb34e89bc3e9a884c3050434d9294efc737977d0d186e3adad3a78
name: python-cid-cmd
arch: src
version: 0.3.13
epoch: 0
release: 1
summary: Cloud Intelligence Dashboards deployment helper tool
url: https://github.com/aws-samples/aws-cudos-framework-deployment
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cid-cmd-0.3.13-1.src.rpm
checksum_type: sha256
description:
  | Dashboard documentation | Demo URL | Prerequisites URL |
  | --- | --- | --- |
  | [CUDOS Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi#cudos-dashboard) | [demo](https://cid.workshops.aws.dev/demo?dashboard=cudos) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [Cost Intelligence Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi#cost-intelligence-dashboard-(cid)) | [demo](https://cid.workshops.aws.dev/demo?dashboard=cost_intelligence_dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [Trusted Advisor Organisation (TAO) Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/trusted-advisor) | [demo](https://cid.workshops.aws.dev/demo?dashboard=tao-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/trusted-advisor/prerequisites) |
  | [Trends Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/additional/trends) | [demo](https://cid.workshops.aws.dev/demo?dashboard=trends-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [KPI Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi#kpi-dashboard) | [demo](https://cid.workshops.aws.dev/demo?dashboard=kpi) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [Compute Optimizer Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/compute-optimizer) | [demo](https://cid.workshops.aws.dev/demo?dashboard=compute-optimizer-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/compute-optimizer/prerequisites) |
  | [Cost Anomaly Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/cost-anomaly) | [demo](https://cid.workshops.aws.dev/demo?dashboard=aws-cost-anomalies) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/cost-anomaly/prerequisites) |
  | [Data Transfer Cost Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/additional/data-transfer) | [demo](https://cid.workshops.aws.dev/demo?dashboard=datatransfer-cost-analysis-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [AWS Budgets Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/aws-budgets) | [demo](https://cid.workshops.aws.dev/demo?dashboard=aws-budgets) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/aws-budgets#deploy-via-cid-tool) |
  See more dashboards on the [workshop page](https://catalog.workshops.aws/awscid/en-US/dashboards).

  1. :heavy_exclamation_mark: Complete the prerequisites for respective dashboard (see above).
  2. :heavy_exclamation_mark: [Specifying a Query Result Location Using a Workgroup](https://docs.aws.amazon.com/athena/latest/ug/querying.html#query-results-specify-location-workgroup)
  3. :heavy_exclamation_mark: Make sure QuickSight [Enterprise edition](https://aws.amazon.com/premiumsupport/knowledge-center/quicksight-enterprise-account/) is activated.


     [![asciicast](https://asciinema.org/a/467770.svg)](https://asciinema.org/a/467770)

  1. Launch [AWS CloudShell](https://console.aws.amazon.com/cloudshell/home) or your local shell
      Automation requires Python 3
  2. Make sure you have the latest pip package installed
      ```bash
      python3 -m ensurepip --upgrade
      ```
  4. Install CID Python automation PyPI package
      ```bash
      pip3 install --upgrade cid-cmd
      ```

  ```bash
  cid-cmd deploy
  ```

  Update only Dashboard
  ```bash
  cid-cmd update
  ```
  Update dashboard and all dependencies (Datasets and Athena View). WARNING: this will override any customization of SQL files and Datasets.
  ```bash
  cid-cmd update --force --recursive
  ```

  Show dashboards status
  ```bash
  cid-cmd status
  ```
  [<img width="558" alt="status" src="https://github.com/aws-samples/aws-cudos-framework-deployment/assets/82834333/cae2015f-0f81-4593-80b3-c67ec1200fcd">](https://www.youtube.com/watch?v=ivr1MoGaApM)

  ```bash
  cid-cmd share
  ```

  One time action to initialize Amazon QuickSight Enterprise Edition.
  ```bash
  cid-cmd init-qs
  ```

  One time action to initialize Athena table and Crawler from s3 with CUR data.
  ```bash
  cid-cmd init-cur
  ```

  Delete Dashboards and all dependencies unused by other CID-managed dashboards.(including QuickSight datasets, Athena views and tables)
  ```bash
  cid-cmd delete
  ```

  ```
   --dashboard-id TEXT QuickSight dashboard id
   --athena-database TEXT Athena database
   ```

  The command `export` lets you download or share a customized dashboard with another AWS Account. It takes the QuickSight Analysis as an input and generates all the assets needed to deploy your Analysis into another AWS Account. This command will generate a yaml file with a description of the Dashboard and all required Datasets. Also this command generates a QuickSight Template in the current AWS Account that can be used for Dashboard deployment in other accounts. The resource file can be used with all other cid commands. Both accounts must have relevant Athena Views and Tables.
  Export from account A:
  ```
  cid-cmd export
  ```
  Deployment to account B:
  ```
  cid-cmd deploy --resources ./mydashboard.yaml
  ```

  ```
  cid-cmd --help
  ```

  Generate and SQL file for Athena View for CSV file
  ```
  cid-cmd csv2view --input my_mapping.csv --name my_mapping
  ```
  This command generates a SQL file that you can execute. Please mind [Athena Service Limit for Query Size](https://docs.aws.amazon.com/athena/latest/ug/service-limits.html#service-limits-query-string-length).

  CID is also provided in a form of CloudFormation templates. See detailed instructions in the [Well Architected Labs](https://wellarchitectedlabs.com/cost/200_labs/200_cloud_intelligence/cost-usage-report-dashboards/dashboards/deploy_dashboards/) site.

  CID offers a set of Terraform modules to deploy CUR replication and CID dashboards. Refer to these [deployment instructions](terraform-modules/README.md) for details of
  how to deploy CID dashboards with these modules.
    1. Create a bucket for consolidating CUR [terraform-modules/cur-setup-destination/](terraform-modules/cur-setup-destination/)
    2. Create a CUR in Payer Account(s) [terraform-modules/cur-setup-source/](terraform-modules/cur-setup-source/)
    3. Create Dashboards (wrapper around CloudFormation) [terraform-modules/cid-dashboards/](terraform-modules/cid-dashboards/)

  The ownership of CID is usually with the FinOps team, who do not have administrative access. However, they require specific privileges to install and operate CID dashboards. To assist the Admin team in granting the necessary privileges to the CID owners, a CFN template is provided. This template, located at [CFN template](cfn-templates/cid-admin-policies.yaml), takes an IAM role name as a parameter and adds the required policies to the role.

  If you experience unexpected behaviour of the `cid-cmd` script please run `cid-cmd` in debug mode:
  ```bash
  cid-cmd -vv [command]
  ```
  This will produce a log file in the same directory that were at the tile of launch of cid-cmd.
  We encourage you to open [new issue](https://github.com/aws-samples/aws-cudos-framework-deployment/issues/new) with description of the problem and attached debug log file.


pkgId: 27707f43f2b2e3fd3124f5cfb06ae2aa0986a0f374c48489f8c2c7359e437e08
name: python-cid-cmd
arch: src
version: 4.0.5
epoch: 0
release: 1
summary: Cloud Intelligence Dashboards deployment helper tool
url: https://github.com/aws-samples/aws-cudos-framework-deployment
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cid-cmd-4.0.5-1.src.rpm
checksum_type: sha256
description:
  | Dashboard documentation | Demo URL | Prerequisites URL |
  | --- | --- | --- |
  | [CUDOS Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi#cudos-dashboard) | [demo](https://cid.workshops.aws.dev/demo?dashboard=cudos) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [Cost Intelligence Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi#cost-intelligence-dashboard-(cid)) | [demo](https://cid.workshops.aws.dev/demo?dashboard=cost_intelligence_dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [Trusted Advisor Organisation (TAO) Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/trusted-advisor) | [demo](https://cid.workshops.aws.dev/demo?dashboard=tao-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/trusted-advisor/prerequisites) |
  | [Trends Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/additional/trends) | [demo](https://cid.workshops.aws.dev/demo?dashboard=trends-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [KPI Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi#kpi-dashboard) | [demo](https://cid.workshops.aws.dev/demo?dashboard=kpi) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [Compute Optimizer Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/compute-optimizer) | [demo](https://cid.workshops.aws.dev/demo?dashboard=compute-optimizer-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/compute-optimizer/prerequisites) |
  | [Cost Anomaly Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/cost-anomaly) | [demo](https://cid.workshops.aws.dev/demo?dashboard=aws-cost-anomalies) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/cost-anomaly/prerequisites) |
  | [Data Transfer Cost Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/additional/data-transfer) | [demo](https://cid.workshops.aws.dev/demo?dashboard=datatransfer-cost-analysis-dashboard) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/foundational/cudos-cid-kpi/deploy) (Steps 1 and 2) |
  | [AWS Budgets Dashboard](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/aws-budgets) | [demo](https://cid.workshops.aws.dev/demo?dashboard=aws-budgets) | [link](https://catalog.workshops.aws/awscid/en-US/dashboards/advanced/aws-budgets#deploy-via-cid-tool) |
  See more dashboards on the [workshop page](https://catalog.workshops.aws/awscid/en-US/dashboards).

  1. :heavy_exclamation_mark: Complete the prerequisites for respective dashboard (see above).
  2. :heavy_exclamation_mark: [Specifying a Query Result Location Using a Workgroup](https://docs.aws.amazon.com/athena/latest/ug/querying.html#query-results-specify-location-workgroup)
  3. :heavy_exclamation_mark: Make sure QuickSight [Enterprise edition](https://aws.amazon.com/premiumsupport/knowledge-center/quicksight-enterprise-account/) is activated.


     [![asciicast](https://asciinema.org/a/467770.svg)](https://asciinema.org/a/467770)

  1. Launch [AWS CloudShell](https://console.aws.amazon.com/cloudshell/home) or your local shell
      Automation requires Python 3
  2. Make sure you have the latest pip package installed
      ```bash
      python3 -m ensurepip --upgrade
      ```
  4. Install CID Python automation PyPI package
      ```bash
      pip3 install --upgrade cid-cmd
      ```

  ```bash
  cid-cmd deploy
  ```

  Update only Dashboard
  ```bash
  cid-cmd update
  ```
  Update dashboard and all dependencies (Datasets and Athena View). WARNING: this will override any customization of SQL files and Datasets.
  ```bash
  cid-cmd update --force --recursive
  ```

  Show dashboards status
  ```bash
  cid-cmd status
  ```
  [<img width="558" alt="status" src="https://github.com/aws-samples/aws-cudos-framework-deployment/assets/82834333/cae2015f-0f81-4593-80b3-c67ec1200fcd">](https://www.youtube.com/watch?v=ivr1MoGaApM)

  ```bash
  cid-cmd share
  ```

  One time action to initialize Amazon QuickSight Enterprise Edition.
  ```bash
  cid-cmd init-qs
  ```

  One time action to initialize Athena table and Crawler from s3 with CUR data. Currently only CUR1 supported.
  ```bash
  cid-cmd init-cur
  ```

  There are 2 CUR formats that `cid-cmd` supports. CUR1 and CUR2 have slightly different fields structure. Each dashboard can be developed using CUR2 or CUR1, but on installation `cid-cmd` will deploy a special Athena View "CUR proxy". This View will play a role of compatibility layer between the CUR version used by Dashboard and available CUR. This View can be extended as new dashboard request CUR fields.
  Please note that Cost Allocation Tags and Cost Categories are not present in CUR Proxy by default. You will need to add these fields by modifying CUR Proxy in Athena or using `cid-cmd` tool:
  For CUR2 proxy (using CUR1 data as source)
  ```bash
  cid-cmd create-cur-proxy -vv \
     --cur-version '2' \
     --cur-table-name 'mycur1' \
     --athena-workgroup 'primary' \
     --fields "resource_tags['user_cost_center'],resource_tags['user_owner']"
  ```
  For CUR1 proxy (using CUR2 data as source)
  ```bash
  cid-cmd create-cur-proxy -vv \
     --cur-version '1' \
     --cur-table-name 'mycur2' \
     --athena-workgroup 'primary' \
     --fields "resource_tags_user_cost_center,resource_tags_user_owner"
  ```

  Delete Dashboards and all dependencies unused by other CID-managed dashboards.(including QuickSight datasets, Athena views and tables)
  ```bash
  cid-cmd delete
  ```

  ```
   --dashboard-id TEXT QuickSight dashboard id
   --athena-database TEXT Athena database
   ```

  The command `export` lets you download or share a customized dashboard with another AWS Account. It takes the QuickSight Analysis as an input and generates all the assets needed to deploy your Analysis into another AWS Account. This command will generate a yaml file with a description of the Dashboard and all required Datasets. Also this command generates a QuickSight Template in the current AWS Account that can be used for Dashboard deployment in other accounts. The resource file can be used with all other cid commands. Both accounts must have relevant Athena Views and Tables.
  Export from account A:
  ```
  cid-cmd export
  ```
  Deployment to account B:
  ```
  cid-cmd deploy --resources ./mydashboard.yaml
  ```

  ```
  cid-cmd --help
  ```

  Generate and SQL file for Athena View for CSV file
  ```
  cid-cmd csv2view --input my_mapping.csv --name my_mapping
  ```
  This command generates a SQL file that you can execute. Please mind [Athena Service Limit for Query Size](https://docs.aws.amazon.com/athena/latest/ug/service-limits.html#service-limits-query-string-length).

  CID is also provided in a form of CloudFormation templates. See detailed instructions in the [Well Architected Labs](https://wellarchitectedlabs.com/cost/200_labs/200_cloud_intelligence/cost-usage-report-dashboards/dashboards/deploy_dashboards/) site.

  CID offers a set of Terraform modules to deploy CUR replication and CID dashboards. Refer to these [deployment instructions](terraform-modules/README.md) for details of
  how to deploy CID dashboards with these modules.
    1. Create a bucket for consolidating CUR [terraform-modules/cur-setup-destination/](terraform-modules/cur-setup-destination/)
    2. Create a CUR in Payer Account(s) [terraform-modules/cur-setup-source/](terraform-modules/cur-setup-source/)
    3. Create Dashboards (wrapper around CloudFormation) [terraform-modules/cid-dashboards/](terraform-modules/cid-dashboards/)

  The ownership of CID is usually with the FinOps team, who do not have administrative access. However, they require specific privileges to install and operate CID dashboards. To assist the Admin team in granting the necessary privileges to the CID owners, a CFN template is provided. This template, located at [CFN template](cfn-templates/cid-admin-policies.yaml), takes an IAM role name as a parameter and adds the required policies to the role.

  If you experience unexpected behaviour of the `cid-cmd` script please run `cid-cmd` in debug mode:
  ```bash
  cid-cmd -vv [command]
  ```
  This will produce a log file in the same directory that were at the tile of launch of cid-cmd.
  We encourage you to open [new issue](https://github.com/aws-samples/aws-cudos-framework-deployment/issues/new) with description of the problem and attached debug log file.


pkgId: 40c906a4b18903fd777600ff7e15b72be598571620e6773b5ed1292b865d2b74
name: python-cidc-cli
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: A command-line interface for interacting with the CIDC.
url: https://pypi.org/project/cidc-cli/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cidc-cli-0.10.2-1.src.rpm
checksum_type: sha256
description:
  | Branch | Status                                                                                                                       | License                                                                                                     |
  | ------ | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
  | Master | ![Continuous Integration](https://github.com/CIMAC-CIDC/cidc-cli/workflows/Continuous%20Integration/badge.svg?branch=master) | [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) |



  Command line tool for interfacing with the CIDC API.





  ```bash
  pip3 install cidc-cli
  ```



  To display the help message for the CLI, run:

  ```bash
  cidc
  ```

  To authenticate with the CIDC API, run:

  ```bash
  cidc login [token]
  ```



  For local development, first install the development dependencies:

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

  Then, install and configure the pre-commit hooks:

  ```bash
  pre-commit install
  ```



  To set-up the git hook for JIRA integration, run:

  ```bash
  ln -s ../../.githooks/commit-msg .git/hooks/commit-msg
  chmod +x .git/hooks/commit-msg
  rm .git/hooks/commit-msg.sample
  ```

  This symbolic link is necessary to correctly link files in `.githooks` to `.git/hooks`. Note that setting the `core.hooksPath` configuration variable would lead to [pre-commit failing](https://github.com/pre-commit/pre-commit/issues/1198). The `commit-msg` hook [runs after](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) the `pre-commit` hook, hence the two are de-coupled in this workflow.

  To associate a commit with an issue, you will need to reference the JIRA Issue key (For eg 'CIDC-1111') in the corresponding commit message.



  Under the (hidden) `admin` are several functions meant for CIDC administators / engineers.



  ```bash
  cidc admin test-csms
  ```

  A simple API hit for a test of CSMS connection. Hits API endpoint `/admin/test_csms` which in turn gets CSMS's `/docs`.
  This tests that the API is able to successfully make connection with the CSMS, as the `/docs` endpoint requires authorization.
  As the API endpoint is protected, only users with role `cidc-admin` can make this request.



  A set of commands to list / remove data from the database, including shipments, clinical data, and assay/analysis data.
  It directly uses Google's cloud SDK to make a direct connection to the postgres cloud sql database, so it requires the user has `cloudsql.instances.connect` IAM permission.



  Authentication uses Application Default Credentials (ADC). Log-in is done via:

  ```bash
  gcloud auth application-default login
  ```



  Configuration of the environment ie staging versus production is done as above using:

  ```bash
  cidc config get-env
  cidc config set-env ENV
  ```

  Configuration of the database username is done via a pair of functions:

  ```bash
  cidc admin get-username
  cidc admin set-username USERNAME
  ```

  The password is requested every time you issue a command so as to not store it.



  Under the `list` subcommand of `cidc admin`, you can get descriptions of the data available in the database.

  - `cidc admin list clinical TRIAL_ID`
    - prints a table describing all shipments for the given trial
    - with the following columns:
      - `object_url`, `filename`, `num_participants`, `created`, `comment`

  - `cidc admin list misc-data TRIAL_ID`
    - prints a table describing all misc_data files for the given trial
    - with the following columns:
      - `batch_id`, `object_url`, `filename`, `created`, `description`

  - `cidc admin list shipments TRIAL_ID`
    - prints a table describing all shipments for the given trial
    - with the following columns:
      - `upload_type`, `manifest_id`, `num_samples`, `created`

  - `cidc admin list assay TRIAL_ID ASSAY_OR_ANALYSIS`
    - prints a table listing all samples for the given assay/analysis and trial
    - any of the following values are allowed:
      - `clinical_data`, same as `cidc admin list clinical TRIAL_ID`
      - `misc_data`, same as `cidc admin list misc-data TRIAL_ID`
      - analyses: `atacseq_analysis`, `ctdna_analysis`, `cytof_analysis`, `microbiome_analysis`, `rna_level1_analysis`, `tcr_analysis`, `wes_analysis`, `wes_analysis_old`, `wes_tumor_only_analysis`, `wes_tumor_only_analysis_old`
      - assays: `atacseq`, `ctdna`, `cytof`, `hande`, `ihc`, `elisa`, `microbiome`, `mif`, `nanostring`, `olink`, `rna`, `tcr`, `wes`



  Under the `remove` subcommand of `cidc admin`, you can remove a wide variety of data from the JSON blobs.

  - `cidc admin remove clinical TRIAL_ID TARGET_ID`
    - removes a given clinical data file from a given trial's metadata as well as the file itself from the portal
    - `TARGET_ID` is the `filename` of the clinical data to remove, as from `cidc admin list clinical TRIAL_ID`
      - special value `'*'` for all files for this trial

  - `cidc admin remove shipment TRIAL_ID TARGET_ID`
    - removes a given shipment from a given trial's metadata
    - `TARGET_ID` is the `manifest_id` of the shipment to remove, as from `cidc admin list shipments TRIAL_ID`

  - `cidc admin remove assay TRIAL_ID ASSAY_OR_ANALYSIS TARGET_ID`
    - removes a given clinical data file from a given trial's metadata as well as the associated files themselves from the portal
    - for `ASSAY_OR_ANALYSIS=clinical_data`, same as `cidc admin remove clinical TRIAL_ID TARGET_ID`
    - `TARGET_ID` is a tuple of the ids to find the data to remove, as from `cidc admin list assay TRIAL_ID ASSAY_OR_ANALYSIS`.
      - It cannot go past where is divisible in the data, but can end early to remove the whole section.
      - Namely:
        - `elisa`: requires only `assay_run_id`
        - `misc_data`, `olink`: require `batch_id` with an optional `filename`
        - `nanostring`: requires `batch_id` and optional `run_id`
        - `rna_level1_analysis`, `wes_tumor_only_analysis`,  `wes_tumor_only_analysis_old`: requires only `cimac_id`
        - `wes_analysis`, `wes_analysis_old`: requires only `run_id`
        - otherwise: requires `batch_id` and optional `cimac_id`


pkgId: 71dedec4f33a0bfcd38dd6d23fed690a81b35b5f5e8b473316c147619c3772b9
name: python-cidc-ngs-pipeline-api
arch: src
version: 0.1.24
epoch: 0
release: 1
summary: The CIDC NGS Pipeline output APIs
url: https://github.com/CIMAC-CIDC/cidc-ngs-pipeline-api
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cidc-ngs-pipeline-api-0.1.24-1.src.rpm
checksum_type: sha256
description:
  ![Continuous Integration](https://github.com/CIMAC-CIDC/cidc-ngs-pipeline-api/workflows/Continuous%20Integration/badge.svg?branch=master)  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)


  This repository serves as an interface between the CIDC and Bioinformatics teams to determine specifications and documentation related to NGS pipelines.

  Repository structure:
  ```
  .
  ├── README.md
  ├── cidc_ngs_pipeline_api
  │   ├── output_API.schema.json
  │   ├── rna
  │   │   ├── rna.md
  │   │   ├── rna_config.schema.json
  │   │   ├── rna_output_API.json
  │   │   └── imgs
  │   |       └── RIMA.png
  │   ├── atacseq
  │   │   ├── atacseq.md
  │   │   ├── atacseq_output_API.json
  │   │   └── imgs
  │   |       └── atacseq.png
  │   ├── tcr
  │   │   ├── tcr.md
  │   │   └── imgs
  │   |       └── TCRseq.png
  │   └── wes
  │       ├── wes.md
  │       ├── wes_config.schema.json
  │       ├── wes_output_API.json
  │       ├── wes_tumor_only_output_API.json
  │       ├── wes_output_API.py
  │       └── imgs
  │          └── wes.png
  ├── tests
  │   └── test_apis.py
  ├── requirements.dev.txt
  ├── requirements.txt
  ├── MANIFEST.in
  ├── CHANGELOG.md
  ├── setup.py
  └── .github
      └── workflows
         └── ci.yml

  ```



  * The `output_API.schema.json` file defines the schema structure:
      - `filter_group`: Filter under which the file would appear during faceted search. It is the GCS-URI top-level hierarchy
      - `file_path_template`: Local file path used for CLI upload
      - `short_description`: Description to appear on hovering over file name in file browser
      - `long_description`: Longer description to appear on file documentation page
      - `file_purpose`: Assigns a tag to show up in a particular file-browser view configuration. Permissible values: `Source view`, `Analysis view`, `Clinical view`, `Miscellaneous`

  * Within the directory for each assay:

      * The defined schema is used to structure information about pipeline-related files in the respective  `< assay >_output_API.json`.

      * Information related to YAML configurations (which are generated by the CIDC and configured with CIMAC IDs to run the pipelines), are described in the respective `< assay > config.schema.json`.

      * Documentation related to each pipeline is in the respective `< assay > .md`.



  Install necessary dependencies.

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

  Install and configure pre-commit hooks.

  ```bash
  pre-commit install
  ```


pkgId: bb50a2ffb3a69d8dc8b07eee1a706cf5c8337c10f49464db08c2af4d5ff52bf8
name: python-cidc-schemas
arch: src
version: 0.26.23
epoch: 0
release: 1
summary: The CIDC data model and tools for working with it.
url: https://github.com/CIMAC-CIDC/schemas
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cidc-schemas-0.26.23-1.src.rpm
checksum_type: sha256
description:
  | Branch                                               | Status                                                                                                                           | Maintainability                                                                                                                                                          | Test Coverage                                                                                                                                                      | Code Style                                                                                                                                |
  | ---------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
  | [master](https://cimac-cidc.github.io/cidc-schemas/) | ![Continuous Integration](https://github.com/CIMAC-CIDC/cidc-schemas/workflows/Continuous%20Integration/badge.svg?branch=master) | [![Maintainability](https://api.codeclimate.com/v1/badges/3f989b974663df81ef45/maintainability)](https://codeclimate.com/github/CIMAC-CIDC/cidc-schemas/maintainability) | [![Test Coverage](https://api.codeclimate.com/v1/badges/3f989b974663df81ef45/test_coverage)](https://codeclimate.com/github/CIMAC-CIDC/cidc-schemas/test_coverage) | <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a> |

  This repository contains formal definitions of the CIDC metadata model using [json-schema](https://json-schema.org/) syntax and vocabulary.





  To install the latest released version, run:

  ```bash
  pip install cidc-schemas
  ```





  - **`cidc_schemas/`** - a python module for generating, validating, and reading manifest and assay templates.
    - **`schemas/`** - json specifications defining the CIDC metadata model.
      - `templates/` - schemas for generating and validating manifest and assay templates.
      - `assays/` - schemas for defining assay data models.
      - `artifacts/` - schemas for defining artifacts.
  - **`docs/`** - the most recent build of the data model documentation, along with templates and scripts for re-generating the documentation.
  - **`template_examples/`** - example populated Excel files for template specifications in `schemas/templates`, and `.csv`s auto-generated from those `.xlsx`s that allow to transparently keep track of changes in them.
  - **`tests/`** - tests for the `cidc_schemas` module.
  - **`.githooks/`** - git hooks, e.g. for auto-generating `.csv`s in `template_examples/` and `.html` documentation files.



  Install necessary dependencies.

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

  Install and configure pre-commit hooks.

  ```bash
  pre-commit install
  ```



  To set-up the git hook for JIRA integration, run:

  ```bash
  ln -s ../../.githooks/commit-msg .git/hooks/commit-msg
  chmod +x .git/hooks/commit-msg
  rm .git/hooks/commit-msg.sample
  ```

  This symbolic link is necessary to correctly link files in `.githooks` to `.git/hooks`. Note that setting the `core.hooksPath` configuration variable would lead to [pre-commit failing](https://github.com/pre-commit/pre-commit/issues/1198). The `commit-msg` hook [runs after](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) the `pre-commit` hook, hence the two are de-coupled in this workflow.

  To associate a commit with an issue, you will need to reference the JIRA Issue key (For eg 'CIDC-1111') in the corresponding commit message.




  This repository has unit tests in the _tests_ folder. After installing dependencies
  the tests can be run via the command

  ```bash
  pytest tests
  ```



  Pre-commit hooks ensure documentation is automatically up-to date. To build the documentation manually, run the following commands:

  ```bash
  python setup.py install # install helpers from the cidc_schemas library
  python docs/generate_docs.py
  ```

  This will output the generated html documents in `docs/docs`. If the updated docs are pushed up and merged into master, they will be viewable at https://cimac-cidc.github.io/cidc-schemas/.



  This project comes with a command-line interface for validating schemas and generating/validating assay and manifest templates.



  Clone the repository and cd into it

  ```bash
  git clone git@github.com:CIMAC-CIDC/cidc-schemas.git
  cd cidc-schemas
  ```

  Install the `cidc_schemas` package (this adds the `cidc_schemas` CLI to your console)

  ```bash
  python setup.py install
  ```

  Run `cidc_schemas --help` to see available options.

  If you're making changes to the module and want those changes to be reflected in the CLI without reinstalling the `cidc_schemas` module every time, run

  ```bash
  python3 -m cidc_schemas.cli [args]
  ```



  Create a template for a given template configuration.

  ```bash
  cidc_schemas generate_template -m templates/manifests/pbmc_template.json -o pbmc.xlsx
  ```



  Check that a populated template file is valid with respect to a template specification.

  ```bash
  cidc_schemas validate_template -m templates/manifests/pbmc_template.json -x template_examples/pbmc_template.xlsx
  ```



  Check that a JSON schema conforms to the JSON Schema specifications.

  ```bash
  cidc_schemas validate_schema -f shipping_core.json
  ```


pkgId: bf12a9a88a11797b93300ad76c066f2f46f8b2a38d1dbfe34ce2b9d7a46e807c
name: python-ciderpolarity
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/jcy204/ciderPolarity
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ciderpolarity-0.3.3-1.src.rpm
checksum_type: sha256
description:
  **Paper Available:** https://doi.org/10.1371/journal.pone.0299490

  CIDER (Context Informed Dictionary and sEntiment Reasoner) is a Python library used to improve domain-specific sentiment analysis.

  It generates, filters, and substitutes polarities into [VADER](https://github.com/cjhutto/vaderSentiment/).
  The approach taken to generate polarities is taken from [SocialSent](https://github.com/williamleif/socialsent).



  - [Installation](#installation)
  - [Overview](#overview)
  - [Examples](#examples)
  - [Alternative Scales](#alternativescales)



  Before you begin, ensure you have met the following requirements:

  * You have installed Python 3.7 or later.
  * You have a Windows/Linux/Mac machine.

  To install CIDER, follow these steps:

  ```bash
  pip install ciderpolarity
  ```



  The easiest way to use the package is as follows:

  ```python
  from ciderpolarity import CIDER




  input_data = 'test_data.csv'
  output_folder = '/path/to/output/folder/'

  cdr = CIDER(input_data, output_folder)
  results = cdr.fit_transform()
  ```

  This trains the model, creating a customised VADER classifier, before classifying the provided input using the model. A ficticious example output is as follows:

  ```python
  results = [
      ['Really hate this heat. Just want AC', {"neg":0.6, "neu":0.4, "pos":0.0, "compound":-0.6}],
      ['I love an icecream in this heat!', {"neg":0.0, "neu":0.5, "pos":0.5, "compound":0.6}],
      ['I’m melting - terrible weather!', {"neg":0.7, "neu":0.3, "pos":0.0, "compound":-0.7}],
      ['Very dehydrated in this heat', {"neg":0.5, "neu":0.4, "pos":0.0, "compound":-0.5}],
              ...
      ['this sunny weather is great', {"neg":0.0, "neu":0.2, "pos":0.8, "compound":0.7}],
      ['Oh my icecream is melting', {"neg":0.3, "neu":0.4, "pos":0.3, "compound":0.0}],
      ['My AC is broken! 🥵', {"neg":0.6, "neu":0.4, "pos":0.0, "compound":-0.6}]
  ]

  ```


  **Some alternative ways to use the library are as follows:**

  Applying CIDER to a list of strings, adding custom seed words, custom stopwords, and tuning various parameters:

  ```python
  POS_seeds = {'lovely':1, 'excellent':2, 'fortunate':4, 'excited':1, 'loves':2, '♥':1, '🙂':2}
  NEG_seeds = {'bad':1, 'horrible':2, 'hate':4, 'crappy':1, 'sad':2, 'bitch':1, 'hates':2}

  input_data = ['list of strings']
  output = '/path/to/output/test_outputs/'

  cdr_example = CIDER(input_data,                   # input data
                      output,                       # output path
                      iterations=100,               # number of iterations for bootstrapped label propagation
                      stopwords=['i', 'it', 'the'], # custom stopwords, alternativly set as 'default' for the nltk set
                      keep=['code', 'python'],      # words to force into the final lexicon
                      no_below=5,                   # exclude words that occur fewer times than this
                      max_polarities_returned=3000, # maximum number of words returned
                      pos_seeds=POS_seeds,          # positive seeds with custom weighting
                      neg_seeds=NEG_seeds,          # negative seeds with custom weighting
                      verbose=False)                # whether to print progress or not
  ```

  If the model only requires training, the following can be executed:

  ```python
  cdr_example.fit()
  ```

  And the resulting polarities (before filtering and scaling) can be viewed:

  <img src="https://github.com/jcy204/ciderPolarity/blob/main/figs/cdr_out_example.png?raw=true" alt="drawing" width="500"/>

  ___



  Whilst CIDER has built in seed words (found [here](ciderpolarity/suggest_seeds.py)), custom seed words can be generated and suggested. The following shows how this is carried out:

  ```python
  Pos, Neg = cdr_example.generate_seeds(['good','brilliant','love'],['bad','terrible','hate'], n=20, sentiment = True)
  ```
  Which looks at strongly polarised words which occur both often, are close to one seed set, and distant from the opposing seed set.

  The following returns all words in the data, alongside their seed word suitability.
  ```python
  df = cdr_example.generate_seeds(['good','brilliant','love'],['bad','terrible','hate'], return_all = True, sentiment = True)
  ```



  CIDER is not limited to sentiment. By initiating the model with alternative sets of seed words, non-intuitive linguistic scales can be produced. For instance:
  ```python
  from ciderpolarity import CIDER

  input_data = 'test_data.csv'
  output_folder = '/path/to/output/folder/'

  cdr = CIDER(input_data, output_folder, predefined_seeds = 'gender')
  cdr.fit()
  ```
  The above creates a linguistic scale based off of proximity to gendered seed words (i.e. 'he', 'him', 'brother' and 'she', 'her', 'sister').
  Below shows a sample output for this scale when applied to all of the tweets from the UK in 2020.
  <img src="https://github.com/jcy204/ciderPolarity/blob/main/figs/genderpols.png?raw=true" alt="drawing" width="850"/>


pkgId: b1ef0c143fe351b555c2394fb2874079a6a2c3e388a0d5409ef538f9aa873492
name: python-cidr-trie
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Store/search CIDR prefixes in a trie structure.
url: https://github.com/Figglewatts/cidr-trie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cidr-trie-3.1.2-1.src.rpm
checksum_type: sha256
description:
  Store CIDR IP addresses (both v4 and v6) in a trie for easy lookup.
  Read the documentation `here
  <https://cidr-trie.readthedocs.io/en/latest/>`_.


pkgId: d4797355569159b978b83ab93f93141ed2633e89c93a84a5d95498ef30813ac1
name: python-ciecplib
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: A python client for SAML/ECP authentication
url: https://pypi.org/project/ciecplib/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ciecplib-0.8.2-1.src.rpm
checksum_type: sha256
description:
  This python package provides a native Python client to access
  SAML/ECP-authenticated content over HTTP with
  [CILogon](https://cilogon.org).



  [![PyPI version](https://img.shields.io/pypi/v/ciecplib.svg)](https://pypi.python.org/pypi/ciecplib)
  [![Conda version](https://img.shields.io/conda/vn/conda-forge/ciecplib.svg)](https://anaconda.org/conda-forge/ciecplib/)
  [![DOI](https://zenodo.org/badge/33156275.svg)](https://zenodo.org/badge/latestdoi/33156275)
  [![License](https://img.shields.io/pypi/l/ciecplib.svg)](https://choosealicense.com/licenses/gpl-3.0/)
  ![Supported Python versions](https://img.shields.io/pypi/pyversions/ciecplib.svg)



  [![Build status](https://github.com/duncanmmacleod/ciecplib/actions/workflows/python.yml/badge.svg?branch=main)](https://github.com/duncanmmacleod/ciecplib/actions/workflows/python.yml)
  [![Codecov](https://img.shields.io/codecov/c/gh/duncanmmacleod/ciecplib?logo=codecov)](https://codecov.io/gh/duncanmmacleod/ciecplib)
  [![Maintainability](https://api.codeclimate.com/v1/badges/9e777f5fe160d1e3e7b6/maintainability)](https://codeclimate.com/github/duncanmmacleod/ciecplib/maintainability)
  [![Documentation](https://readthedocs.org/projects/ciecplib/badge/?version=latest)](https://ciecplib.readthedocs.io/en/latest/?badge=latest)



  See https://ciecplib.readthedocs.io/en/latest/#installation for installation instructions.



  ```python
  >>> from ciecplib import request
  >>> response = request('https://somewhere.org/mywebpage/')
  ```


pkgId: 63b020734f436dac323febede92f080dd589a7af435573416d8af91d1ca27525
name: python-cifer
arch: src
version: 0.1.27
epoch: 0
release: 1
summary: Federated Learning and Fully Homomorphic Encryption
url: https://www.cifer.ai
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cifer-0.1.27-1.src.rpm
checksum_type: sha256
description:
  <br>
  For more detailed information and access to the full documentation, please visit [www.cifer.ai](https://cifer.ai)



  - Websocket server-client
  - PyJWT

  - Resolved bug in data processing related to incorrect input handling.


  - Added support for WebSocket Secure (WSS), allowing users to choose between standard WebSocket (WS) or secure WSS communication.
  - Enabled model weight encryption using Homomorphic Encryption (RSA) for secure data transmission between Client and Server. This can be enabled with the use_homomorphic parameter.
  - Added JSON Web Token (JWT) authentication, requiring Clients to send a token to the Server for identity verification, enhancing access control.

  - Resolved import issues by switching to absolute imports in connection_handler.py to reduce cross-package import conflicts when running the project externally.


  - Resolved bug in data processing related to incorrect input handling.


  - No matching distribution found for tensorflow
  - Package versions have conflicting dependencies.


  - Add conditional TensorFlow installation based on platform

  - Resolved bug in data processing related to incorrect input handling.


  - Initial release of `FedServer` class that supports federated learning using gRPC.
  - Added client registration functionality with `clientRegister`.
  - Added model training round management with `startServer` function.
  - Implemented federated averaging (FedAvg) aggregation for model weights.
  - Model validation functionality with `__callModelValidation` method.
  - Support for handling multiple clients concurrently with threading.
  - Configurable server via `config.json`.

  - Modularized the code for future extension and improvement.
  - Created configuration options for server IP, port, and `max_receive_message_length` via the `config.json` file.

  - Optimized client handling to prevent blocking during registration and learning rounds.


  - Resolved bug in data processing related to incorrect input handling.


  - Resolved bug in data processing related to incorrect input handling.


  -- Integrate Tensorflow and Huggingface's Transformer
  New Integration: Added support for TensorFlow and HuggingFace's Transformers library to enhance model training and expand compatibility with popular AI frameworks.

  -- Resolved various bugs to improve system stability and performance.
  This update continues to build on CiferAI's federated learning and fully homomorphic encryption (FHE) framework, focusing on enhanced compatibility, privacy, and security in decentralized machine learning environments.


  - Homepage --- cifer.ai
  Documentation. --- cifer.ai/documentation
  Repository --- https://github.com/CiferAI/ciferai


  - Updated `README.md` to improve content and information about Cifer.


  - Added new feature for handling exceptions in the main module.
  - Included additional error logging functionality.


  - Resolved bug in data processing related to incorrect input handling.


pkgId: 6f5a9df423c288a298d968cb8a2a64845e0d2d5e18616561c79f3518ba3677e0
name: python-cifkit
arch: src
version: 1.0.6
epoch: 0
release: 1
summary: A Python package for coordination geometry and atomic site analysis
url: https://pypi.org/project/cifkit/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cifkit-1.0.6-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bobleesj/cifkit/actions/workflows/tests-on-pr.yml/badge.svg?branch=main)](https://github.com/bobleesj/cifkit/actions/workflows/tests-on-pr.yml)
  [![codecov](https://codecov.io/gh/bobleesj/cifkit/graph/badge.svg?token=AN2YAC337A)](https://codecov.io/gh/bobleesj/cifkit)
  ![Python - Version](https://img.shields.io/pypi/pyversions/cifkit)
  [![PyPi version](https://img.shields.io/pypi/v/cifkit.svg)](https://pypi.python.org/pypi/cifkit)

  <a href="https://joss.theoj.org/papers/9016ae27b8c6fddffaae5aeb8be18d19"><img src="https://joss.theoj.org/papers/9016ae27b8c6fddffaae5aeb8be18d19/status.svg"></a>

  ![Logo light mode](docs/assets/img/logo-black.png#gh-light-mode-only "cifkit logo light")
  ![Logo dark mode](docs/assets/img/logo-color.png#gh-dark-mode-only "cifkit logo dark")

  `cifkit` is designed to provide a set of fully-tested utility functions and
  variables for handling large datasets, on the order of tens of thousands, of
  `.cif` files.



  `cifkit` provides higher-level functions in just a few lines of code.

  - **Coordination geometry** - `cifkit` provides functions for visualing
    coordination geometry from each site and extracts physics-based features like
    volume and packing efficiency in each polyhedron.
  - **Atomic mixing** - `cifkit` extracts atomic mixing information at the bond
    pair level—tasks that would otherwise require extensive manual effort using
    GUI-based tools like VESTA, Diamond, and CrystalMaker.
  - **Filter** - `cifkit` offers features for preprocessing. It systematically
    addresses common issues in CIF files from databases, such as incorrect loop
    values and missing fractional coordinates, by standardizing and filtering out
    ill-formatted files. It also preprocesses atomic site labels, transforming
    labels such as 'M1' to 'Fe1' in files with atomic mixing.
  - **Sort** - `cifkit` allows you to copy, move, and sort `.cif` files based on
    attributes such as coordination numbers, space groups, unit cells, shortest
    distances, elements, and more.



  The example below uses `cifkit` to visualize the polyhedron generated from each
  atomic site based on the coordination number geometry.

  ```python
  from cifkit import Cif

  cif = Cif("your_cif_file_path")
  site_labels = cif.site_labels


  for label in site_labels:
      
      cif.plot_polyhedron(label, is_displayed=True)
  ```

  ![Polyhedron generation](docs/assets/img/ErCoIn-polyhedron.png)



  The following example generates a distribution of structure.

  ```python
  from cifkit import CifEnsemble

  ensemble = CifEnsemble("your_folder_path_containing_cif_files")
  ensemble.generate_structure_histogram()
  ```

  ![structure distribution](docs/assets/img/histogram-structure.png)

  Basde on your visual histogram above, you can copy and move .cif files based on
  specific attributes:

  ```python

  ensemble.filter_by_structures(["Co1.75Ge", "CoIn2"])


  ensemble.filter_by_structures("CeAl2Ga2")
  ```

  To learn more, please read the official documentation here:
  https://bobleesj.github.io/cifkit.



  Here is a quote illustrating how `cifkit` addresses one of the challenges
  mentioned above.

  > "I am building an X-Ray diffraction analysis (XRD) pattern visualization
  > script for my lab using `pymatgen`. I feel like `cifkit` integrated really
  > well into my existing stable of libraries, while surpassing some alternatives
  > in preprocessing and parsing. For example, it was often unclear at what stage
  > an error occurred—whether during pre-processing with `CifParser`, or XRD plot
  > generation with `diffraction.core` in `pymatgen`. The pre-processing logic in
  > `cifkit` was communicated clearly, both in documentation and in actual
  > outputs, allowing me to catch errors in my data before it was used in my
  > visualizations. I now use `cifkit` by default for processing CIFs before they
  > pass through the rest of my pipeline." - Alex Vtorov `



  - [Official documentation](https://bobleesj.github.io/cifkit)
  - [Contribution guide](https://github.com/bobleesj/cifkit/blob/main/CONTRIBUTING.md)
  - [MIT license](https://github.com/bobleesj/cifkit/blob/main/LICENSE)



  Here is how you can contribute to the `cifkit` project if you found it helpful:

  - Star the repository on GitHub and recommend it to your colleagues who might
    find `cifkit` helpful as well.
    [![Star GitHub repository](https://img.shields.io/github/stars/bobleesj/cifkit.svg?style=social)](https://github.com/bobleesj/cifkit/stargazers)
  - Create a new issue for any bugs or feature requests
    [here](https://github.com/bobleesj/cifkit/issues)
  - Fork the repository and consider contributing changes via a pull request.
    [![Fork GitHub repository](https://img.shields.io/github/forks/bobleesj/cifkit?style=social)](https://github.com/bobleesj/cifkit/fork).
    Check out
    [CONTRIBUTING.md](https://github.com/bobleesj/cifkit/blob/main/CONTRIBUTING.md)
    for instructions.
  - If you have any suggestions or need further clarification on how to use
    `cifkit`, please reach out to Bob Lee
    ([@bobleesj](https://github.com/bobleesj)).



  ```bash
  pip install -r requirements/docs.txt
  mkdocs serve
  ```

rpm_license:
  Copyright 2024 Sangjoon Lee  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: 418132d65a1ff2fddcf73b6be907580e10c032133419fecdc0fdfa77ab386a22
name: python-cifparse
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: A python parser for the FAA CIFP
url: https://github.com/misterrodg/cifparse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cifparse-0.9.3-1.src.rpm
checksum_type: sha256
description:
  A python parser for the FAA CIFP.



  | Version | Description                                                         | Release Date |
  | ------- | ------------------------------------------------------------------- | ------------ |
  | 0.9.3   | Updated procedure handling (breaking changes) and database support. | 2024-11-15   |
  | 0.9.2   | Minor fixes.                                                        | 2024-07-13   |
  | 0.9.0   | Initial public release.                                             | 2024-07-13   |

  A changelog is available in the [CHANGELOG.md](./CHANGELOG.md) with additional detail and guidance.



  Install using `pip`:

  ```
  pip install cifparse
  ```



  Usage is relatively straightforward. Setting the path to the file can be somewhat finnicky, as it will only accept relative paths. To keep things simple, place the CIFP file in your project directory. Otherwise, if you want to go up several folders into a download folder, it might end up looking like `../../../../Downloads/FAACIFP18`.

  Given the amount of data, parsing can take a moment. If dumping the data to a file, that can also add time. Dumping every airport to JSON can take around 15 seconds, and the resulting file is about 330MB.



  Start by importing `cifparse`, setting the path to the CIFP file, and then parsing the data.

  ```python
  import cifparse


  from cifparse import CIFP


  c = CIFP("FAACIFP18")


  c.parse()

  c.parse_airports()
  c.parse_heliports()
  c.parse_ndbs()
  c.parse_airways()
  c.parse_vhf_dmes()
  c.parse_waypoints()
  c.parse_controlled()
  c.parse_restrictive()
  ```



  After parsing the data, the results will be in the CIFP object, accessible via getters that return lists of the objects.

  ```python
  all_airports = c.get_airports()
  all_heliports = c.get_heliports()
  all_airways = c.get_airways()
  all_ndbs = c.get_ndbs()
  all_vordmes = c.get_vhf_dmes()
  all_waypoints = c.get_waypoints()
  all_controlled = c.get_controlled()
  all_restrictive = c.get_restrictive()
  ```



  ```python
  airport = c.find_airport("KIAD")
  heliport = c.find_heliport("DC03")
  airway = c.find_airway("J146")
  ndb = c.find_ndb("GTN")
  vor = c.find_vhf_dme("AML")
  fix = c.find_waypoint("RAVNN")
  dc_class_b = c.find_controlled("KDCA")
  roa_class_c = c.find_controlled("KROA")
  cho_class_d = c.find_controlled("KCHO")
  moa = c.find_restrictive("DEMO 1 MOA")



  all_5314 = c.find_restrictive_match("5314")

  ```





  Each object has its own `to_dict()` method. This is useful when you need to dump the data to json:

  ```python
  c = CIFP("FAACIFP18")
  airport = c.find_airport("KIAD")
  with open("output.json", "w") as json_file:
      json.dump(airport.to_dict(), json_file, indent=2)
  ```



  Each object has its own `to_db()` method. This is useful when you would like the data to persist, or query it using standard database methods:

  ```python
  import sqlite3

  connection = sqlite.connect("FAACIFP18.db")
  cursor = connection.cursor()

  c = CIFP("FAACIFP18")
  c.initialize_database(cursor)
  c.parse()
  c.to_db(cursor)

  connection.commit()
  connection.close()
  ```

  NOTE: The resulting tables are somewhat less-optimally normalized than they could be. This is mostly to allow flexibility in querying. For example, the `airway_points` table can be queried directly, or it can be queried via `airways` with a join to `airway_points`. There is limited additional information, but it could also help to get higher level overviews of the underlying data. Airspace follows a similar principle.



  An example file is provided in the [Examples](./examples/) directory. It demonstrates parsing all of the CIFP data, finding an airport within the data, and then looping through the SID and STAR data to create a geoJSON file for each.



  A breakdown of the different objects can be found in the [Docs](./docs/) directory.


pkgId: 2c49a577c246cfef42c723bb9274981c79cb52fe8e434ebc72a9e554dbd568bb
name: python-cigsegy
arch: src
version: 1.1.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/JintaoLee-Roger/cigsegy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cigsegy-1.1.8-1.src.rpm
checksum_type: sha256
description:
  - Fast (Implemented in c++)
  - python wraping and **numpy** array supports
  - dealing with normal and **irregular** SEG-Y volume [1]_.
  - creating a SEG-Y file using the **existed header** of a SEG-Y


pkgId: 1373e93ea71d9d50c40da04f8913438f0899816b57446f964d46a38ec1ca0f79
name: python-cihai
arch: src
version: 0.34.0
epoch: 0
release: 1
summary: Library for CJK (chinese, japanese, korean) language data.
url: https://pypi.org/project/cihai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cihai-0.34.0-1.src.rpm
checksum_type: sha256
description:
  ```

  All datasets that cihai uses have stand-alone tools to export their data. No library required.
  - [unihan-etl](https://unihan-etl.git-pull.com) - [UNIHAN](http://unicode.org/charts/unihan.html)
    data exports for csv, yaml and json.

  ```console
  $ git clone https://github.com/cihai/cihai.git`
  ```
  ```console
  $ cd cihai/
  ```
  [Bootstrap your environment and learn more about contributing](https://cihai.git-pull.com/contributing/). We use the same conventions / tools across all cihai projects: `pytest`, `sphinx`, `mypy`, `ruff`, `tmuxp`, and file watcher helpers (e.g. `entr(1)`).

  - 0.19.0: Last Python 3.7 release

  - [Quickstart](https://cihai.git-pull.com/quickstart.html)
  - [Datasets](https://cihai.git-pull.com/datasets.html) a full list of current and future data sets
  - Python [API](https://cihai.git-pull.com/api.html)
  - [Roadmap](https://cihai.git-pull.com/design-and-planning/)
  - Python support: >= 3.8, pypy
  - Source: <https://github.com/cihai/cihai>
  - Docs: <https://cihai.git-pull.com>
  - Changelog: <https://cihai.git-pull.com/history.html>
  - API: <https://cihai.git-pull.com/api.html>
  - Issues: <https://github.com/cihai/cihai/issues>
  - Test coverage: <https://codecov.io/gh/cihai/cihai>
  - pypi: <https://pypi.python.org/pypi/cihai>
  - OpenHub: <https://www.openhub.net/p/cihai>
  - License: MIT
  [![Docs](https://github.com/cihai/cihai/workflows/docs/badge.svg)](https://cihai.git-pull.com/)
  [![Build Status](https://github.com/cihai/cihai/workflows/tests/badge.svg)](https://github.com/cihai/cihai/actions?query=workflow%3A%22tests%22)


pkgId: e8f4f407195cb0dc9fad140e92b9e304dce4e5a24e71083c769a65479adb90bf
name: python-cihai-cli
arch: src
version: 0.29.0
epoch: 0
release: 1
summary: Command line frontend for the cihai CJK language library
url: https://pypi.org/project/cihai-cli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cihai-cli-0.29.0-1.src.rpm
checksum_type: sha256
description:
  char: 嫏
  kCantonese: long4
  kDefinition: the place where the supreme stores his books; library
  kJapaneseOn: ROU
  kMandarin: láng
  kTotalStrokes: '11'


pkgId: 9b0ec1e2608f9f1b37637c3a2419fa8f480a391f66208b63fef86911f2c7add2
name: python-cijoe
arch: src
version: 0.9.41
epoch: 0
release: 1
summary: A loosely coupled approach to systems development and testing
url: https://pypi.org/project/cijoe/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cijoe-0.9.41-1.src.rpm
checksum_type: sha256
description:
  Tools for systems development and testing.
  Please take a look at the documentation for how to install and use ``cijoe``:
  * `Quickstart Guide`_
  * `Usage`_
  If you find bugs or need help then feel free to submit an `Issue`_. If you want
  to get involved head over to the `GitHub page`_ to get the source code and
  submit a `Pull request`_ with your changes.

rpm_license:
  BSD 3-Clause License  Copyright (c) 2022, Simon A. F. Lund All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 7e0e053c5d8d80c6b571d425b5c7ecff63476e1f60334ab26c930cae205b8fd4
name: python-cilantro
arch: src
version: 2.0.11
epoch: 0
release: 1
summary: A client implementation for Serrano 2.x
url: http://cbmi.github.com/cilantro
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cilantro-2.0.11-1.src.rpm
checksum_type: sha256
description:
  Cilantro as a python package has be DEPRECATED and will not longer be updated nor supported. Cilantro is now purely a static client containing only JavaScript, HTML and CSS files. See more on the GitHub page: https://github.com/cbmi/cilantro/


pkgId: 832981b241d0d75f74980c6d5f8aea3ba76aabc8be5975425aac80ebe485af8b
name: python-cilog
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: CiLog is a flexible integrated logging tool
url: https://github.com/CM-BF/CiLog/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cilog-1.3.0-1.src.rpm
checksum_type: sha256
description:
  CiLog is a flexible integrated logging tool with color and custom bold font base on package logging.



  * Colored console outputs
  * Setting stack info output level
  * Easier way to custom format for each level
  * Substitute builtins.print: a new print grammar to use log!
  * Command line script to substitute `nohup cmd &` with a "task
  completed reminder" feature.



  ```bash
  $ pip install cilog
  ```




  * Add SUPPORT for excel table filling.
  Usage:
  ```python
  from cilog import fill_table


  table_format = [['A', 'B', 'C', 'D', 'E', 'F', 'G'],
                  ['da', 'db', 'dc', 'de'],
                  ['sa', 'sb', 'sc', 'sd', 'sf']]

  fill_table('./excel_test.xlsx', value='0.4013', x='C', y='db', z='sd', table_format=table_format)
  ```
  ![fill_table](./figures/fill_table.png)


  * Add SUPPORT for error logging(such as `raise ***`), all the error message will go though the
  logger.error process. Note that you have to use set flag `sub_print=True` in `create_logger()`
  to use this function.
  * Fix bug with package tqdm


  * Tabular print SUPPORT: `print(f'#T#!latex{table_list}')` for latex format table string
  or `print(f'#T#{table_list}')` for markdown format table string.


  * Bug fixed


  * Automatically install dependencies when first running.


  * bug fixed


  * Add origin level. When we use sub_print=True, `print(f'string')` will act like normal builtin print
  function. Other levels like `info`, `debug` and `mail`, etc, should be specified by special notation
  like `#IN#`, `#D#` and `#M#`, etc.
  * Support Table print in markdown format or latex format for data scientists.


  * Bug fixed


  * Bug fixed


  * Develop print function substitute function. Now you can directly
  send parameter `sub_print=True` to `create_logger` for substituting print.
  * A command line TOOL: cilog is available NOW! You don't have
  to use `nohup cmd &` any more! It will even send a EMAIL to you when your task
  completed! Please refer to the main document for how to use it.



  * Substitute builtins.print using logger.substitute_print()
  * A brand NEW way to use logger! You can just use print()!
  * By using print, you need to know the easier logger grammar.
  Please refer to the main document.



  * Bug fixed: Now the logger can automatically create the directory for log file.



  * Eliminate ipt_info, instead you can use logger.important() to log important info.
  * adding feature of sending email. By Default, after setting enable_mail and mail_setting, all message log by
  logger.mail() will be sent to the specific email address according to mail_setting.



  * After log file's line_length is greater than 1e+4, it will automatically backup the log file with localtime then new
  a log file.



  * new parameter ipt_info



  ```python
  from cilog import create_logger


  def call_error():
      logger.error('Exception')

  '''
  mail_setting = {
              mailhost:   string or tuple - YourMailHost or (host, port),
              fromaddr:   string          - YourSenderAddress,
              toaddrs:    list(string)    - List of YourTargetAddresses,
              subject:    string          - Mail Subject,
              credentials:tuple           - (YourUsername, YourPassword),
              secure:     tuple           - () or (KeyfileName) or (KeyfileName, CertificatefileName)
                                              use the secure protocol (TLS),
              timeout:    float           - Default 1.0
          }
  '''

  mail_setting = {
      'mailhost': ('*****', int(**)),
      'fromaddr': '****@*****',
      'toaddrs': ['****@****', '***@***'],
      'subject': 'CiLog test',
      'credentials': ('***@**', '****')
  }
  logger = create_logger(name='l1', file='./log.log', use_color=True, enable_mail=True,
                         mail_setting=mail_setting)
  logger.info('start')
  logger.debug('here')
  logger.warning('warn')
  call_error()
  logger.critical('Program exit.')
  logger.important('lal')
  logger.mail('test') # you will receive an email after using this function.
  ```

  "*" means new features

  `create_logger` keywords:

  name : str - logger name

  file : str - File path

  file_mode : str - File open mode. Default: 'a'

  file_level : Literal['DEBUG', 'INFO', 'WARNING', 'IMPORTANT', 'ERROR', 'CRITICAL', 'MAIL'] - Default 'INFO'

  enable_mail : bool - Default False

  mail_level : Literal['DEBUG', 'INFO', 'WARNING', 'IMPORTANT', 'ERROR', 'CRITICAL', 'MAIL'] - Default 'MAIL'

  mail_setting : dir - Required if enable_mail == True
  ```
      {
          mailhost:   string or tuple - YourMailHost or (host, port),
          fromaddr:   string          - YourSenderAddress,
          toaddrs:    list(string)    - List of YourTargetAddresses,
          subject:    string          - Mail Subject,
          credentials:tuple           - (YourUsername, YourPassword),
          secure:     tuple           - () or (KeyfileName) or (KeyfileName, CertificatefileName)
                                          use the secure protocol (TLS),
          timeout:    float           - Default 1.0
      }
  ```
  use_color : bool - Signal for using colored info. Default True

  stack_level : Literal['DEBUG', 'INFO', 'WARNING', 'IMPORTANT', 'ERROR', 'CRITICAL', 'MAIL'] - Default 'ERROR'

  msg_fmt : Dict{'DEBUG': debug_fmt, 'INFO': info_fmt, 'WARNING': warning_fmt, 'IMPORTANT': important_fmt,
  'ERROR': error_fmt, 'CRITICAL': critical_fmt, 'MAIL': mail_fmt} - Custom design massage format.

  (Specially, you can use $BOLD **text** $RESET to use bold font)
  Please refer to CustomFormatter and url: https://docs.python.org/3/library/logging.html#logrecord-attributes

  return: logger : CustomLogger




  The only step you shoud do is:
  ```python
  from cilog import create_logger
  create_logger(sub_print=True)








  print('i=1') # info: i=1
  print('i', '=', '1') # info: i = 1
  print('#D#Here!') # Debug: Here! [#d#, #DEbu#, #dEBug#, ... are all valid!]
  print('#W#warning') # Warning ...


  ```
  **Grammar**: The way to use `logger.info` is just use `print`, and the way
  to use other level is to **type the first several characters of the level
  name between simbol `#`**.

  You can use print everywhere which actually use the logger
  you created to output! Meanwhile, you can use any `print` features,
  like `end=*` or `sep=* ...` but do not use `file=*`, because the logger
  only monitor the standard output.

  **Elaborate Example:**

  ```python
  from cilog import create_logger


  def call_error():
      print('#E#Exception')

  '''
  mail_setting = {
              mailhost:   string or tuple - YourMailHost or (host, port),
              fromaddr:   string          - YourSenderAddress,
              toaddrs:    list(string)    - List of YourTargetAddresses,
              subject:    string          - Mail Subject,
              credentials:tuple           - (YourUsername, YourPassword),
              secure:     tuple           - () or (KeyfileName) or (KeyfileName, CertificatefileName)
                                              use the secure protocol (TLS),
              timeout:    float           - Default 1.0
          }
  '''
  mail_setting = {
      'mailhost': ('*****', int(**)),
      'fromaddr': '****@*****',
      'toaddrs': ['****@****', '***@***'],
      'subject': 'CiLog test',
      'credentials': ('***@**', '****')
  }
  create_logger(name='l1', file='./log.log', enable_mail=True,
                         mail_setting=mail_setting, sub_print=True)

  print('origin')
  table_list = [['Tox21', 'Clintox'], [1, 2], [3, 4]]
  print(f'#t#{table_list}')   # print table in markdown format





  print(f'#t#!latex{table_list}') # latex format table









  print('#IN#start')
  print('#D#here')
  print('#W#warn')
  call_error()
  print('#C#Program exit.')
  print('#IM#lal')

  ```




  Run `$ cilog [any cmd]` to create default config file at
  `$HOME$/.cilog/config.json` then modify it with your custom
  setting.


  For example:

  ```bash
  $ cilog python my_algorithm.py --lr 0.01 --epoch 100
  ```
  it is equal to:
  ```bash
  $ nohup python my_algorithm.py --lr 0.01 --epoch 100 > cilog.log 2>&1 &
  ```

  `-e` usage:
  ```bash
  $ cilog -e python my_algorithm.py --lr 0.01 --epoch 100
  ```
  There is no different to the previous example but will send you
  A EMAIL when the task finished [Using your default setting].
  It is especially useful when your program is time comsuming.

  `-c [config_file]`: use your own config file instead of the default one.

  `-r [redirect_file]`: redirect the output to a file instead of `cilog.log`.

  Ps: Do not use the same cmdline parameters `-c -e -r` in your program,
  or it will cause an error.

  Help: `cilog --help`




  See [MIT LICENSE](https://github.com/CM-BF/CiLog/blob/master/LICENSE)


pkgId: 73aec0db7dbc49e127907191650a781c90a9c584c990ff89e2b77f463f58a8a1
name: python-cim-11-CERTIC
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: Classification Internationale des Maladies Onzième Révision en français. Données OMS.
url: https://pypi.org/project/cim-11-CERTIC/
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cim-11-CERTIC-0.6.5-1.src.rpm
checksum_type: sha256
description:
  Package fournissant en français une liste de maladies associées à leurs codes internationaux,
  tels que diffusés par l'OMS (Organisation Mondiale de la Santé), ainsi qu'une recherche
  plein-texte sur les labels de ces maladies.

  Pour plus de renseignements, voir la page officielle de la CIM-11: https://icd.who.int/fr



  - Ce package n'est pas affilié à l'OMS, merci de ne pas les contacter pour un quelconque support à son sujet
  - Ce package est destiné à fournir une solution simple, rapide et surtout hors-ligne au codage des maladies
  - Il ne se soustrait pas aux outils fournis par l'OMS et en particulier son API
  - Dans sa dernière version, les données de ce package sont figées au 12 mars 2024



      pip install cim-11-CERTIC



      from cim_11 import root_concepts, label_search

      

      for item in root_concepts():
          print(f"-- {item.icode + ' ' if item.icode else ''}{item.label}")
          for child in item.children:
              print(f"-- {child.icode + ' ' if child.icode else ''}{child.label}")
              for sub in child.children:
                  print(f"---- {sub.icode + ' ' if sub.icode else ''}{sub.label}")

      

      for item in label_search("tumeur foie métastase"):
          print(f"{item.icode} {item.label}")


pkgId: f5a3718cb3d63ccb2d16f5259d4b1783d720e67b728cfff1df1744ca1ddb6b7d
name: python-cimcb
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: This is a pre-release.
url: https://github.com/KevinMMendez/cimcb
rpm_license: http://www.apache.org/licenses/LICENSE-2.0.html
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cimcb-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <img src="cimcb_logo.png" alt="drawing" width="400"/>


  cimcb package containing the necessary tools for the statistical analysis of untargeted and targeted metabolomics data.




  cimcb requires:
  - Python (>=3.5)
  - Bokeh (>=1.0.0)
  - Keras
  - NumPy (>=1.12)
  - SciPy
  - scikit-learn
  - Statsmodels
  - TensorFlow
  - tqdm


  The recommend way to install cimcb and dependencies is to using ``conda``:
  ```console
  conda install -c cimcb cimcb
  ```
  or ``pip``:
  ```console
  pip install cimcb
  ```
  Alternatively, to install directly from github:
  ```console
  pip install https://github.com/KevinMMendez/cimcb/archive/master.zip
  ```


  Open with Binders:

  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/KevinMMendez/BinderTutorial_Workflow/master?filepath=BinderTutorial_Workflow.ipynb)


  For futher detail on the usage refer to the docstring.


  - [PLS_SIMPLS](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/PLS_SIMPLS.py#L14-L36): Partial least-squares regression using the SIMPLS algorithm.
  - [PCR](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/PCR.py#L8-L29): Principal component regression.
  - [PCLR](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/PCLR.py#L8-L29): Principal component logistic regression.
  - [RF](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/RF.py#L8-L9): Random forest.
  - [SVM](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/SVM.py#L8-L9): Support Vector Machine.
  - [RBF_NN](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/RBF_NN.py#L8-L9): Radial basis function neural network.
  - [NN_LinearLinear](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/NN_LinearLinear.py#L7-L8): 2 Layer linear-linear neural network.
  - [NN_LinearLogit](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/NN_LinearLogit.py#L7-L8): 2 Layer linear-logistic neural network.
  - [NN_LogitLogit](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/model/NN_LogitLogit.py#L7-L8): 2 Layer logistic-logistic neural network.


  - [boxplot](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/boxplot.py#L8-L18): Creates a boxplot using Bokeh.
  - [distribution](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/distribution.py#L6-L16): Creates a distribution plot using Bokeh.
  - [pca](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/pca.py#L10-L17): Creates a PCA scores and loadings plot using Bokeh.
  - [permutation_test](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/permutation_test.py#L13-L27): Creates permutation test plots using Bokeh.
  - [roc_plot](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/roc.py#L11-L24): Creates a rocplot using Bokeh.
  - [scatter](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/scatter.py#L6-L16): Creates a scatterplot using Bokeh.
  - [scatterCI](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/plot/scatterCI.py#L7-L14): Creates a scatterCI plot using Bokeh.


  - [kfold](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/cross_val/kfold.py#L14-L42): Exhaustitive search over param_dict calculating binary metrics.


  - [Perc](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/bootstrap/Perc.py#L6-L35): Returns bootstrap confidence intervals using the percentile boostrap interval.
  - [BC](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/bootstrap/BC.py#L8-L37): Returns bootstrap confidence intervals using the bias-corrected boostrap interval.
  - [BCA](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/bootstrap/BCA.py#L8-L36): Returns bootstrap confidence intervals using the bias-corrected and accelerated boostrap interval.


  - [binary_metrics](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/binary_metrics.py#L5-L23): Return a dict of binary stats with the following metrics: R2, auc, accuracy, precision, sensitivity, specificity, and F1 score.
  - [ci95_ellipse](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/ci95_ellipse.py#L6-L28): Construct a 95% confidence ellipse using PCA.
  - [knnimpute](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/knnimpute.py#L7-L22): kNN missing value imputation using Euclidean distance.
  - [load_dataXL](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/load_dataXL.py#L7-L29): Loads and validates the DataFile and PeakFile from an excel file.
  - [nested_getattr](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/nested_getattr.py#L4-L5): getattr for nested attributes.
  - [scale](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/scale.py#L4-L42): Scales x (which can include nans) with method: 'auto', 'pareto', 'vast', or 'level'.
  - [table_check](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/table_check.py#L4-L17): Error checking for DataTable and PeakTable (used in load_dataXL).
  - [univariate_2class](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/univariate_2class.py#L8-L35): Creates a table of univariate statistics (2 class).
  - [wmean](https://github.com/KevinMMendez/cimcb/blob/master/cimcb/utils/wmean.py#L4-L19): Returns Weighted Mean. Ignores NaNs and handles infinite weights.


  cimcb is licensed under the ___ license.


  - Kevin Mendez
  - [David Broadhurst](https://scholar.google.ca/citations?user=M3_zZwUAAAAJ&hl=en)


  Professor David Broadhurst, Director of the Centre for Integrative Metabolomics & Computation Biology at Edith Cowan University.
  E-mail: d.broadhurst@ecu.edu.au


  If you would cite cimcb in a scientific publication, you can use the following: ___


pkgId: 7d484b086b48c42a2fef3210e1eaf94baeb3a814f2612f203d36d24bf92b7cc3
name: python-cimcb-lite
arch: src
version: 1.0.2
epoch: 0
release: 1
url: https://github.com/cimcb/cimcb_lite
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cimcb-lite-1.0.2-1.src.rpm
checksum_type: sha256
summary:
  A lite version of the cimcb package containing the necessary tools for the statistical analysis of untargeted and targeted metabolomics data.

description:
  <img src="cimcb_logo.png" alt="drawing" width="400"/>


  cimcb_lite is a lite version of the cimcb package containing a small number of basic tools for the statistical analysis of untargeted and targeted metabolomics data.




  cimcb_lite requires:
  - Python (>=3.5)
  - Bokeh (>=1.0.0)
  - NumPy
  - SciPy
  - scikit-learn
  - Statsmodels
  - tqdm


  The recommend way to install cimcb_lite and dependencies is to using ``conda``:
  ```console
  conda install -c cimcb cimcb_lite
  ```
  or ``pip``:
  ```console
  pip install cimcb_lite
  ```
  Alternatively, to install directly from github:
  ```console
  pip install https://github.com/cimcb/cimcb_lite/archive/master.zip
  ```


  For futher detail on the usage refer to the docstring.


  - [PLS_SIMPLS](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/PLS_SIMPLS.py#L14-L36): Partial least-squares regression using the SIMPLS algorithm.
    - [train](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/PLS_SIMPLS.py#L43-L58): Fit the PLS model, save additional stats (as attributes) and return Y predicted values.
    - [test](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/PLS_SIMPLS.py#L105-L117): Calculate and return Y predicted value.
    - [evaluate](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/BaseModel.py#L40-L56): Plots a figure containing a Violin plot, Distribution plot, ROC plot and Binary Metrics statistics.
    - [calc_bootci](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/BaseModel.py#L191-L201): Calculates bootstrap confidence intervals based on bootlist.
    - [plot_featureimportance](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/BaseModel.py#L211-L212): Plots feature importance metrics.
    - [plot_permutation_test](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/model/BaseModel.py#L253-L254): Plots permutation test figures.


  - [boxplot](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/boxplot.py#L8-L18): Creates a boxplot using Bokeh.
  - [distribution](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/distribution.py#L6-L16): Creates a distribution plot using Bokeh.
  - [pca](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/pca.py#L10-L17): Creates a PCA scores and loadings plot using Bokeh.
  - [permutation_test](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/permutation_test.py#L13-L27): Creates permutation test plots using Bokeh.
  - [roc_plot](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/roc.py#L11-L24): Creates a rocplot using Bokeh.
  - [scatter](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/scatter.py#L6-L16): Creates a scatterplot using Bokeh.
  - [scatterCI](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/plot/scatterCI.py#L7-L14): Creates a scatterCI plot using Bokeh.


  - [kfold](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/cross_val/kfold.py#L14-L42): Exhaustitive search over param_dict calculating binary metrics.


  - [Perc](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/bootstrap/Perc.py#L6-L35): Returns bootstrap confidence intervals using the percentile boostrap interval.
  - [BC](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/bootstrap/BC.py#L8-L37): Returns bootstrap confidence intervals using the bias-corrected boostrap interval.
  - [BCA](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/bootstrap/BCA.py#L8-L36): Returns bootstrap confidence intervals using the bias-corrected and accelerated boostrap interval.


  - [binary_metrics](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/binary_metrics.py#L5-L23): Return a dict of binary stats with the following metrics: R2, auc, accuracy, precision, sensitivity, specificity, and F1 score.
  - [ci95_ellipse](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/ci95_ellipse.py#L6-L28): Construct a 95% confidence ellipse using PCA.
  - [knnimpute](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/knnimpute.py#L7-L22): kNN missing value imputation using Euclidean distance.
  - [load_dataXL](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/load_dataXL.py#L7-L29): Loads and validates the DataFile and PeakFile from an excel file.
  - [nested_getattr](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/nested_getattr.py#L4-L5): getattr for nested attributes.
  - [scale](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/scale.py#L4-L42): Scales x (which can include nans) with method: 'auto', 'pareto', 'vast', or 'level'.
  - [table_check](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/table_check.py#L4-L17): Error checking for DataTable and PeakTable (used in load_dataXL).
  - [univariate_2class](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/univariate_2class.py#L8-L35): Creates a table of univariate statistics (2 class).
  - [wmean](https://github.com/KevinMMendez/cimcb_lite/blob/master/cimcb_lite/utils/wmean.py#L4-L19): Returns Weighted Mean. Ignores NaNs and handles infinite weights.


  cimcb_lite is licensed under the MIT license.


  - [Kevin Mendez](https://github.com/KevinMMendez/)
  - [David Broadhurst](https://scholar.google.ca/citations?user=M3_zZwUAAAAJ&hl=en)


  Professor David Broadhurst, Director of the Centre for Integrative Metabolomics & Computation Biology at Edith Cowan University.


pkgId: 234f9d170625b1cd526589f407822ec1f4d0ea46ebd1267d8a6ea350b97159a0
name: python-cimren-wkmeans-geo
arch: src
version: 1.3.4
epoch: 0
release: 1
summary: Weighted KMeans Clustering for Geolocational Problem
url: https://github.com/emrahcimren/wkmeans-geo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cimren-wkmeans-geo-1.3.4-1.src.rpm
checksum_type: sha256
description:
  Repo for weighted k means clustering for specifically geo locational problems.
  For an example and mathematical explanation:
  https://emrahcimren.github.io/data%20science/Greenfield-Analysis-with-Weighted-Clustering/


pkgId: 1045a0437a95784e59fc1c391e5d57354be8428cfc0ca8ba5c115122b176b6f0
name: python-cimsparql
arch: src
version: 7.0.5
epoch: 0
release: 1
summary: CIM query utilities
url: https://pypi.org/project/cimsparql/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cimsparql-7.0.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/cimsparql)](https://pypi.org/project/cimsparql/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/cimsparql)](https://pypi.org/project/cimsparql/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![](https://github.com/statnett/data_cache/workflows/Tests/badge.svg)](https://github.com/statnett/cimsparql/actions?query=workflow%3ATests)
  [![codecov](https://codecov.io/gh/statnett/cimsparql/branch/master/graph/badge.svg)](https://codecov.io/gh/statnett/cimsparql)



  This Python package provides functionality for reading cim data from
  tripple stores such as GraphDB, BlazeGraph or Rdf4j into Python memory
  as pandas dataframes.

  The package provides a set of predefined functions/queries to load CIM
  data such as generator, demand or branch data, though the user can
  easiliy define their own queries.





  ```python
  >>> from cimsparql.graphdb import ServiceConfig
  >>> from cimsparql.model import get_single_client_model
  >>> model = get_single_client_model(ServiceConfig(limit=3))
  >>> ac_lines = model.ac_lines()
  >>> print(ac_lines[['name', 'x', 'r', 'bch']])
           name       x       r       bch
  0  <branch 1>  1.9900  0.8800  0.000010
  1  <branch 2>  1.9900  0.8800  0.000010
  2  <branch 3>  0.3514  0.1733  0.000198
  ```

  In the example above the client will query repo "<repo>" in the default server
  [GraphDB](https://graphdb.ontotext.com) for AC line values.



  See the sparql templates folder (`cimsparql/sparql`) to the query used.



  ```python
  >>> from string import Template
  >>> query = 'PREFIX cim:<${cim}>\nPREFIX rdf: <${rdf}>\nSELECT ?mrid where {?mrid rdf:type cim:ACLineSegment}'
  >>> query_result = model.get_table_and_convert(model.template_to_query(Template(query)))
  >>> print(query_result)
  ```



  Available namespace for current graphdb client (`gdbc` in the examples above),
  which can be used in queries (such as `rdf` and `cim`) can by found by

  ```python
  >>> print(model.prefixes)
  {'wgs': 'http://www.w3.org/2003/01/geo/wgs84_pos#',
   'rdf': 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
   'owl': 'http://www.w3.org/2002/07/owl#',
   'cim': 'http://iec.ch/TC57/2010/CIM-schema-cim15#',
   'gn': 'http://www.geonames.org/ontology#',
   'xsd': 'http://www.w3.org/2001/XMLSchema#',
   'rdfs': 'http://www.w3.org/2000/01/rdf-schema#',
   'SN': 'http://www.statnett.no/CIM-schema-cim15-extension#',
   'ALG': 'http://www.alstom.com/grid/CIM-schema-cim15-extension#'}
  ```



  Tests can be run agains RDF4J and/or BlazeGraph databases if a container with the correct images are available.

  ```
  docker pull eclipse/rdf4j-workbench
  docker pull openkbs/blazegraph
  ```

  Launch one or both containers and specify the following environment variables

  ```
  RDF4J_URL = "localhost:8080/rdf4j-server"
  BLAZEGRAPH_URL = "localhost:9999/blazegraph/namespace
  ```
  **Note 1**: The port numbers may differ depending on your local Docker configurations.
  **Note 2**: You don't *have* to install RDF4J or BlazeGraph. Tests requiring these will be skipped in case
  they are not available. They will in any case be run in the CI pipeline on GitHub (where both always are available).



  Ontologies for the CIM model can be found at (ENTSOE's webpages)[https://www.entsoe.eu/digital/common-information-model/cim-for-grid-models-exchange/].
  For convenience and testing purposes the ontology are located under `tests/data/ontology`. CIM models used for testing purposes in Cimsparql should
  be stored in N-quads format. In case you have a model in XML format it can be converted to N-quads by launching a DB (for example RDF4J) and upload
  all the XML files and the ontology.

  Execute

  ```sparql
  PREFIX cims: <http://iec.ch/TC57/1999/rdf-schema-extensions-19990926#>

  DELETE {?s ?p ?o}
  INSERT {?s ?p ?o_cast} WHERE {
    ?s ?p ?o .
    ?p cims:dataType ?_dtype .
    ?_dtype cims:stereotype ?stereotype .
    BIND(IF(?stereotype = "Primitive",
      URI(concat("http://www.w3.org/2001/XMLSchema#", lcase(strafter(str(?_dtype), "#")))),
      ?_dtype) as ?dtype)
    BIND(STRDT(?o, ?dtype) as ?o_cast)
  }
  ```
  and export as N-quads.



  1. *micro_t1_nl*: `MicroGrid/Type1_T1/CGMES_v2.4.15_MicroGridTestConfiguration_T1_NL_Complete_v2`




  CimSparql mainly uses `SparqlWrapper` to communicate with the databases. However, there are certain operations which are performed
  directly via REST calls. Since there are small differences between different APIs you may have to specify which API you are using.
  This can be done when initializing the `ServiceCfg` class or by specifying the `SPARQL_REST_API` environment variable. Currently,
  `RDF4J` and `blazegraph` is supported (if not given `RDF4J` is default).

  ```bash
  export SPARQL_REST_API=RDF4J  # To use RDF4J
  export SPARQL_REST_API=BLAZEGRAPH  # To use BlazeGraph
  ```


pkgId: c986a13367857d6c1a5e160d024ff9339e74971ded4fa2b5920996d0e161263d
name: python-cin
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A framework for creating autonomous agents with dynamic workflows.
url: https://github.com/bytelinkbuckley/collective-intelligence-network
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cin-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Collective Intelligence Network (CIN) is an idea to create autonomous agents that have their dynamic workflows




  This framework was designed with three core principles in mind: simplicity, flexibility, and interoperability. My goal was to create a platform where autonomous agents can effectively tackle complex challenges either collabortively or individually, while meeting enterprise-grade requirements.

  Built-in supported endpoints and models:

  OpenAI https://api.openai.com/v1/chat/completions:

  - "gpt-4o-2024-08-06" ✅


  Anthropic "https://api.anthropic.com/v1/messages":

  - "claude-3-5-sonnet-20241022" ✅


pkgId: eb209fe068f333aef61b21c5483f4078483732e513b07ac02f93ac4956d1d8f4
name: python-cinemagoer
arch: src
version: 2023.5.1
epoch: 0
release: 1
summary: Python package to access the IMDb's database
url: https://cinemagoer.github.io/
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cinemagoer-2023.5.1-1.src.rpm
checksum_type: sha256
description:
  Cinemagoer is a Python package useful to retrieve and
  manage the data of the IMDb movie database about movies, people,
  characters and companies.

  Cinemagoer and its authors are not affiliated in any way to
  Internet Movie Database Inc.; see the DISCLAIMER.txt file for
  details about data licenses.

  Platform-independent and written in Python 3

  Cinemagoer package can be very easily used by programmers and developers
  to provide access to the IMDb's data to their programs.

  Some simple example scripts - useful for the end users - are included
  in this package; other Cinemagoer-based programs are available at the
  home page: https://cinemagoer.github.io/


pkgId: ac20b87a38bb0508960682a7148b635a11b72b634fe6863d0a413d8985f582bd
name: python-cinful
arch: src
version: 1.2.6
epoch: 0
release: 1
url: https://github.com/wilkelab/cinful
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cinful-1.2.6-1.src.rpm
checksum_type: sha256
summary:
  cinful: A fully automated pipeline to identify microcinswith associated immunity proteins and export machinery

description:
  *cinful* reads a directory of genome data and identifies class II microcins using a combination of HMM and BLAST. It has functionality that identifies the associated export machinery (MFP & PCAT) and putative immunity protein. Publication of this work is forthcoming and will be cited here.

  *cinful* is developed by the [Wilke lab](https://wilkelab.org/) at the [Department of Integrative Biology](https://integrativebio.utexas.edu/) in collaboration with the [Davies lab](https://bwdaviesutaustin.org/) at the [Department of Molecular Biosciences](https://molecularbiosci.utexas.edu/), both at [The University of Texas at Austin](https://www.utexas.edu/).


  There are two methods for installation; one uses pip and should be more user friendly.



  The following includes steps to install dependencies.


  ```bash
  $ conda create --name <your-env-name> python=3.8.13 pip
  $ conda activate <your-env-name>
  ```

  ```bash
  $ conda install mamba -c conda-forge
  $ pip install cinful
  $ cinful_init
  ```

  * seqkit=0.15.0
  * mafft=7.475
  * hmmer=3.3.1
  * blast=2.9.0
  * diamond=2.0.11
  * pandas=1.2.4
  * numpy=1.19.2
  * biopython=1.76
  * snakemake=6.3.0
  * prodigal=2.6.3
  * pyhmmer=0.3.0


  * pyTMHMM==1.3.2
  * seqhash==1.0.0
  * blake3==0.2.0


  If installed properly, running `cinful -h` will produce the following output:

  ```
  cinful

  optional arguments:
    -h, --help            show this help message and exit
    -d DIRECTORY, --directory DIRECTORY
                          Must be a directory containing uncompressed FASTA
                          formatted genome assemblies with .fna extension.
                          Files within nested directories are fine
    -o OUTDIR, --outDir OUTDIR
                          This directory will contain all output files.
                          It will be nested under the input directory.
    -t THREADS, --threads THREADS
                          This specifies how many threads to allow snakemake
                          to have access to for parallelization
  ```




  I am working on a test to verify installation. As a workaround, you are able to download a test genome that contains microcin, MFP, PCAT, and immunity protein from https://github.com/wilkelab/cinful/blob/main/test/.

  Once you've downloaded the test file, you can run *cinful* on the contents and compare the output to the results stored in the directory cinful_out.



  *cinful* takes a directory containing genome assemblies as input. All assemblies in the directory must contain the extension `.fna`. If they end in a different extension, they will be ignored.

  Nested directories will explored recursively, and all `\*.fna` files will be analyzed by *cinful*. Nested directories can be a good way to explore output, as the directory tree will be stored as a part of the *cinful_id* in the output files.

  Snakemake is the core workflow management used by cinful -- the main snakefile is located under cinful/Snakefile, which issues subroutines located in cinful/rules.

  *cinful* has been tested on Linux and MacOS.



  With *cinful*, the following workflow will be executed.
  ![cinful](figures/cinful_workflow.inkscape.svg)


  **00_dbs**
  * This is the initial location of the databases of verified microcins, CvaB, and immunity proteins.
  **01_orf_homology**
  * Prodigal will generate Open Reading Frame (ORF) predictions for the input assemblies
  * Those ORFs will be searched against the previously mentioned databases
  **02_homology_results**
  * The results from all the homology searches will be merged here
  **03_best_hits**
  * The top hits from the homology results will be placed here



  Clone this repository:

  ```bash
  git clone https://github.com/wilkelab/cinful.git
  ```
  All software dependencies needed to run *cinful* are available through conda and are specified in `cinful_conda.yml`, the following helper script can be used to generate the *cinful* conda environment `scripts/build_conda_env.sh`, to run this script, you will need to have conda installed, as well as mamba (which helps speed up installation). To install mamba, use the following command:

  ```bash
  conda install mamba -c conda-forge
  ```

  To build the environment, run:
  ```bash
  bash env/build_conda_env.sh
  ```

  Once setup is complete, you can activate the environment with:
  ```bash
  conda activate cinful
  ```

  There is a test dataset with an _E. coli_ genome assembly to test *cinful* on under `test/colcinV_Ecoli`, you can run *cinful* on this dataset by running the following from the initial *cinful* directory:
  ```bash
  python path/to/cinful.py -d <genomes_directory> -o <output_directory> -t <threads>
  ```



  *cinful* currently exists as a wrapper to a series of snakemake subroutines, so adding functionality to it is as simple as adding additional subroutines. If there are any subroutines that you see are needed, feel free to raise an issue, and I will be glad to guide you through the process of making a pull request to add that feature.

  Additionally, since *cinful* primarily works through snakemake, it can also be used by simply running the snakefiles separately, so if additional configuration is needed, in terms of the types of input files, this can probably be achieved that way.


pkgId: e1dac07f055906135d4c34d83b368fdaf91d19e78844176b740505326a098f89
name: python-ciopath
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Object-oriented platform-transparent path manipulations.
url: https://github.com/ConductorTechnologies/sequence
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ciopath-1.1.2-1.src.rpm
checksum_type: sha256
description:
  Object-oriented platform-transparent path manipulations



  ```bash
  pip install ciopath
  ```





  ```
  python -m unittest discover -v -s ./tests  -p 'test_*.py'
  ```



  Pull requests welcome.


  [MIT](LICENSE)


pkgId: c86cdae65b4bab6bf5389f48e7d49ccebe1007df278b0a74184d87d1ec0db36f
name: python-cioseq
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Manage sequences of frame numbers.
url: https://github.com/ConductorTechnologies/cioseq
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cioseq-0.5.1-1.src.rpm
checksum_type: sha256
description:
  Manage sequences of frame numbers



  ```bash
  pip install cioseq
  ```



  Import
  ```
  >>> from cioseq.sequence import Sequence
  ```

  Several ways to create a Sequence using the `create()` factory method.
  ```


  >>> s = Sequence.create("1")

  >>> s = Sequence.create(1,10,2)


  >>> s = Sequence.create([5,6,7,10,12])


  >>> s = Sequence.create("1-10x2")


  >>> s = Sequence.create("0-10x3, 100, -10--2x2")


  >>> s = Sequence.create(prefix="/path/to/images/image.", extension=".exr")

  NOTE: You must provide both prefix and extension, even if they are empty strings


  >>> s2 = Sequence.create(s)
  >>> s2 == s
  False
  >>> list(s2) == list(s)
  True

  >>> list(s)
  [-10, -8, -6, -4, -2, 0, 3, 6, 9, 100]

  >>> print(s)
  -10-0x2,3-9x3,100

  >>> repr(s)
  "Sequence.create('-10-0x2,3-9x3,100')"
  ```

  Indexing
  ```
  >>> s[-1]
  100

  s[0]
  -10
  ```

  An arithmetic progression is a set of numbers with a common step.
  ```
  >>> s = Sequence.create([1,4,7,10,13])
  >>> type(s)
  <class 'cioseq.sequence.Progression'>

  >>> s=Sequence.create([1,2,3,5,78])
  >>> type(s)
  <class 'cioseq.sequence.Sequence'>
  >>> s.is_progression()
  False

  ```

  Chunks
  ```

  >>> s = Sequence.create("1-20", chunk_size=5)
  >>> s.chunk_count()
  4
  >>> s.chunks()
  [Sequence.create('1-5'), Sequence.create('6-10'), Sequence.create('11-15'), Sequence.create('16-20')]


  >>> s.chunk_strategy = "cycle"
  >>> for c in s.chunks():
  ...    print(list(c))

  [1, 5, 9, 13, 17]
  [2, 6, 10, 14, 18]
  [3, 7, 11, 15, 19]
  [4, 8, 12, 16, 20]



  >>> s = Sequence.create("1-100")
  >>> s.chunk_size = 10
  >>> s.cap_chunk_count(3)
  >>> s.chunk_count()
  3
  >>> s.chunk_size
  34
  ```


  Booleans
  ```
  >>> s = Sequence.create("1-10")
  >>> isect = s.intersection(range(5, 15))
  >>> print(isect)
  5-10


  >>> s = Sequence.create("1-10")
  >>> uni = s.union(range(5, 15))
  >>> print(uni)
  1-14

  ```

  Intersecting chunks. Helps to determine which tasks contain scout frames.

  ```
  >>> s = Sequence.create("1-50", chunk_size=5)
  >>> scout =  Sequence.create("1,2,7")
  >>> chunks = s.intersecting_chunks(scout)
  >>> print(chunks)
  [Sequence.create('1-5'), Sequence.create('6-10')]
  ```

  Multi sequence filename permutations

  ```

  >>> template = "/path/d/image.04d.tif"
  >>> filenames = list(Sequence.permutations(template, frame="0-6x2"))
  >>> print(filenames)
  ['/path/0/image.0000.tif', '/path/2/image.0002.tif', '/path/4/image.0004.tif', '/path/6/image.0006.tif']


  >>> template = "image_02d_02d.04d.tif"
  >>> kw = {"uval": "1-2", "vval": "1-2", "frame": "10-11"}
  >>> filenames = Sequence.permutations(template, **kw)

  >>> print(filenames)
  <generator object permutations at 0x10260f960>

  >>> for f in filenames:
  ...    print f

  image_01_01.0010.tif
  image_01_02.0010.tif
  image_02_01.0010.tif
  image_02_02.0010.tif
  image_01_01.0011.tif
  image_01_02.0011.tif
  image_02_01.0011.tif
  image_02_02.0011.tif
  ```

  Offset
  ```
  >>> s = Sequence.create("1-10")
  >>> s = s.offset(-5)
  >>> print(s)
  -4-5
  ```

  Hash (#) filename expansion

  ```
  >>> s = Sequence.create("8-10")
  s.expand("image.#.exr")
  ['image.8.exr', 'image.9.exr', 'image.10.exr']

  s.expand("/some/dir_###/img.#####.exr")
  ['/some/dir_008/img.00008.exr', '/some/dir_009/img.00009.exr', '/some/dir_010/img.00010.exr']
  ```

  Dollar(n)F filename expansion

  ```
  >>> s = Sequence.create("1")
  >>> s.expand_dollar_f("image.$F.exr")
  ['image.1.exr']

  >>> s.expand_dollar_f("image.$F.$5F.$2F.exr")
  ['image.1.00001.01.exr']

  ```

  Use different symbols for frame spec
  ```
  >>> s = Sequence.create("1-10, 14, 20-48x4")
  >>> print(s)
  1-10,14,20-48x4

  >>> print(s.to(":", "%", ";"))
  1:10;14;20:48%4

  >>> print(s.to("to", "by", " "))
  1to10 14 20to48by4

  ```

  Reformat with no step separator
  ```
  >>> s = Sequence.create("1-10x2,22-25")
  >>> print(s.to("-", "", ","))
  1,3,5,7,9,22-25
  ```


  Take a subsample of frames
  ```
  s = Sequence.create("1-10")
  >>> print(s.subsample(1))
  6

  >>> print(s.subsample(2))
  3-8x5

  >>> print(s.subsample(3))
  2-6x4,9

  >>> print(s.subsample(5))
  2-10x2

  >>> print(list(s.subsample(4)))
  [2, 4, 7, 9]
  ```



  From git repo
  ```
  python -m unittest discover -v -s ./tests  -p 'test_*.py'
  ```




  Clone the repo.

  ```
  git clone git@github.com:ConductorTechnologies/cioseq.git
  cd cioseq
  ```

  Set up a clean virtual envirionment with Python 2.7 for development (optional).

  ```
  python -m virtualenv venv
  . ./venv/bin/activate
  ```

  Install development dependencies
  ```
  pip install -r requirements_dev.txt
  ```

  pip install --upgrade .

  ```





  Adds a method, cap_chunk_count(), to limit the number of chunks. Chunk size is adjusted accordingly.



  * Adds a boolean difference method to the Sequence class.



  * adds the abilliity to build a sequence from files on disk



  * the `to()` function now handles an empty string for step separator, which enables frame spec strings compatible with Katana's command-line.



  * Simple edit to remove circle test release. [b92a2c9]




  * Implemented a feature to calculate first, middle, and last frames.



  * Added tests for step and irregular sequences. [742d4c4]



  * Use range without importing builtins. [f148290]



  * Removed builtins module to avoid py2/3 errors. [f148290]



  * CICD tweaks and readme. [b9d05ac]



  * Universal flag. [958ef56]
  * Adds pip-dependency-file key. [719ec31]



  * Adds ssh key so we can push the tag in circleci. [60360af]
  * Use skulk context. [3459bc0]



  * Fixed wrong pypi registry. [a3d82e1]



  * Adds release flow to circleci. [71bbca2]
  * Add .circleci/config.yml. [30fd9d9]
  * Adds tox for py 2.7 and 3.8. [7ce0970]



  * Bad test name and $f4 token support. [f3c1923]



  * Added several examples to the README and implemented and indexing. [fdec3b4]



  * Python 2 and 3 compatibility. [4aba985]



  * Transfer from core. As such, this is the first changelog entry. [54f9132]
  * Sequence consumers must use factory. [a9fd08a]
  * Adds cycle_progressions chunk strategy. [37075c9]
  * Expander path list enhancements (#5)
  * Lib enhancements (#4)
  * adds sequence intersection check
  * allows uppercase characters in angle-bracket template.. [255f61f]
  * Initial commit. [7cf8fd3]


  --


pkgId: 5b8a2fccae633ec6c60c7a93602c5bef5dc266981e4219265a62585292d037da
name: python-cipher-craftt
arch: src
version: 0.1.18
epoch: 0
release: 1
url: https://github.com/jarvismayur/ciphercraft
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cipher-craftt-0.1.18-1.src.rpm
checksum_type: sha256
summary:
  A comprehensive tool for password management including generation, strength checking, expiry tracking, and secure sharing.

description:
  CipherCraft is a versatile and secure password generator designed to help you create strong, memorable passwords with ease. With a range of customizable features and unique tools, CipherCraft ensures your passwords are not only secure but also tailored to your needs.

  - For detailed documentation and usage instructions, please visit our [Read the Docs page](https://cipher-craftt.readthedocs.io).
  - You can also explore the source code and contribute to the project on our [GitHub repository](https://github.com/jarvismayur/cipher-craftt).


  CipherCraft offers a wide range of features to help you securely generate, manage, and share passwords and passphrases:

  1. **Password and Passphrase Generation**
  - **Random Password Generator**: Generate strong, random passwords with customizable options such as length, inclusion/exclusion of uppercase letters, lowercase letters, digits, and special characters.
  - **Context-Aware Password Generator**: Generate passwords tailored to specific contexts, such as finance, social media, or work environments.
  - **Mnemonic Password Generator**: Create mnemonic-based passwords using a custom wordlist, making them easier to remember.
  - **Passphrase Generator**: Generate secure passphrases composed of random words from a user-defined wordlist, with customizable separators.
  2. **Password Strength and Entropy**
  - **Password Strength Checker**: Evaluate the strength of a given password to ensure its robustness against attacks.
  - **Entropy Calculator**: Calculate the entropy of a password, giving you an indication of its unpredictability and security level.
  3. **Password History Management**
  - **Password History Checker**: Verify if a password has been used before, helping to prevent reuse of old passwords.
  - **Password Expiry Checker**: Check if a password has expired based on a specified number of days.
  - **Password Creation Recorder**: Record the creation date of a new password for tracking and expiry purposes.
  - **Limit Password History**: Set a limit on the number of stored passwords in history to maintain a clean and secure password management process.
  4. **Obfuscation and Pronunciation Guide**
  - **Password Obfuscator**: Obfuscate your password to different levels (1, 2, or 3) for enhanced security.
  - **Pronunciation Guide**: Generate a pronunciation guide for a given password to make it easier to recall.
  5. **Secure Sharing and Breach Detection**
  - **Secure Password Sharing**: Encrypt and securely share passwords using a generated key.
  - **Password Decryption**: Decrypt a shared password using the provided key.
  - **Data Breach Checker**: Check if your password has been involved in any known data breaches, ensuring its safety.
  6. **Time-Based One-Time Password (TOTP)**
  - **TOTP Generation**: Generate a Time-Based One-Time Password (TOTP) using a provided secret, for use in two-factor authentication.
  - **TOTP Verification**: Verify the validity of a TOTP using the provided secret and OTP.
  7. **Advanced Customization**
  - **Salting**: Apply passphrase-based salting to generated passwords for added security.
  - **Personalization**: Incorporate personalized inputs (e.g., names, favorite numbers) into password generation for more tailored security.
  - **Common Words Filtering**: Exclude common words from the password using a custom dictionary file to enhance password security.



  You can install CipherCraft via PyPI:

  ```bash
  pip install cipher-craftt
  ```


  To ensure you have the latest features and improvements, you can easily update the CipherCraft package using pip. Open your command line interface and run the following command:

  ```bash
  pip install --upgrade cipher-craftt
  ```
  This command will update your CipherCraft package to the latest version available on [PyPI](https://pypi.org/project/cipher-craftt/).


  To use the CLI, run the following command:

  ```bash
  python cli.py [options]
  ```

  1. **Password Generation**
  - `--generate-password`: Generates a random password.

  ```bash
  python cli.py --generate-password
  ```
  Options:

  - `-l, --length`: Length of the generated password (default: 12).
  - `-u, --no-upper`: Exclude uppercase letters.
  - `-lo, --no-lower`: Exclude lowercase letters.
  - `-d, --no-digits`: Exclude digits.
  - `-s, --no-special`: Exclude special characters.
  - `--exclude-chars`: Characters to exclude from the password.
  - `--min-digits`: Minimum number of digits required (default: 0).
  - `--min-special`: Minimum number of special characters required (default: 0).
  - `--salting`: Apply passphrase-based salting to the password.
  - `--personalization`: Personalized input to include in the password.
  - `--file_path`: Path to a file containing common words (e.g., common_words.txt).
  - `--obfuscate`: Apply obfuscation to the password (level 1, 2, or 3).

  2. **Passphrase Generation**
  -  `--generate-passphrase`: Generates a passphrase based on a word list.

  ```bash
  python cli.py --generate-passphrase
  ```
  Options:

  - `--num-words`: Number of words in the passphrase (default: 4).
  - `--separator`: Separator between words in the passphrase (default: '-').
  - `--obfuscate`: Apply obfuscation to the passphrase (level 1, 2, or 3).
  - `--wordlist` : Your custom wordlist can also be used.
  - `--language`: Multiple language wordlist available.
    - `da` : Danish
    - `de` : German
    - `en` : Enlish ( default )
    - `es` : Spanish
    - `fr` : French
    - `it` : Italian
    - `nl` : Dutch
    - `no` : Norwegian
    - `pl` : Polish
    - `pt` : Portuguese
    - `sv` : Swedish
    - `tr` : Turkish

  1. **Password Entropy**
  - `--calculate-entropy`: Calculate the entropy of a given password.

  ```bash
  python cli.py --calculate-entropy your_password
  ```
  4. **Password Expiry Check**
  - `--check-expiry`: Check if a password has expired.

  ```bash
  python cli.py --check-expiry your_password
  ```
  Options:

  - `--expiry-days`: Number of days before a password expires (default: 90).
  5. **Password History Management**
  - `--record-password`: Record the creation date of a new password.

  ```bash
  python cli.py --record-password your_password
  ```
  - `--check-history`: Check if a password has been used before.

  ```bash
  python cli.py --check-history your_password
  ```
  - `--max-history`: Limit the number of stored passwords in history.

  ```bash
  python cli.py --max-history 100
  ```
  6. **Data Breach Check**
  - `--check-breach`: Check if a password has been involved in a data breach.

  ```bash
  python cli.py --check-breach your_password
  ```
  7. **Secure Password Sharing**
  - `--share-password`: Encrypt and share a password securely.

  ```bash
  python cli.py --share-password your_password
  ```
  - `--decrypt-password`: Decrypt a shared password.

  ```bash
  python cli.py --decrypt-password encrypted_password key
  ```
  8. **Pronunciation Guide**
  - `--pronunciation-guide`: Generate a pronunciation guide for a password.

  ```bash
  python cli.py --pronunciation-guide your_password
  ```
  9. **Password Strength Check**
  - `--check-strength`: Check the strength of the given password.

  ```bash
  python cli.py --check-strength your_password
  ```
  10. **Mnemonic Password Generation**
  - `--generate-mnemonic`: Generate a mnemonic-based password.

  ```bash
  python cli.py --generate-mnemonic --wordlist path/to/wordlist.txt
  ```
  Options:

  - `--num-words`: Number of words in the mnemonic password (default: 4).
  - `--separator`: Separator between words in the mnemonic password (default: '-').
  - `--length`: Length of the mnemonic password.
  11. **Context-Aware Password Generation**
  - `--context`: Specify the context for the password generation (e.g., finance, social, work).

  ```bash
  python cli.py --generate-password --context finance
  ```
  12. TOTP (Time-based One-Time Password)
  - `--generate-totp`: Generate a TOTP using the provided secret.

  ```bash
  python cli.py --generate-totp your_secret
  ```
  - `--verify-totp`: Verify a TOTP using the provided secret and OTP.

  ```bash
  python cli.py --verify-totp your_secret your_otp
  ```

  - Generate a password with specific constraints:

  ```bash
  python cli.py --generate-password -l 16 --no-special --min-digits 2 --personalization "MySecret!"
  ```
  - Generate a passphrase with a custom word list and separator:

  ```bash
  python cli.py --generate-passphrase --wordlist path/to/wordlist.txt --separator "_"
  ```
  - Check if a password has expired:

  ```bash
  python cli.py --check-expiry your_password --expiry-days 60
  ```
  - Encrypt and share a password securely:

  ```bash
  python cli.py --share-password your_password
  ```
  - Generate a TOTP:

  ```bash
  python cli.py --generate-totp your_secret
  ```



  CipherCraft is licensed under the MIT [License](https://github.com/jarvismayur/Cipher_Craftt/blob/main/LICENSE). See the LICENSE file for details.


  If you have any questions, suggestions, or encounter issues, please feel free to [open an issue](https://github.com/yourusername/cipher-craftt/issues) on the GitHub repository. For direct communication, you can reach out to Mayur Tembhare via [email](mailto:tembharemayur@gmail.com) .


pkgId: 38db68f3b4cbe408ee6fd78d09a6e68264dad122e354fb1282728af4644d81f5
name: python-ciphey
arch: src
version: 5.14.0
epoch: 0
release: 1
summary: Automated Decryption Tool
url: https://pypi.org/project/ciphey/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ciphey-5.14.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  Translations <br>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/de/README.md>🇩🇪 DE   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/fr/README.md>🇫🇷 FR   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/hu/README.md>🇭🇺 HU   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/id/README.md>🇮🇩 ID   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/it/README.md>🇮🇹 IT   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/nl/README.md>🇳🇱 NL   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/pt-br/README.md>🇧🇷 PT-BR   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/ru/README.md>🇷🇺 RU   </a>
  <a href=https://github.com/Ciphey/Ciphey/tree/master/translations/zh/README.md>🇨🇳 ZH   </a>
   <br><br>
  ➡️
  <a href="https://github.com/Ciphey/Ciphey/wiki">Documentation</a> |
  <a href="https://discord.gg/zYTM3rZM4T">Discord</a> |
   <a href="https://github.com/Ciphey/Ciphey/wiki/Installation">Installation Guide</a>
   ⬅️

  <br>
    <img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/binoculars.png" alt="Ciphey">
  </p>

  <p align="center">
  <img src="https://pepy.tech/badge/ciphey">
   <img src="https://pepy.tech/badge/ciphey/month">
    <a href="https://discord.gg/zYTM3rZM4T"><img alt="Discord" src="https://img.shields.io/discord/754001738184392704"></a>
  <a href="https://pypi.org/project/ciphey/"><img src="https://img.shields.io/pypi/v/ciphey.svg"></a>
    <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="Ciphey">

  <br>
  Fully automated decryption/decoding/cracking tool using natural language processing & artificial intelligence, along with some common sense.
  </p>
  <hr>



  | <p align="center"><a href="https://pypi.org/project/ciphey">🐍 Python | <p align="center"><a href="https://hub.docker.com/r/remnux/ciphey">🐋 Docker (Universal) | <p align="center"><a href="https://ports.macports.org/port/ciphey/summary">🍎 MacPorts (macOS)|
  | --------------------------------------------------------------------- | --------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
  | <p align="center"><img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/python.png" /></p>    | <p align="center"><img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/docker.png" /></p>                | <p align="center"><img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/macports.png" /></p>                |
  | `python3 -m pip install ciphey --upgrade`                             | `docker run -it --rm remnux/ciphey`                                               |  `sudo port install ciphey`                                               |

  | Linux                                                                                                                   | Mac OS                                                                                                                     | Windows                                                                                                                   |
  | ----------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
  | ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/ciphey/ciphey/Python%20application?label=Linux) | ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/ciphey/ciphey/Python%20application?label=Mac%20OS) | ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/ciphey/ciphey/Python%20application?label=Windows) |

  <hr>



  Input encrypted text, get the decrypted text back.

  > "What type of encryption?"

  That's the point. You don't know, you just know it's possibly encrypted. Ciphey will figure it out for you.

  Ciphey can solve most things in 3 seconds or less.

  <p align="center" href="https://asciinema.org/a/336257">
    <img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/index.gif" alt="Ciphey demo">
  </p>

  Ciphey aims to be a tool to automate a lot of decryptions & decodings such as multiple base encodings, classical ciphers, hashes or more advanced cryptography.

  If you don't know much about cryptography, or you want to quickly check the ciphertext before working on it yourself, Ciphey is for you.

  **The technical part.** Ciphey uses a custom built artificial intelligence module (_AuSearch_) with a _Cipher Detection Interface_ to approximate what something is encrypted with. And then a custom-built, customisable natural language processing _Language Checker Interface_, which can detect when the given text becomes plaintext.

  No neural networks or bloated AI here. We only use what is fast and minimal.

  And that's just the tip of the iceberg. For the full technical explanation, check out our [documentation](https://github.com/Ciphey/Ciphey/wiki).



  - **50+ encryptions/encodings supported** such as binary, Morse code and Base64. Classical ciphers like the Caesar cipher, Affine cipher and the Vigenere cipher. Along with modern encryption like repeating-key XOR and more. **[For the full list, click here](https://github.com/Ciphey/Ciphey/wiki/Supported-Ciphers)**
  - **Custom Built Artificial Intelligence with Augmented Search (AuSearch) for answering the question "what encryption was used?"** Resulting in decryptions taking less than 3 seconds.
  - **Custom built natural language processing module** Ciphey can determine whether something is plaintext or not. Whether that plaintext is JSON, a CTF flag, or English, Ciphey can get it in a couple of milliseconds.
  - **Multi Language Support** at present, only German & English (with AU, UK, CAN, USA variants).
  - **Supports encryptions and hashes** Which the alternatives such as CyberChef Magic do not.
  - **[C++ core](https://github.com/Ciphey/CipheyCore)** Blazingly fast.





  <table>
    <tr>
    <th>Name</th>
      <th>⚡ Ciphey ⚡ </th>
      <th>🐢 CyberChef 🐢</th>
    </tr>
    <tr>
    <th>Gif</th>
      <td><img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/ciphey_gooder_cyberchef.gif" alt="The guy she tells you not to worry about"></td>
      <td><img src="https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/not_dying.gif" alt="You"></td>
    </tr>
    <tr>
    <th>Time</th>
      <td>2 seconds</td>
      <td>6 seconds</td>
    </tr>
      <tr>
    <th>Setup</th>
      <td><ul><li>Run ciphey on the file</li></ul></td>
      <td><ul><li>Set the regex param to "{"</li><li>You need to know how many times to recurse</li><li>You need to know it's Base64 all the way down</li><li>You need to load CyberChef (it's a bloated JS app)</li><li>Know enough about CyberChef to create this pipeline</li><li>Invert the match</li></ul></td>
    </tr>
  </table>

  <sub><b>Note</b> The gifs may load at different times, so one may appear significantly faster than another.</sub><br>
  <sub><b>A note on magic </b>CyberChef's most similar feature to Ciphey is Magic. Magic fails instantly on this input and crashes. The only way we could force CyberChef to compete was to manually define it.</sub>

  We also tested CyberChef and Ciphey with a **6gb file**. Ciphey cracked it in **5 minutes and 54 seconds**. CyberChef crashed before it even started.



  | **Name**                                   | ⚡ Ciphey ⚡ | 🗡️ Katana 🗡️ | 🐢 CyberChef Magic 🐢 |
  | ------------------------------------------ | ------------ | ------------ | --------------------- |
  | Advanced Language Checker                  | ✅           | ❌           | ✅                    |
  | Supports Encryptions                       | ✅           | ✅           | ❌                    |
  | Releases named after Dystopian themes 🌃   | ✅           | ❌           | ❌                    |
  | Supports hashes                            | ✅           | ✅           | ❌                    |
  | Easy to set up                             | ✅           | ❌           | ✅                    |
  | Can guess what something is encrypted with | ✅           | ❌           | ❌                    |
  | Created for hackers by hackers             | ✅           | ✅           | ❌                    |



  If you're having trouble with installing Ciphey, [read this.](https://github.com/Ciphey/Ciphey/wiki/Common-Issues-&-Their-Solutions)



  | Installation Guide                                                          | Documentation                                             | Discord                                     | Docker Image (from REMnux)                                                                          |
  | --------------------------------------------------------------------------- | --------------------------------------------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------------- |
  | 📖 [Installation Guide](https://github.com/Ciphey/Ciphey/wiki/Installation) | 📚 [Documentation](https://github.com/Ciphey/Ciphey/wiki) | 🦜 [Discord](https://discord.gg/zYTM3rZM4T) | 🐋 [Docker Documentation](https://docs.remnux.org/run-tools-in-containers/remnux-containers#ciphey) |



  There are 3 ways to run Ciphey.

  1. File Input `ciphey -f encrypted.txt`
  2. Unqualified input `ciphey -- "Encrypted input"`
  3. Normal way `ciphey -t "Encrypted input"`

  ![Gif showing 3 ways to run Ciphey](https://github.com/Ciphey/Ciphey/raw/master/Pictures_for_README/3ways.gif)

  To get rid of the progress bars, probability table, and all the noise use the quiet mode.

  `ciphey -t "encrypted text here" -q`

  For a full list of arguments, run `ciphey --help`.



  You can import Ciphey\'s main and use it in your own programs and code. `from Ciphey.__main__ import main`



  Ciphey was invented by [Bee](https://github.com/bee-san) in 2008, and revived in 2019. Ciphey wouldn't be where it was today without [Cyclic3](https://github.com/Cyclic3) - president of UoL's Cyber Security Society.

  Ciphey was revived & recreated by the [Cyber Security Society](https://www.cybersoc.cf/) for use in CTFs. If you're ever in Liverpool, consider giving a talk or sponsoring our events. Email us at `cybersecurity@society.liverpoolguild.org` to find out more 🤠

  **Major Credit** to George H for working out how we could use proper algorithms to speed up the search process.
  **Special thanks** to [varghalladesign](https://www.facebook.com/varghalladesign) for designing the logo. Check out their other design work!



  Don't be afraid to contribute! We have many, many things you can do to help out. Each of them labelled and easily explained with examples. If you're trying to contribute but stuck, tag @bee-san ✨

  Alternatively, join the Discord group and send a message there (link in [contrib file](https://github.com/Ciphey/Ciphey/wiki/Contributing)) or at the top of this README as a badge.

  Please read the [contributing file](https://github.com/Ciphey/Ciphey/wiki/Contributing) for exact details on how to contribute ✨

  By doing so, you'll get your name added to the README below and get to be apart of an ever-growing project!
  [![Stargazers over time](https://starchart.cc/Ciphey/Ciphey.svg)](https://starchart.cc/Ciphey/Ciphey)



  The contributions will be used to fund not only the future of Ciphey and its authors, but also Cyber Security Society at the University of Liverpool.

  GitHub doesn't support "sponsor this project and we'll evenly distribute the money", so pick a link and we'll sort it out on our end 🥰



  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://github.com/Cyclic3"><img src="https://avatars1.githubusercontent.com/u/15613874?v=4?s=100" width="100px;" alt=""/><br /><sub><b>cyclic3</b></sub></a><br /><a href="#design-cyclic3" title="Design">🎨</a> <a href="#maintenance-cyclic3" title="Maintenance">🚧</a> <a href="https://github.com/Ciphey/Ciphey/commits?author=cyclic3" title="Code">💻</a> <a href="#ideas-cyclic3" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://skerritt.blog"><img src="https://avatars3.githubusercontent.com/u/10378052?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Brandon</b></sub></a><br /><a href="#design-brandonskerritt" title="Design">🎨</a> <a href="#maintenance-brandonskerritt" title="Maintenance">🚧</a> <a href="https://github.com/Ciphey/Ciphey/commits?author=brandonskerritt" title="Code">💻</a> <a href="#ideas-brandonskerritt" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://github.com/michalani"><img src="https://avatars0.githubusercontent.com/u/27767884?v=4?s=100" width="100px;" alt=""/><br /><sub><b>michalani</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=michalani" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/ashb07"><img src="https://avatars2.githubusercontent.com/u/24845568?v=4?s=100" width="100px;" alt=""/><br /><sub><b>ashb07</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=ashb07" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/TheAlcanian"><img src="https://avatars3.githubusercontent.com/u/22127191?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Shardion</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/issues?q=author%3ATheAlcanian" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/Bryzizzle"><img src="https://avatars0.githubusercontent.com/u/57810197?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Bryan</b></sub></a><br /><a href="#translation-Bryzizzle" title="Translation">🌍</a> <a href="https://github.com/Ciphey/Ciphey/commits?author=Bryzizzle" title="Documentation">📖</a></td>
      <td align="center"><a href="https://lukasgabriel.net"><img src="https://avatars0.githubusercontent.com/u/52338810?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Lukas Gabriel</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=lukasgabriel" title="Code">💻</a> <a href="https://github.com/Ciphey/Ciphey/issues?q=author%3Alukasgabriel" title="Bug reports">🐛</a> <a href="#translation-lukasgabriel" title="Translation">🌍</a> <a href="#ideas-lukasgabriel" title="Ideas, Planning, & Feedback">🤔</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/DarshanBhoi"><img src="https://avatars2.githubusercontent.com/u/70128281?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Darshan</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/issues?q=author%3ADarshanBhoi" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/SkeletalDemise"><img src="https://avatars1.githubusercontent.com/u/29117662?v=4?s=100" width="100px;" alt=""/><br /><sub><b>SkeletalDemise</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=SkeletalDemise" title="Code">💻</a></td>
      <td align="center"><a href="https://www.patreon.com/cclauss"><img src="https://avatars3.githubusercontent.com/u/3709715?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Christian Clauss</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=cclauss" title="Code">💻</a> <a href="https://github.com/Ciphey/Ciphey/issues?q=author%3Acclauss" title="Bug reports">🐛</a></td>
      <td align="center"><a href="http://machinexa.xss.ht"><img src="https://avatars1.githubusercontent.com/u/60662297?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Machinexa2</b></sub></a><br /><a href="#content-machinexa2" title="Content">🖋</a></td>
      <td align="center"><a href="https://github.com/anantverma275"><img src="https://avatars1.githubusercontent.com/u/18184503?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Anant Verma</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=anantverma275" title="Code">💻</a> <a href="https://github.com/Ciphey/Ciphey/issues?q=author%3Aanantverma275" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/XVXTOR"><img src="https://avatars1.githubusercontent.com/u/40268197?v=4?s=100" width="100px;" alt=""/><br /><sub><b>XVXTOR</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=XVXTOR" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/Itamikame"><img src="https://avatars2.githubusercontent.com/u/59034423?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Itamikame</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=Itamikame" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/MikeMerz"><img src="https://avatars3.githubusercontent.com/u/50526795?v=4?s=100" width="100px;" alt=""/><br /><sub><b>MikeMerz</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=MikeMerz" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/jacobggman"><img src="https://avatars2.githubusercontent.com/u/30216976?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jacob Galam</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=jacobggman" title="Code">💻</a> <a href="https://github.com/Ciphey/Ciphey/issues?q=author%3Ajacobggman" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://tuxthexplorer.github.io/"><img src="https://avatars1.githubusercontent.com/u/37508897?v=4?s=100" width="100px;" alt=""/><br /><sub><b>TuxTheXplorer</b></sub></a><br /><a href="#translation-TuxTheXplorer" title="Translation">🌍</a></td>
      <td align="center"><a href="https://github.com/Itamai"><img src="https://avatars3.githubusercontent.com/u/53093696?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Itamai</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=Itamai" title="Code">💻</a> <a href="https://github.com/Ciphey/Ciphey/issues?q=author%3AItamai" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/Termack"><img src="https://avatars2.githubusercontent.com/u/26333901?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Filipe</b></sub></a><br /><a href="#translation-Termack" title="Translation">🌍</a></td>
      <td align="center"><a href="https://github.com/malathit"><img src="https://avatars0.githubusercontent.com/u/2684148?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Malathi</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=malathit" title="Code">💻</a></td>
      <td align="center"><a href="https://hexchaos.xyz/"><img src="https://avatars1.githubusercontent.com/u/8947820?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Jack</b></sub></a><br /><a href="#translation-HexChaos" title="Translation">🌍</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/yafkari"><img src="https://avatars3.githubusercontent.com/u/41365655?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Younes</b></sub></a><br /><a href="#translation-yafkari" title="Translation">🌍</a></td>
      <td align="center"><a href="https://gitlab.com/Marnick39"><img src="https://avatars2.githubusercontent.com/u/17315511?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Marnick Vandecauter</b></sub></a><br /><a href="#translation-Marnick39" title="Translation">🌍</a></td>
      <td align="center"><a href="https://github.com/mav8557"><img src="https://avatars0.githubusercontent.com/u/47306745?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Michael V</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=mav8557" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/chuinzer"><img src="https://avatars2.githubusercontent.com/u/64257785?v=4?s=100" width="100px;" alt=""/><br /><sub><b>chuinzer</b></sub></a><br /><a href="#translation-chuinzer" title="Translation">🌍</a></td>
      <td align="center"><a href="https://github.com/blackcat-917"><img src="https://avatars1.githubusercontent.com/u/53786619?v=4?s=100" width="100px;" alt=""/><br /><sub><b>blackcat-917</b></sub></a><br /><a href="#translation-blackcat-917" title="Translation">🌍</a> <a href="https://github.com/Ciphey/Ciphey/commits?author=blackcat-917" title="Documentation">📖</a></td>
      <td align="center"><a href="https://github.com/Ozzyz"><img src="https://avatars3.githubusercontent.com/u/6113447?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Åsmund Brekke</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=Ozzyz" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/sashreek1"><img src="https://avatars1.githubusercontent.com/u/45600974?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Sashreek Shankar</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=sashreek1" title="Code">💻</a></td>
    </tr>
    <tr>
      <td align="center"><a href="https://github.com/cryptobadger"><img src="https://avatars2.githubusercontent.com/u/26308101?v=4?s=100" width="100px;" alt=""/><br /><sub><b>cryptobadger</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=cryptobadger" title="Code">💻</a> <a href="https://github.com/Ciphey/Ciphey/issues?q=author%3Acryptobadger" title="Bug reports">🐛</a></td>
      <td align="center"><a href="https://github.com/e1fy"><img src="https://avatars3.githubusercontent.com/u/61194758?v=4?s=100" width="100px;" alt=""/><br /><sub><b>elf</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=e1fy" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/rogercyyu"><img src="https://avatars0.githubusercontent.com/u/45835736?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Roger Yu</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=rogercyyu" title="Code">💻</a></td>
      <td align="center"><a href="https://github.com/JesseEmond"><img src="https://avatars.githubusercontent.com/u/1843555?v=4?s=100" width="100px;" alt=""/><br /><sub><b>dysleixa</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=JesseEmond" title="Code">💻</a></td>
      <td align="center"><a href="http://mohzulfikar.me"><img src="https://avatars.githubusercontent.com/u/48849323?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Mohammad Zulfikar</b></sub></a><br /><a href="https://github.com/Ciphey/Ciphey/commits?author=mohzulfikar" title="Documentation">📖</a></td>
    </tr>
  </table>

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

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

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: 76fd062e4f1fcc2fbad4e3cc89b39c5b2572e1aabfab9381a31b334fe4791b06
name: python-cira
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: A simpler library for the alapaca trade api
url: https://github.com/AxelGard/cira
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cira-3.3.0-1.src.rpm
checksum_type: sha256
description:
  Cira algorithmic trading made easy. A [Façade library](https://refactoring.guru/design-patterns/facade) for simpler interaction with alpaca-trade-API from Alpaca Markets.

  Cira is available on [pip](https://pypi.org/project/cira/). **Please give it a star if you like it!**

  <img src="https://raw.githubusercontent.com/AxelGard/cira/master/docs/img/cira.jpeg" alt="drawing" style="width:300px;"/>

  ![GitHub stars](https://img.shields.io/github/stars/AxelGard/Cira?style=social)
  ![GitHub forks](https://img.shields.io/github/forks/AxelGard/cira?style=social)
  [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/Axel_Gard)

  ![GitHub](https://img.shields.io/github/license/AxelGard/cira?style=plastic)
  ![PyPI](https://img.shields.io/pypi/v/cira)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cira)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/cira)

  The name **cira** is a miss spelling of the word for a [baby alpaca cria](https://en.wikipedia.org/wiki/Cria) and because this is a simple and small lib I thought it would be a perfect fit.

  [Axel Gard](https://github.com/AxelGard) is main developer for cira.



  If you are new to cira checkout the [tutorial](https://github.com/AxelGard/cira/wiki/Tutorial).
  Or checkout an [example](https://github.com/AxelGard/cira/blob/master/examples/linear.ipynb).


  You can install it using [pip](https://pypi.org/project/cira/).
  ```bash
  pip install cira
  ```


  Since the Alpaca trade API need a API key, you need to generate your own key at [alpaca markets website](https://app.alpaca.markets/signup). If you want to play around with it you can try paper trading (recommended for beginners). I recommend keep it in a **JSON file** which cira needs the **path** to.
  You can also set the variables directly or use an environment variable, see the **[wiki](https://github.com/AxelGard/cira/wiki/Storing-the-Alpaca-API-key)** for diffrent the ways. However, it is **recommended** that you store it in a file just make sure not to upload that file on any public repositories.

  You can set the Alpaca keys directly

  ```python
  import cira

  cira.auth.APCA_API_KEY_ID = "my key"
  cira.auth.APCA_API_SECRET_KEY = "my secret key"

  stock = cira.Stock("TSLA")
  stock.buy(1) # buy 1 TSLA stock on alpaca
  stock.sell(1) # sell 1 TSLA stock on alpaca
  ```

  For interactons with alpaca you can:
  ```python
  portfolio = cira.Portfolio() # methods for your portfolio
  exchange = cira.Exchange() # methods for exchange
  stock = cira.Stock("TSLA") # a class for one stock
  crypto = cira.Cryptocurrency("BTC/USD") # method for one cryptocurrency
  ```



  Crypto market data can be accessed [without any alpaca keys](https://alpaca.markets/sdks/python/market_data.html#api-keys).
  So there for you can try cira out with out needing to get alpaca keys.
  To put you model in production where you buy and sell you will need alpaca keys.

  Needs `cira>=3.2.2`.

  ```python
  import cira
  from datetime import datetime
  import matplotlib.pyplot as plt

  assert not cira.auth.check_keys() # No keys are needed

  SYMBOL = "BTC/USD"
  ast = cira.Cryptocurrency(SYMBOL)

  print(f"The current asking price for {SYMBOL} is {ast.price()}")



  data = ast.historical_data_df(datetime(2021, 1, 1), datetime.now().date())
  print(data.head())


  strat = cira.strategy.Randomness()
  cira.strategy.back_test_against_buy_and_hold(strat, data, data["open"].to_frame(), 100_000).plot()
  plt.savefig('./result.png')
  ```

  you can find more examples on the **[examples repo](https://github.com/AxelGard/cira-examples)** and the **[wiki/tutorial](https://github.com/AxelGard/cira/wiki/Tutorial)** for even more information.



  Cira have also support for strategies.
  An **full example** of how to use the strategy is [example/linear](../../examples/linear.ipynb).

  With strategies you can run a cira backtests.

  ```python
  from cira.strategy import Strategy
  import numpy as np
  import pandas as pd

  class MyStrat(Strategy):
      def __init__(self) -> None:
          super().__init__(name="MyStrat")

      def iterate(self, feature_data: pd.DataFrame, prices: pd.DataFrame, portfolio: np.ndarray, cash:float) -> np.ndarray:
          
          
          
          return np.array([ portfolio_change_as_int_or_float ])
  ```



  If your model is put into a strategy you can run a backtest on you own data.
  This is a backtest using some of the included strategy in cira.
  You can run a backtest aginst multiple strategies using the same data, this requires however that all features for all models are in the given data to the backtest.
  You should of course add your own strategy, but as an example.

  ```python
  import cira
  from datetime import datetime
  import matplotlib.pyplot as plt

  assert not cira.auth.check_keys() # back testing against crypto do not need keys

  SYMBOL = "ETH/USD"
  ast = cira.Cryptocurrency(SYMBOL)

  data = ast.historical_data_df(datetime(2021, 1, 1), datetime.now().date())

  strats = [
              cira.strategy.ByAndHold(),
              cira.strategy.DollarCostAveraging(0.8),
              cira.strategy.Randomness(-100, 100, seed=None, use_float=True),
              
          ]
  cira.strategy.multi_strategy_backtest(strats, data, data["open"].to_frame(), 100_000).plot()
  plt.savefig("./result.png")
  ```

  If you want more full example of how to use the backtest checkout
  [multiassets](../../examples/multi_assets.ipynb) and
  [linear](../../examples/linear.ipynb).





  * [News](https://github.com/AxelGard/cira/discussions/categories/news)
  * [Wiki](https://github.com/AxelGard/cira/wiki/)
  * [Tutorial](https://github.com/AxelGard/cira/wiki/Tutorial)
  * [Storing the Alpaca API key](https://github.com/AxelGard/cira/wiki/Storing-the-Alpaca-API-key)
  * [Examples of how to use cira](https://github.com/AxelGard/cira-examples)
  * [Discussions](https://github.com/AxelGard/cira/discussions)



  To see what more you can do check out the [wiki](https://github.com/AxelGard/cira/wiki).



  For backwards compatibility I made sure to fork cira in to [cira-classic](https://github.com/AxelGard/cira-classic) and cira-classic is also available on [pypi with pip](https://pypi.org/project/cira-classic/).

  **If you find bug plz let me know with a issue.** If you know how to solve the problem then you can of course make a pull request and I will take a look at it.



  If you have a question about cira, want to share what you built with cira or want to talk to others using cira,
  you can checkout the [discussions page](https://github.com/AxelGard/cira/discussions) or make issue if that is more fitting.



  I was interested in using the Alpaca trade API for building a quantitative paper trader.
  The project is available [here](https://github.com/AxelGard/paper-trader).<br>
  However after working on this for alomst a year (off and on) I realized that I had alomst build a small library for using the Alpaca API.
  So I thought that I would make this into a real library so that you can get started with quantitative paper trading as well.


  If you want to help develop cira you are more then welcome to do so.
  Feel free to make a pull request or issue.
  To install cira with all the dev req.
  ```bash
  git clone git@github.com:AxelGard/cira.git
  cd cira/
  git checkout develop
  ```
  and know you need to
  ```bash
  python3 -m venv env
  source env/bin/activate
  pip install -e .
  pip install -r requirements.txt
  ```
  Run tests using pytest. Ensure that you are in the cira dir.
  But you will need a new key. This key should not only be used for testing or if you don't mind if all of the assets in the portfolio being sold.
  ```bash
  pytest -rP
  ```


  I'm trying to follow the [pep8](https://pep8.org/) standard notation.
  I try to make the library to be so intuitive as possible for easy of use.

  I enforce [black formater](https://github.com/psf/black) when you commit code, by [pre-commit githooks](https://git-scm.com/docs/githooks#_pre_commit) to keep it some what well formated.



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




  * [Alpaca API](https://alpaca.markets/)
  * [paper-trader](https://github.com/AxelGard/paper-trader)
  * [cira-classic](https://github.com/AxelGard/cira-classic)


pkgId: da5b4df26b86d23a6386728b81ef61ee0cba2da4b6ba91d75ff6450dff15a87a
name: python-circe-certic
arch: src
version: 0.0.48
epoch: 0
release: 1
summary: Circe Server
url: https://pypi.org/project/circe-certic/
rpm_license: CECILL-B
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circe-certic-0.0.48-1.src.rpm
checksum_type: sha256
description:
  API web pour la transformation de documents.



  - [Description du service](#description-du-service)
  	- [Format d'échange](#format-déchange)
  		- [Structure du fichier job.json](#structure-du-fichier-jobjson)
  	- [Web API](#web-api)
  		- [GET /transformations/](#get-transformations)
  		- [POST /job/](#post-job)
  		- [GET /job/[UUID]](#get-jobuuid)
  	- [Notification](#notification)
  - [Serveur de référence](#serveur-de-référence)
  	- [Pré-requis](#pré-requis)
  	- [Installation et démarrage du service](#installation-et-démarrage-du-service)
  	- [Variables d'environnement et configuration par défaut:](#variables-denvironnement-et-configuration-par-défaut)
  	- [Utilisation en ligne de commande](#utilisation-en-ligne-de-commande)
  	- [Authentification](#Authentification)
  	- [Ajouter des transformations](#ajouter-des-transformations)
  - [Clients de référence](#clients-de-référence)
  - [Tests](#tests)
  - [Mise en production](#mise-en-production)






  Le client fournit au serveur une tâche (un _job_) à effectuer sous forme d'une archive tar *gzippée* (*.tar.gz)
  contenant a minima **à sa racine**:

  - les fichiers à transformer
  - un fichier nommé job.json décrivant les transformations souhaitées sur ces fichiers

  On peut également ajouter des fichiers utiles à la conversion, tel que des feuilles de styles ou des fichiers de
  fontes par exemple.



  Est placé dans l'archive un fichier ```job.json``` décrivant l'ensemble des opérations à faire sur les fichiers.

  Un cas minimal:

      {
          "transformations": [
              {"name": "html2pdf"}
          ]
      }

  ... décrit une transformation unique à effectuer sur les documents fournis dans l'archive, sans options.

  La seule clef obligatoire pour le job est la clef ```transformations```, contenant la liste des transformations à faire.
  La seule clef obligatoire pour la transformation est la clef ```name```, contenant le nom de la transformation.

  Un cas plus complet:

      {
          "transformations": [
              {"name": "html2pdf",
               "options": {"compression": 1}},
              {"name": "donothing",}
          ],
          "notify_hook": "http://www.domain.tld/notify-me/"
      }

  ... décrit 2 transformations consécutives, dont une avec une option, ainsi qu'une URL de notification
  (```notify_hook```) qui sera appelée par le serveur à la fin du _job_.

  Les résultats des transformations sont également fournis par le serveur sous forme d'archive tar _gzippée_.





  Retourne une liste JSON des transformations supportées. Exemple:

      ["html2pdf","donothing", "docx2markdown"]



  Attend dans le corps de la requête une archive de _job_ correctement formée.

  Retourne un [UUID version 4](https://fr.wikipedia.org/wiki/Universal_Unique_Identifier#Version_4 "UUID v4") sous
  forme de chaîne de caractères. L'UUID retourné est l'identifiant du _job_, à conserver pour les prochaines requêtes.

  Si l'option ```block=1``` est passée dans l'URL (```/job/?block=1```), alors le comportement est différent: ce n'est
  pas l'UUID qui sera retourné mais directement le résultat des transformations, de manière identique à ```GET /job/[UUID]```.

  En fonction de la configuration du serveur, la soumission d'un nouveau _job_ peut nécessiter une authentification.
  Dans ce cas, l'entête HTTP Authorization doit être renseigné sous la forme suivante:

      Authorization: [UUID de l'application] [signature HMAC de l'archive]

  _Voir le source du client Python pour un exemple de signature HMAC._



  Récupère l'archive contenant les fichiers transformés par le serveur. Exemple:

      curl http://www.domain.tl/job/55d87fe0-3924-423a-893d-23aa45614ad9

  Un statut HTTP 200 est retourné et l'archive avec les documents transformés est contenue dans le corps de la réponse.

  Au cas où le _job_ ne serait pas terminé, un statut HTTP 202 est retourné.

  Au cas où l'UUID fait référence à un _job_ n'existant pas sur ce serveur, un statut HTTP 404 est retourné.

  En fonction de la configuration du serveur, la récupération d'un _job_ terminé peut nécessiter une authentification.
  Dans ce cas, l'entête HTTP Authorization doit être renseigné sous la forme suivante:

      Authorization: [UUID de l'application] [signature HMAC de l'UUID du job]

  _Voir le source du client Python pour un exemple de signature HMAC._



  Dans le cas où une URL a été fournie dans la clef ```notify_hook``` du fichier job.json, le serveur effectue une
  requête POST sur cette URL avec l'UUID du _job_ en corps de requête.



  Un serveur de référence est implémenté en Python. Deux composants sont fournis:

  - un serveur HTTP exposant l'interface HTTP du service
  - un pool de workers effectivement chargés des transformations



  - Python >= 3.6



  Création et activation d'un venv:

      python3 -m venv myvenv
      . ./myvenv/bin/activate

  Installation de Circe:

      pip install circe-CERTIC

  Démarrage du service HTTP:

      circe serve

  Démarrage des workers:

      circe start-workers

  Démarrage simultané du service HTTP et des workers:

      circe run



  - ```CIRCE_HOST``` (```127.0.0.1```)
  - ```CIRCE_PORT``` (```8000```)
  - ```CIRCE_DEBUG``` (```0```)
  - ```CIRCE_WORKERS``` (```number of CPUs```)
  - ```CIRCE_WORKING_DIR``` (```$HOME/.circe/```)
  - ```CIRCE_ENABLE_WEB_UI``` (```0```)
  - ```CIRCE_WEB_UI_CRYPT_KEY``` (```"you should really change this"```)
  - ```CIRCE_WEB_UI_REMOVE_USER_FILES_DELAY``` (```7200```)
  - ```CIRCE_WEB_UI_SECURE_COOKIE``` (```1```)
  - ```CIRCE_USE_AUTH``` (```1```)
  - ```CIRCE_TRANSFORMATIONS_MODULE``` (```None```)

  Vous pouvez renseigner ces variables à différents endroits, en fonction de vos besoins:

  - dans le fichier lu au démarrage de votre shell (~/.zshrc, ~/.bashrc, etc)
  - dans un fichier .env dans votre répertoire de travail (celui où vous vos trouvez quand vous lancez circe)
  - directement avant la commande circe, sur la même ligne

  Exemple type d'un fichier .env:

  	CIRCE_TRANSFORMATIONS_MODULE=mon_module_de_transfos
  	CIRCE_ENABLE_WEB_UI=1
  	CIRCE_WEB_UI_CRYPT_KEY="53CreT"
  	CIRCE_USE_AUTH=0



  Un certain nombre de commande sont disponibles dans circe. Pour les afficher:

      (venv) ➜  src ✗ circe --help
      usage: circe [-h]
                   {serve,start-workers,make-api-access,remove-api-access,list-api-access,list-transformations,run}
                   ...

      positional arguments:
        {serve,start-workers,make-api-access,remove-api-access,list-api-access,list-transformations,run}
          serve               Start Circe HTTP server
          start-workers       Start job workers
          make-api-access     Create new app uuid / secret couple for api access.
          remove-api-access   Remove access to the API
          list-api-access     List all access tokens to the API
          list-transformations
          run                 Start both HTTP server and job workers

      optional arguments:
        -h, --help            show this help message and exit

  Il est possible d'obtenir de l'aide sur chaque commande:

      (venv) ➜  src ✗ circe serve --help
      usage: circe serve [-h] [--host HOST] [-p PORT] [-w WORKERS] [-d] [-a]

      Start Circe HTTP server

      optional arguments:
        -h, --help            show this help message and exit
        --host HOST           '127.0.0.1'
        -p PORT, --port PORT  8000
        -w WORKERS, --workers WORKERS
                              1
        -d, --debug           False
        -a, --access-log      False



  Lorsque la variable d'environnement CIRCE_USE_AUTH est à "1", le serveur attend
  une authentification sous la forme d'un hash HMAC du corps de la requête avec
  une clef partagée entre le serveur est le client. Ce hash est ajouté aux entêtes
  de la requête avec un identifiant propre au client de la façon suivante:

  	Authorization: [identifiant du client] [hash HMAC du corps de la requête]

  Pour plus de détails sur le hash HMAC, voir les différentes implémentations dans les
  librairies clients listées en bas de ce README.

  Toute la gestion des accès à l'API Circe se fait en ligne de commande.

  Pour la création de l'accès:

  	(venv) ➜  circe-server ✗ circe make-api-access -t MonClientDeTest
  	Access granted to MonClientDeTest
  	uuid    : 33f3f6c5-3bbc-4eeb-b661-e4579b2d9671
  	secret: &#H-9csMX|0):'-eUP6'u,I6=5X}U|z/

  Le client se voit attribué un UUID ainsi qu'une clef qu'il utilisera pour le hâchage.

  Pour la suppression de l'accès:

  	(venv) ➜  circe-server ✗ circe remove-api-access 33f3f6c5-3bbc-4eeb-b661-e4579b2d9671

  Pour lister tous les accès:

  	(venv) ➜  circe-server ✗ circe list-api-access
  	7afa5930a3c549b9a7003c0f98b55e73 : rcY<S<"\oHvjUJdf'w"J:YKE\?AKiG"~  [test client]
  	3a5eb39cadb04c8e9b30ee167c2e4cb5 : ~1!|J;yxGkW)?Z]hQ\v+Rn*52?`y(_:z  [test client]
  	a9e836331612498cb1681bc953132d82 : EQbQ&>)BxC|J/5Gz?4$BNr)~&\|k89`I  [test client]
  	1f902a30f124450bbe267b56026d347f : L$xc8cwFiczK4z7n%.{eSg^y0xFrzBtX  [test client]



  La variable d'environnement CIRCE_TRANSFORMATIONS_MODULE contient le nom du module Python contenant les transformations
  que vous souhaitez rendre disponible dans le service.

  Une transformation est un Python callable (fonction ou classe) prenant en argument le dossier de travail du job, une
  instance de logging.Logger ainsi qu'un dictionnaire d'options (facultatif). Exemple minimal d'une transformation:

      def ne_fait_rien(working_dir: str, logger: logging.Logger, options: dict = None):
          pass  # ajouter ici le code transformant les documents

  L'instance de logging.Logger peut prendre ee paramêtre une chaîne ou un dictionnaire:

  	logger.info('message de log")
  	logger.info({"message": "message de log", "autre info utile": 42}

  Les transformations peuvent fournir une description de leur fonctionnement ainsi:

  	ne_fait_rien.description = {
  		"label": "Ne fait rien",
  		"help": "Ne fait rien absolument rien. Utile pour tester l'API.",
  		"options": [],  # aucune option pour cette transformation
  	}

  Ces descriptions sont utiles pour les clients.

  Des exemples de transformations sont disponibles dans ce dépôt: https://git.unicaen.fr/certic/circe-transformations



  Une librairie cliente de référence en python est proposée.

  Installation:

      pip install circe-client-CERTIC

  Utilisation:

      from circe_client import Client

      
      
      
      client = Client(
          api_endpoint="http://host.tld/,
          secret_key="notsosecret",
          application_uuid="786d1b69a6034eb89178fed2a195a1ed",
      )

      if "html2pdf" in client.available_transformations():
          job = client.new_job()
          job.add_file("index.html")
          
          job.add_file("style.css")
          job.add_transformation("html2pdf")
          
          
          

          
          
          
          client.send(job, wait=True)

          
          
          
          
          
          
          
          
          
          
          

          
          
          for file_name, file_handle in job.result.files:
              print(file_name)


  Une [librairie cliente équivalente en Java](https://git.unicaen.fr/certic/circe-java-client) est disponible
  ainsi qu'une [librairie minimale en PHP](https://git.unicaen.fr/certic/circe-php-client)
  et un [outil en ligne de commande implémenté en Go](https://git.unicaen.fr/mickael.desfrenes/circe-helper).



  Un ensemble de tests exécutables par Pytest sont disponibles dans le fichier ```test.py```.



  Une façon simple de faire fonctionner Circe en production sur Linux est de maintenir le service via systemd
  et de le mettre en reverse proxy derrière un serveur web.

  Pour le service sous systemd, ajouter ceci dans un fichier /etc/systemd/system/circe.service, en prenant soin
  de changer les chemins en fonction de votre installation, ainsi que votre utilisateur/groupe:

  	[Unit]
  	Description=Circe Service

  	[Service]
  	Type=simple

  	
  	User=circe
  	Group=circe
  	UMask=007

  	
  	ExecStart=/home/circe/venvs/circe_env/bin/circe run
  	Environment="PATH=/usr/bin:/home/circe/venvs/circe_env/bin:$PATH"
  	
  	Environment="CIRCE_WEB_UI_CRYPT_KEY=qpoiurfIPUBeriIPU"
  	Environment="CIRCE_TRANSFORMATIONS_MODULE=your_transformations"
  	Environment="CIRCE_ENABLE_WEB_UI=0"
  	Restart=always
  	RestartSec=0

  	
  	TimeoutStopSec=30

  	[Install]
  	WantedBy=multi-user.target

  Puis, dans votre shell avec les droits root:

  	systemctl daemon-reload
  	systemctl enable circe
  	systemctl start circe

  Vous pouvez vérifier que le service est bien démarré avec la commande suivante:

  	systemctl status circe

  Le serveur devrait écouter en locahost (127.0.0.1) sur le port 8000 si vous n'avez pas modifié sa configuration.
  Vous pouvez maintenant placer ce service derrière le serveur web de votre choix.

  Pour [Caddy](https://caddyserver.com), dans votre /etc/caddy/CaddyFile:

  	circe.yourhost.com {
  		reverse_proxy 127.0.0.1:8000
  		header -Server
  	}

  Pour Apache, dans la configuration de votre vhost:

  	<Location />
  		ProxyPass "http://127.0.0.1:8000/"
  		ProxyPassReverse "http://127.0.0.1:8000/"
  	</Location>

  Référez-vous à la documentation de votre serveur web pour plus de détail.


pkgId: 3984656c2156f6b5583a242530b94df0b71966c955633bafdedfdc5083f2b70a
name: python-circle-chain
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: circle chain sdk in python
url: https://gitee.com/lidh04/python-circle-chain
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-chain-0.0.4-1.src.rpm
checksum_type: sha256
description:
  build the project please input the following command:

  ```shell
  python3 -m build
  ```



  ```shell
  twine upload --repository testpypi dist/*
  pip install -i https://test.pypi.org/simple/ circle-chain
  ```
  after installation, test passed in the local machine. then upload the lib to the release pypi:



  upload to pypi:

  ```shell
  twine upload dist/*
  ```



  ```shell
  pip install circle-chain
  ```





  ```python


  from circle_chain.user import send_register_verify_code,register,login,send_verify_code
  response = send_register_verify_code({ "email": "<your-email>" })
  if response['status'] != 200:
      raise Exception(response['message'])

  response = register({
      "email": "<your-email>",
      "passwordInput1": "111111",
      "passwordInput2": "111111",
      "verifyCode": "222222"
  })
  if response['status'] != 200:
      raise Exception(response['message'])


  response = login({
      "email": "<your-email>",
      "password": "111111",
  })
  if response['status'] != 200:
      raise Exception(response['message'])


  response = send_verify_code({ "email": "<your-email>" })
  if response['status'] != 200:
      raise Exception(response['message'])

  response = login({
      "email": "<your-email>",
      "verifyCode": "111111",
  })
  if response['status'] != 200:
      raise Exception(response['message'])


  ```



  ```python
  from circle_chain.wallet import create_wallet,list_wallet,assets_of_wallet
  response = create_wallet()
  if response['status'] != 200:
      raise Exception(response['message'])

  address = response['data']
  response = list_wallet()
  if response['status'] != 200:
      raise Exception(response['message'])

  address_list = response['data']
  response = assets_of_wallet()
  if response['status'] != 200:
      raise Exception(response['message'])

  data = response['data']
  ```



  ```py
  from circle_chain.user import send_pay_verify_code, set_pay_password
  response = send_pay_verify_code({ "email": "<your-email>" })
  if response['status'] != 200:
      raise Exception(response['message'])

  response = set_pay_password({
      "account": {
          "email": "test@gmail.com"
      },
      "password": "333333",
      "verifyCode": "112222"
  })
  if response['status'] != 200:
      raise Exception(response['message'])

  ```



  ```py
  from circle_chain.wallet import send_to, pay
  from_address = '1L8eRrBuWnBxcQ6DKCDkkPM7ozxDcmpho1'
  to = '14hF1BynFVnBEFKxyo51FHmJksVwfxg4sg'

  response = send_to({
      'email': 'test@gmail.com',
      'from': from_address,
      'address': to,
      'transContent': {
          'type': 1,
          'uuid': 'e1f1d3c7-3c6e-4f3b-a50d-58710b851357'
      },
      'payPassword': '111111'
  })
  if response['status'] != 200:
      raise Exception(response['message'])



  response = pay({
      'from': from_address,
      'to': to,
      'value': 100,
      'payPassword': "111111"
  });
  if response['status'] != 200:
      raise Exception(response['message'])

  ```



  ```py
  from circle_chain.user import add_contacts
  response = add_contacts({
      'email': "test2@gmail.com",
      'name': "test2",
      'sex': 1,
      'address': "beijing"
  });
  if response['status'] != 200:
      raise Exception(response['message'])

  ```





  1. `subcribe`

  2. `server_features`

  3. `broadcast_transaction`



  1. `send_verify_code`
  2. `login`
  3. `logout`
  4. `send_register_verify_code`
  5. `register`
  6. `add_contacts`
  7. `list_contacts`
  8. `send_pay_verify_code`
  9. `set_pay_password`
  10. `have_pay_password`
  11. `send_reset_password_verify_code`
  12. `reset_password`
  13. `save_or_update_user_info`
  14. `user_info`





  1. `create_wallet`
  2. `list_wallet`
  3. `balance_of_wallet`
  4. `assets_of_wallet`
  5. `assets_of_address`
  6. `get_public_key_hash_from_address`
  7. `balance_of_address`
  8. `send_to`
  9. `pay`
  10. `search_tx_by_type`
  11. `search_tx_by_time`
  12. `public_key_from_address`
  13. `let_me_try`



  1. `public_get_address_by_uid`
  2. `public_get_assets_of_address`
  3. `public_search_transaction`
  4. `public_get_balance_of_address`



  1. `get_block_hash_list`
  2. `get_block`
  3. `get_block_header_list`
  4. `get_block_data`
  5. `get_block_tail_hash_list`
  6. `get_block_tails_po`
  7. `get_transaction_by_txid`
  8. `search_tx_by_txid`
  9. `search_tx_by_address`
  10. `search_utxo`


pkgId: 6f4d2bc236206c121017ea952911f504b208f864785eb8ec04d07af8263747bc
name: python-circle-developer-controlled-wallets
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Developer-Controlled Wallets
url: https://pypi.org/project/circle-developer-controlled-wallets/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-developer-controlled-wallets-4.0.0-1.src.rpm
checksum_type: sha256
description:
  api_key | Yes | Api Key that is used to authenticate against Circle APIs. Must be provided by ether env variable or function parameter
  entity_secret | Yes | Your configured entity secret. Must be provided by ether env variable or function parameter.
  host | No | Optional base URL to override the default: https://api.circle.com/v1/w3s.
  user_agent | No | Optional custom user agent request header. We will prepend it to default user agent header if provided.

  Here are some helpful links, if you encounter any issues or have questions about this SDK:
  - 📖 [Getting started](https://developers.circle.com/interactive-quickstarts/dev-controlled-wallets): Check out our official Developer-Controlled Wallets QuickStart.
  - 🎮 [Join our Discord Community](https://discord.com/invite/buildoncircle): Engage, learn, and collaborate.
  - 🛎 [Visit our Help-Desk Page](https://support.usdc.circle.com/hc/en-us/p/contactus?_gl=1*1va6vat*_ga*MTAyNTA0NTQ2NC4xNjk5NTYyMjgx*_ga_GJDVPCQNRV*MTcwMDQ5Mzg3Ny4xNC4xLjE3MDA0OTM4ODQuNTMuMC4w): Dive into curated FAQs and guides.
  - 📧 [Direct Email](mailto:customer-support@circle.com): We're always a message away.
  - 📖 [Read docs](https://developers.circle.com/w3s/docs?_gl=1*15ozb5b*_ga*MTAyNTA0NTQ2NC4xNjk5NTYyMjgx*_ga_GJDVPCQNRV*MTcwMDQ5Mzg3Ny4xNC4xLjE3MDA0OTM4ODQuNTMuMC4w): Check out our developer documentation.
  Happy coding!


pkgId: 0adfefbe4fa12ba69ec8725792e239a28948f5fc6939b4ab313476b13c1660ef
name: python-circle-fit
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A Circle Fitting Library for Python
url: https://github.com/AlliedToasters/circle-fit
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-fit-0.2.1-1.src.rpm
checksum_type: sha256
description:
  ![LICENCE](https://img.shields.io/github/license/AlliedToasters/circle-fit)
  [![Flake8](https://github.com/AlliedToasters/circle-fit/actions/workflows/flake8.yml/badge.svg)](https://github.com/AlliedToasters/circle-fit/actions/workflows/flake8.yml)
  [![PyTest](https://github.com/AlliedToasters/circle-fit/actions/workflows/PyTest.yml/badge.svg)](https://github.com/AlliedToasters/circle-fit/actions/workflows/PyTest.yml)
  ![Version](https://img.shields.io/pypi/v/circle-fit)
  ![Python](https://img.shields.io/pypi/pyversions/circle-fit)


  Given a collection of points in 2D space, a common problem is finding the parameters of a circle that best approximate
  these points. This library implements a collection of different circle fitting algorithms:

  ```
  - hyperLSQ()      : Least squares circle fit with "hyperaccuracy" by Kenichi Kanatani, Prasanna Rangarajan
  - standardLSQ()   : Least squares circle fit, standard version.
  - riemannSWFLa()  : Riemann circle fit, SWFL version A
  - lm()            : Levenberg-Marquardt in the full (a,b,R) parameter space
  - prattSVD()      : Algebraic circle fit by V. Pratt
  - taubinSVD()     : Algebraic circle fit by G. Taubin
  - hyperSVD()      : Algebraic circle fit with "hyperaccuracy"
  - kmh()           : Consistent circle fit by A. Kukush, I. Markovsky, S. Van Huffel
  ```

  Most of these algorithms are based on the original MATLAB implementations by Nikolai Chernov:
  https://people.cas.uab.edu/~mosya/cl/MATLABcircle.html

  Each algorithm may work better in specific cases. If you are in doubt about which to use, `taubinSVD()`
  is a good starting point.


  `circle-fit` is available from PyPi. Run the following in a command line terminal:
  `pip install circle-fit`


  Fit a circle to four `(x,y)` points.
  ```
  from circle_fit import taubinSVD
  point_coordinates = [[1, 0], [-1, 0], [0, 1], [0, -1]]
  xc, yc, r, sigma = taubinSVD(point_coordinates)
  ```


  Your data must have at least two points in 2-D space. The algorithms in `circle-fit` expects either
  a 2D List or numpy ndarray of shape `(n, 2)`, where n is the number of points in your dataset.

  All the algorithms available in this library return four values:
  ```
  - xc    : x-coordinate of solution center (float)
  - yc    : y-coordinate of solution center (float)
  - r     : Radius of solution (float)
  - sigma : Residual error of solution (float)
  ```


  The function `plot_data_circle(coords, xc, yc, r)` can be used to open a plot window which shows you data points with
  a circle fit overlaid on top. Example use:
  ```
  xc, yc, r, sigma = taubinSVD(point_coordinates)
  plot_data_circle(point_coordinates, xc, yc, r)
  ```


  This library is a community collaboration, all work is voluntary.


  Please open a pull request with the changes you would like to contribute ([example](https://github.com/AlliedToasters/circle-fit/pull/10))


  As we are volunteers, please be patient when requesting support. You can either open an issue if you think you've found a bug with the code, or contact one of us directly if you have a user issue:

   - michael.r.klear@gmail.com
   - mag.lauritzen@gmail.com

rpm_license:
  Copyright (c) 2022 Michael Klear  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: bf288138445e23f2a3a63ce3b7942ae2ab042d53f00f56544f1d9042f20318c9
name: python-circle-sdk
arch: src
version: 0.1.0b14
epoch: 0
release: 1
summary: Python SDK for Circle APIs
url: https://pypi.org/project/circle-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-sdk-0.1.0b14-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/circle-sdk)](https://pypi.org/project/circle-sdk)
  [![pypi](https://img.shields.io/pypi/dm/circle-sdk)](https://pypi.org/project/circle-sdk)

  The Circle Python library provides convenient access to the Circle API for
  applications written in Python. For the API reference, see the [Circle API docs](https://developers.circle.com/reference). Also see this project's [PyPI package page](https://pypi.org/project/circle-sdk/).



  Python 3.7+ and Node 10+ (optional for contributing and development).



  The recommended way of installation is using the Python Package Index (PyPI):
  ```sh
  python3 -m pip install circle-sdk
  ```

  The other option requires you to clone this repo and run
  ```sh
  python3 -m pip install -e /Path/to/this/repo/root
  ```


  We strongly recommended that you use this SDK with Python typing extensions: we recommend using the VS Code IDE, downloading the [Python IntelliSense extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python), and enabling type checking for your workspace (see [this guide](https://www.emmanuelgautier.com/blog/enable-vscode-python-type-checking)).



  ```python
  import circle
  from circle.apis.tags import subscriptions_api
  from circle.model.subscription_request import SubscriptionRequest
  from pprint import pprint


  circle.base_url = circle.Environment.SANDBOX_BASE_URL
  circle.api_key = '<replace-me-with-your-api-key>'


  api_instance = subscriptions_api.SubscriptionsApi()


  body = SubscriptionRequest(
      endpoint="https://example.org/py/notifications"
  )


  try:
      api_response = api_instance.create_subscription(body=body)
      pprint(api_response)
  except circle.ApiException as e:
      print("Exception when calling SubscriptionsApi->create_subscription: %s\n" % e)

  ```


  Clone this repo and install development dependencies using

  ```sh

  yarn install


  python3 -m pip install -r requirements.txt
  ```

  1. Run the codegen command to generate the source code for thi
  s SDK from the `.openapi-generator/sdk.json` OpenAPI specificat
  ion file:

      ```sh
      yarn gen-sdk
      ```



  Please follow the [Conventional Commits][convencomms] format for all commits when creating a contributing pull request for this repo.

  [convencomms]: https://www.conventionalcommits.org/en/v1.0.0/


pkgId: ced886143e5acaad2012af737a303c776ae40f855eda4f93d71b45b5d8431ab1
name: python-circle-smart-contract-platform
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: Smart Contract Platform
url: https://pypi.org/project/circle-smart-contract-platform/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-smart-contract-platform-4.0.0-1.src.rpm
checksum_type: sha256
description:
  api_key | Yes | Api Key that is used to authenticate against Circle APIs. Must be provided by ether env variable or function parameter.
  entity_secret | Yes | Your configured entity secret. Must be provided by ether env variable or function parameter.
  host | No | Optional base URL to override the default: https://api.circle.com/v1/w3s.
  user_agent | No | Optional custom user agent request header. We will prepend it to default user agent header if provided.

  Here are some helpful links, if you encounter any issues or have questions about this SDK:
  - 📖 [Getting started](https://developers.circle.com/interactive-quickstarts): Check out our official Developer-Controlled Wallets QuickStart.
  - 🎮 [Join our Discord Community](https://discord.com/invite/buildoncircle): Engage, learn, and collaborate.
  - 🛎 [Visit our Help-Desk Page](https://support.usdc.circle.com/hc/en-us/p/contactus?_gl=1*1va6vat*_ga*MTAyNTA0NTQ2NC4xNjk5NTYyMjgx*_ga_GJDVPCQNRV*MTcwMDQ5Mzg3Ny4xNC4xLjE3MDA0OTM4ODQuNTMuMC4w): Dive into curated FAQs and guides.
  - 📧 [Direct Email](mailto:customer-support@circle.com): We're always a message away.
  - 📖 [Read docs](https://developers.circle.com/w3s/docs?_gl=1*15ozb5b*_ga*MTAyNTA0NTQ2NC4xNjk5NTYyMjgx*_ga_GJDVPCQNRV*MTcwMDQ5Mzg3Ny4xNC4xLjE3MDA0OTM4ODQuNTMuMC4w): Check out our developer documentation.
  Happy coding!


pkgId: 8421346fe719dedf3b05754b6fe973971818a4b18842ab16495fa014404bf3ef
name: python-circle-user-controlled-wallets
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: User-Controlled Wallets
url: https://pypi.org/project/circle-user-controlled-wallets/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-user-controlled-wallets-4.0.0-1.src.rpm
checksum_type: sha256
description:
  api_key | Yes | Api Key that is used to authenticate against Circle APIs. Must be provided by ether env variable or function parameter.
  host | No | Optional base URL to override the default: https://api.circle.com/v1/w3s.
  user_agent | No | Optional custom user agent request header. We will prepend it to default user agent header if provided.

  Here are some helpful links, if you encounter any issues or have questions about this SDK:
  - 📖 [Getting started](https://developers.circle.com/interactive-quickstarts/user-controlled-wallets): Check out our official Developer-Controlled Wallets QuickStart.
  - 🎮 [Join our Discord Community](https://discord.com/invite/buildoncircle): Engage, learn, and collaborate.
  - 🛎 [Visit our Help-Desk Page](https://support.usdc.circle.com/hc/en-us/p/contactus?_gl=1*1va6vat*_ga*MTAyNTA0NTQ2NC4xNjk5NTYyMjgx*_ga_GJDVPCQNRV*MTcwMDQ5Mzg3Ny4xNC4xLjE3MDA0OTM4ODQuNTMuMC4w): Dive into curated FAQs and guides.
  - 📧 [Direct Email](mailto:customer-support@circle.com): We're always a message away.
  - 📖 [Read docs](https://developers.circle.com/w3s/docs?_gl=1*15ozb5b*_ga*MTAyNTA0NTQ2NC4xNjk5NTYyMjgx*_ga_GJDVPCQNRV*MTcwMDQ5Mzg3Ny4xNC4xLjE3MDA0OTM4ODQuNTMuMC4w): Check out our developer documentation.
  Happy coding!


pkgId: 1c2cf0eb96599b9d90985e7f115b8756267a871f25f082ad10cf5fd7b00527db
name: python-circle-web3-sdk-util
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: The Python SDK Utility for Circle Web3 Services
url: https://github.com/circlefin/circle-web3-python-sdk
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circle-web3-sdk-util-4.0.0-1.src.rpm
checksum_type: sha256
description:
  The Circle Web3 Python SDK provides convenient access to the Circle Web3 APIs for
  applications written in Python. For the API reference, see the [Circle Web3 API Docs](https://developers.circle.com/w3s/reference/getping).
  Also see this project's [PyPI Package Page [TODO]]().



  Python 3.7+.

  Java 11 and Node 10+ (optional for contributing and development).



  The recommended way of installation is using the Python Package Index (PyPI):
  ```sh
  pip install circle-developer-controlled-wallets
  pip install circle-smart-contract-platform
  pip install circle-user-controlled-wallets
  ```


  Clone this repo and install development dependencies using

  ```sh

  yarn install
  ```

  Initialize the submodules:
  ```bash
  git submodule init
  ```

  Build the OpenAPI specifications:
  ```bash
  cd w3s-openapi-internal
  make build
  cd ..
  ```

  Run the codegen command to generate the source code for this SDK from
  the `w3s-openapi-internal` OpenAPI specifications
  ```sh

  yarn gen-sdk
  ```



  Initialize circle web3 API clients. To secure your entity secret and circle API key. Set the API key and entity secret as environment variables. Learn more about entity secret management [here](https://developers.circle.com/w3s/docs/entity-secret-management)

  ```shell
  export CIRCLE_ENTITY_SECRET="Your entity secret"
  export CIRCLE_WEB3_API_KEY="Your API KEY"
  ```

  ```python
  from circle.web3 import utils

  dcw_client = utils.init_developer_controlled_wallets_client(api_key="Your API KEY", entity_secret="Your entity secret")
  scp_client = utils.init_smart_contract_platform_client(api_key="Your API KEY", entity_secret="Your entity secret")
  ucw_client = utils.init_user_controlled_wallets_client(api_key="Your API KEY")
  ```

  Using client to make a transaction.

  ```python
  from circle.web3 import user_controlled_wallets


  ucw_client = utils.init_user_controlled_wallets_client(api_key="<your-api-key>")

  api_instance = user_controlled_wallets.PINAuthenticationApi(ucw_client)
  try:
      api_request = user_controlled_wallets.UserTokenRequest.from_dict({"userId": "test-user"})
      api_response = api_instance.get_user_token(api_request)
      print(api_response.data.user_token)
  except user_controlled_wallets.ApiException as e:
      print("Exception when calling PINAuthenticationApi->get_user_token: %s\n" % e)
  ```



  Please follow the [Conventional Commits][convencomms] format for all commits when creating a contributing pull request for this repo.

  [convencomms]: https://www.conventionalcommits.org/en/v1.0.0/


pkgId: 2ae5624d8f2a44be578b547aa3d46834f824671b1478b3c998550ff788d133e4
name: python-circleguard
arch: src
version: 5.4.3
epoch: 0
release: 1
url: https://github.com/circleguard/circlecore
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circleguard-5.4.3-1.src.rpm
checksum_type: sha256
summary:
  A utilities library for osu!. Provides support for parsing replays from a file or from the api, as well as support for unstable rate, hits, similarity, and frametime calculations.

description:
  <img src="readme_resources/logo.png" alt="logo" width="200" height="200"/>

  [![PyPi version](https://badge.fury.io/py/circleguard.svg)](https://pypi.org/project/circleguard/)



  Circlecore is a utilities library for osu!. Features include:

  * Unstable Rate calculation
  * Judgments calculation (classifying all hitobjects into misses, hit300s, hit100s, hit50s, or sliderbreaks)
  * Similarity calculation between two replays, for replay stealing detection
  * Frametime calculation, for timewarp detection
  * Jerky, suspicious movement detection (called Snaps)

  Circlecore is used by [Circleguard](https://github.com/circleguard/circleguard), a replay analysis tool.

  Circlecore is developed and maintained by:

  * [tybug](https://github.com/tybug)
  * [samuelhklumpers](https://github.com/samuelhklumpers)



  Circlecore can be installed from pip:

  ```bash
  pip install circleguard
  ```

  This documentation refers to the project as `circlecore` to differentiate it from our organization [Circleguard](https://github.com/circleguard) and the replay analysis tool [Circleguard](https://github.com/circleguard/circleguard). However, `circlecore` is installed from pypi with the name `circleguard`, and is imported as such in code (`import circleguard`).



  Github: <https://github.com/circleguard/circlecore> <br/>
  Documentation: <https://circleguard.github.io/circlecore/> <br/>
  Discord: <https://discord.gg/VNnkTjm> <br/>



  We have a full tutorial and documentation at <https://circleguard.github.io/circlecore/>. If you really want to jump right in, below is a quickstart guide:

  ```python
  from circleguard import *


  cg = Circleguard("key")

  replay = ReplayMap(221777, 2757689)

  print(cg.ur(replay)) # unstable rate
  print(cg.frametime(replay)) # average frametime
  print(cg.frametimes(replay)) # full frametime list
  print(cg.hits(replay)) # where the replay hits hitobjects
  print(cg.snaps(replay)) # any jerky/suspicious movement

  replay2 = ReplayMap(221777, 4196808)
  print(cg.similarity(replay, replay2)) # how similar the replays are



  map_ = cg.Map(221777, span="1-3")

  user = cg.User(124493, span="15, 20")

  replay3 = ReplayPath("/path/to/local/osr/replay.osr")




  for r in map_:
      print(cg.ur(r))
  ```



  Join [our discord](https://discord.gg/VNnkTjm) and ask how you can help, or look around for open issues which interest you and tackle those. Pull requests are welcome!


pkgId: da305cd113d72673a3401f029e36962dcb2c7f3fc1e6c70d4eb95db97fc46a3c
name: python-circlemind-sdk
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Python Client SDK Generated by Speakeasy.
url: https://github.com/circlemind-ai/circlemind-sdk.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circlemind-sdk-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Developer-friendly & type-safe Python SDK specifically catered to leverage *circlemind-sdk* API.

  <div align="left">
      <a href="https://www.speakeasy.com/?utm_source=circlemind-sdk&utm_campaign=python"><img src="https://custom-icon-badges.demolab.com/badge/-Built%20By%20Speakeasy-212015?style=for-the-badge&logoColor=FBE331&logo=speakeasy&labelColor=545454" /></a>
      <a href="https://opensource.org/licenses/MIT">
          <img src="https://img.shields.io/badge/License-MIT-blue.svg" style="width: 100px; height: 28px;" />
      </a>
  </div>


  <br /><br />

  <!-- Start Summary [summary] -->



  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->


  * [SDK Installation](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#sdk-installation)
  * [IDE Support](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#ide-support)
  * [SDK Example Usage](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#sdk-example-usage)
  * [Available Resources and Operations](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#available-resources-and-operations)
  * [Retries](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#retries)
  * [Error Handling](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#error-handling)
  * [Server Selection](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#server-selection)
  * [Custom HTTP Client](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#custom-http-client)
  * [Authentication](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#authentication)
  * [Debugging](https://github.com/circlemind-ai/circlemind-sdk/blob/master/#debugging)
  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install circlemind-sdk
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add circlemind-sdk
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from circlemind_sdk import CirclemindSDK
  import os

  s = CirclemindSDK(
      api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
  )

  res = s.get_graph_configuration(graph_name="<value>")

  if res is not None:
      
      pass
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from circlemind_sdk import CirclemindSDK
  import os

  async def main():
      s = CirclemindSDK(
          api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
      )
      res = await s.get_graph_configuration_async(graph_name="<value>")
      if res is not None:
          
          pass

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>



  * [get_graph_configuration](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#get_graph_configuration) - Get Graph Configuration
  * [create_graph_configuration](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#create_graph_configuration) - Post Graph Configuration
  * [get_graph_list](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#get_graph_list) - Get Graph List
  * [create_graph](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#create_graph) - Create Graph
  * [create_query](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#create_query) - Post Query
  * [get_query_handler](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#get_query_handler) - Get Query Handler
  * [create_insert](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#create_insert) - Post Insert
  * [create_graph_files](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#create_graph_files) - Add Files
  * [get_insert_handler](https://github.com/circlemind-ai/circlemind-sdk/blob/master/docs/sdks/circlemindsdk/README.md#get_insert_handler) - Get Insert Handler

  </details>
  <!-- End Available Resources and Operations [operations] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from circlemind_sdk import CirclemindSDK
  from circlemindsdk.utils import BackoffStrategy, RetryConfig
  import os

  s = CirclemindSDK(
      api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
  )

  res = s.get_graph_configuration(graph_name="<value>",
      RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

  if res is not None:
      
      pass

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from circlemind_sdk import CirclemindSDK
  from circlemindsdk.utils import BackoffStrategy, RetryConfig
  import os

  s = CirclemindSDK(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
  )

  res = s.get_graph_configuration(graph_name="<value>")

  if res is not None:
      
      pass

  ```
  <!-- End Retries [retries] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a models.SDKError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `get_graph_configuration_async` method may raise the following exceptions:

  | Error Type                 | Status Code | Content Type     |
  | -------------------------- | ----------- | ---------------- |
  | models.HTTPValidationError | 422         | application/json |
  | models.SDKError            | 4XX, 5XX    | \*/\*            |



  ```python
  from circlemind_sdk import CirclemindSDK, models
  import os

  s = CirclemindSDK(
      api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
  )

  res = None
  try:
      res = s.get_graph_configuration(graph_name="<value>")

      if res is not None:
          
          pass

  except models.HTTPValidationError as e:
      
      raise(e)
  except models.SDKError as e:
      
      raise(e)
  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from circlemind_sdk import CirclemindSDK
  import os

  s = CirclemindSDK(
      server_url="https://api.circlemind.co",
      api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
  )

  res = s.get_graph_configuration(graph_name="<value>")

  if res is not None:
      
      pass

  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from circlemind_sdk import CirclemindSDK
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = CirclemindSDK(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from circlemind_sdk import CirclemindSDK
  from circlemind_sdk.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = CirclemindSDK(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name             | Type   | Scheme  | Environment Variable           |
  | ---------------- | ------ | ------- | ------------------------------ |
  | `api_key_header` | apiKey | API key | `CIRCLEMINDSDK_API_KEY_HEADER` |

  To authenticate with the API the `api_key_header` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from circlemind_sdk import CirclemindSDK
  import os

  s = CirclemindSDK(
      api_key_header=os.getenv("CIRCLEMINDSDK_API_KEY_HEADER", ""),
  )

  res = s.get_graph_configuration(graph_name="<value>")

  if res is not None:
      
      pass

  ```
  <!-- End Authentication [security] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from circlemind_sdk import CirclemindSDK
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = CirclemindSDK(debug_logger=logging.getLogger("circlemind_sdk"))
  ```

  You can also enable a default debug logger by setting an environment variable `CIRCLEMINDSDK_DEBUG` to true.
  <!-- End Debugging [debug] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation.
  We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.


pkgId: 1d246a82554a50920e911ba20943e7bb114961543eae37f935e52ad4550d16e2
name: python-circlevis
arch: src
version: 1.4.7
epoch: 0
release: 1
summary: A Qt Widget for visualizing osu! beatmaps and replays.
url: https://github.com/circleguard/circlevis
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circlevis-1.4.7-1.src.rpm
checksum_type: sha256
description:
  Circlevis is the replay viewer (aka visualizer) in [Circleguard](https://github.com/circleguard/circleguard). It was split off into its own repository to allow other projects to use it, should they so choose.

  Circlevis is a [pyqt](https://pypi.org/project/PyQt6/) widget.



  Circlevis can be installed from pip:

  ```bash
  pip install circlevis
  ```



  Circlevis can be used in two ways:



  The easiest way is to instantiate a `VisualizerApp`, which subclasses `QApplication` so you don't have to create a main application yourself. This is best for quick visualization, when you only want to open circlevis and nothing else.

  ```python
  from circleguard import *
  from circlevis import VisualizerApp, BeatmapInfo

  cg = Circleguard("key")
  r = ReplayMap(509610, 6304246)

  cg.load(r)







  bm = BeatmapInfo(map_id=r.map_id)
  app = VisualizerApp(bm, replays=[r])


  app.exec()
  ```

  You can also visualize only a map, without any replay:

  ```python
  from circlevis import VisualizerApp, BeatmapInfo

  bm = BeatmapInfo(map_id=509610)
  app = VisualizerApp(bm)
  app.exec()
  ```



  If you want to integrate the visualizer into an existing project (which already has its own `QApplication`), you should instead instantiate the `Visualizer` class. `Visualizer` subclasses `QMainWindow` instead of `QApplication` and can be used like any other widget.

  ```python
  from circleguard import *
  from circlevis import Visualizer, BeatmapInfo

  cg = Circleguard("key")
  r = ReplayMap(509610, 6304246)
  cg.load(r)

  bm = BeatmapInfo(map_id=r.map_id)
  visualizer_window = Visualizer(bm, replays=[r])
  visualizer_window.show()

  ```



  Both `VisualizerApp` and `Visualizer` can take several optional arguments:

  * `events` - a list of timestamps (in ms). If a frame with that timestamp is found in the replay, it is colored gold
  * `library` - A [slider](https://github.com/llllllllll/slider) `Library` class, which will be used instead of creating a new one if passed
  * `speeds` - a list of possible speeds the visualizer can play at. These can be switched between in real time with the speed up or speed down icons on the visualizer, or by pressing the up or down keys
  * `start_speed` - which speed to start playback at. This value must be in `speeds`
  * `paint_info` - whether to draw information about the map and replays in the upper left hand corner



  Circlevis also provides a `Classifier` class, which builds on the visualizer to provide an easy way to batch classify replays one at a time. For instance, imagine you want to go through a map's leaderboard and assign a "cursordance score" to each replay, depending on how often the user cursordanced. The classifier will show you the first replay and wait for you to press a number key that assigns a cursordance score to that replay. When you do so, it saves the score and shows the next replay. Repeat until all replays are classified.

  To use, you need a list of hotkeys that you will use to control the classification of the replays, a circleguard instance, and a list of Replay instances. Here's an example for the aforementioned "cursordance scoring" use case, where you can assign replays a score from 1 to 10:

  ```python
  from collections import defaultdict
  from circleguard import Circleguard
  from circlevis import Classifier, ClassifierHotkey

  cg = Circleguard("api_key")

  class JudgeClassifier(Classifier):
      def __init__(self, replays, cg):

          self.scores = defaultdict(list)

          hotkeys = [
              ClassifierHotkey(Qt.Key.Key_1, lambda r: self.assign_score(1, r)),
              ClassifierHotkey(Qt.Key.Key_2, lambda r: self.assign_score(2, r)),
              ClassifierHotkey(Qt.Key.Key_3, lambda r: self.assign_score(3, r)),
              ClassifierHotkey(Qt.Key.Key_4, lambda r: self.assign_score(4, r)),
              ClassifierHotkey(Qt.Key.Key_5, lambda r: self.assign_score(5, r)),
              ClassifierHotkey(Qt.Key.Key_6, lambda r: self.assign_score(6, r)),
              ClassifierHotkey(Qt.Key.Key_7, lambda r: self.assign_score(7, r)),
              ClassifierHotkey(Qt.Key.Key_8, lambda r: self.assign_score(8, r)),
              ClassifierHotkey(Qt.Key.Key_9, lambda r: self.assign_score(9, r)),
              ClassifierHotkey(Qt.Key.Key_0, lambda r: self.assign_score(10, r)),
          ]
          super().__init__(replays, cg, hotkeys)

      def assign_score(self, score, replay):
          print(f"scoring {replay} as a {score}")
          self.scores[score].append(replay)
          
          self.next_replay()

      def done(self):
          print(f"final scores: {self.scores}")

  replays = cg.Map(221777, "1-10")
  classifier = JudgeClassifier(replays, cg)
  classifier.start()
  ```



  A cookbook recipe to save the current state of the visualizer at arbitrary timestamps in the map:

  ```python
  from circleguard import *
  from circlevis import *

  cg = Circleguard("api_key")

  r = cg.Map(2102290, "1", mods=Mod.HD, load=True)[0]
  bm = BeatmapInfo(map_id=r.map_id)
  screenshot_times = [727, 8000, 15214]

  class ScreenshotVisualizer(VisualizerApp):
      def on_load(self):
          self.pause()
          for i, t in enumerate(screenshot_times):
              self.seek_to(t)
              image = self.save_as_image()
              image.save(f"image-{i}.png")
          self.exit()

  vis = ScreenshotVisualizer(bm, [r])
  vis.exec()
  ```

  If you want to take screenshots of multiple replays over multiple maps, it gets a bit trickier because we can only instantiate one `QApplication` over the lifetime of the program, even if we try to instantiate them in sequence. But we can still slightly abuse `Classifier` to achieve this:

  ```python
  m = cg.Map(221777, "1-2", load=True)

  screenshot_times = {
      m[0]: [123, 234, 456],
      m[1]: [10000, 20000, 30000]
  }

  class ScreenshotVisualizer(Visualizer):
      def __init__(self, callback, screenshot_times, *args, **kwargs):
          self.callback = callback
          self.screenshot_times = screenshot_times
          super().__init__(*args, **kwargs)

      def on_load(self):
          self.pause()
          for t in self.screenshot_times:
              self.seek_to(t)
              image = self.save_as_image()
              image.save(f"replay-{self.replays[0].username}-{t}.png")
          self.callback()

  class ScreenshotClassifier(Classifier):
      def visualizer(self, bm, replay):
          callback = lambda: self.next_replay()
          times = screenshot_times[replay]
          return ScreenshotVisualizer(callback, times, bm, [replay])

  c = ScreenshotClassifier(m, cg, [])
  c.start()
  ```


pkgId: 11b9f061faea398672aa2ccc5d731c8e3bbe9fff8beda0db1c1ffe2633fa99d6
name: python-circuit-maintenance-parser
arch: src
version: 2.6.1
epoch: 0
release: 1
summary: Python library to parse Circuit Maintenance notifications and return a structured data back
url: https://github.com/networktocode/circuit-maintenance-parser
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circuit-maintenance-parser-2.6.1-1.src.rpm
checksum_type: sha256
description:
  ```
  7. Run some final CI tests locally to ensure that there is no linting/formatting issues with your changes. You should look to get a code score of 10/10. See the example below: `invoke tests --local`
  ```
  -> % invoke tests --local
  LOCAL - Running command black --check --diff .
  All done! ✨ 🍰 ✨
  41 files would be left unchanged.
  LOCAL - Running command flake8 .
  LOCAL - Running command find . -name "*.py" | xargs pylint
  ************* Module tasks


pkgId: 25f06b5c2649ddc52132d7c55bdce093451bfaaae0f365c3c252292dad4192ee
name: python-circuitbreaker
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Python Circuit Breaker pattern implementation
url: https://github.com/fabfuel/circuitbreaker
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circuitbreaker-2.0.0-1.src.rpm
checksum_type: sha256
description:
  This is a Python implementation of the "Circuit Breaker" Pattern (https://martinfowler.com/bliki/CircuitBreaker.html).
  Inspired by Michael T. Nygard's highly recommendable book *Release It!* (https://pragprog.com/titles/mnee2/release-it-second-edition/).


pkgId: 1e4b117de212394837928427575958d61b865e2735d7a328789599bde42ce48d
name: python-circuitpython-button-handler
arch: src
version: 3.0.0
epoch: 0
release: 1
url: https://github.com/EGJ-Moorington/CircuitPython_Button_Handler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circuitpython-button-handler-3.0.0-1.src.rpm
checksum_type: sha256
summary:
  This helper library simplifies the usage of buttons with CircuitPython, by detecting and differentiating button inputs, returning a set of the inputs and calling their corresponding functions.

description:
  This helper library simplifies the usage of buttons with CircuitPython, by detecting and differentiating button inputs, returning a set of the inputs and calling their corresponding functions.


pkgId: 4373ae53e9a0a9ee922ae990945083ce713acfb0da0a7f7c3daf4bc8ad2ad690
name: python-circuitpython-mag-cal
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Calibrate magnetometer and accelerometer readings
url: https://github.com/furbrain/CircuitPython_mag_cal
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circuitpython-mag-cal-1.4.1-1.src.rpm
checksum_type: sha256
description:
  This library allows you to calibrate magnetometers when used with a 3 axis accelerometer.
  It is designed for use with circuitpython and `ulab <https://github.com/v923z/micropython-ulab>`_,
  but can be used in any python environment where `numpy <https://numpy.org/>`_ is present.


pkgId: 5499929820a4e0a8356c976ac624bbf16d9cd51cffe45eed7b5ea4543130063c
name: python-circuitree
arch: src
version: 0.11.1
epoch: 0
release: 1
summary: Genetic circuit design using Monte Carlo tree search
url: https://pypi.org/project/circuitree/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circuitree-0.11.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
  <img src="https://raw.githubusercontent.com/pranav-bhamidipati/circuitree/main/logo.png" width="300">
  </h1><br>

  Biochemical circuit design using Monte Carlo tree search



  ```pip install circuitree```



  [Getting started tutorial](https://githubtocolab.com/pranav-bhamidipati/circuitree-tutorial/blob/main/src/tutorial-1-getting-started.ipynb).

  See the [`circuitree-tutorial`](https://github.com/pranav-bhamidipati/circuitree-tutorial) repo for additional tutorials and example scripts.



  API docs coming soon


  © 2024 Pranav Bhamidipati
  Logo © 2024 Inna-Marie Strazhnik


pkgId: 1cdeaa2f61aa8a051b38da3a7e197b125b1f08172fb6ad5a2151a95f79987573
name: python-circuits
arch: src
version: 3.2.3
epoch: 0
release: 1
summary: Asynchronous Component based Event Application Framework
url: http://circuitsframework.com/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circuits-3.2.3-1.src.rpm
checksum_type: sha256
description:
  Hello
      
      """circuits Hello World"""
      from circuits import Component, Event
      class hello(Event):
          """hello Event"""
      class App(Component):
          def hello(self):
              """Hello Event Handler"""
              print("Hello World!")
          def started(self, component):
              """Started Event Handler
              This is fired internally when your application starts up and can be used to
              trigger events that only occur once during startup.
              """
              self.fire(hello())  # Fire hello Event
              raise SystemExit(0)  # Terminate the Application
      App().run()
  Echo Server
      
      """Simple TCP Echo Server
      This example shows how you can create a simple TCP Server (an Echo Service)
      utilizing the builtin Socket Components that the circuits library ships with.
      """
      from circuits import handler, Debugger
      from circuits.net.sockets import TCPServer
      class EchoServer(TCPServer):
          @handler("read")
          def on_read(self, sock, data):
              """Read Event Handler
              This is fired by the underlying Socket Component when there has been
              new data read from the connected client.
                        to ValueChagned events (feedback) to determine if a handler
                        returned some data and fires a subsequent Write event with
                        the value returned.
              """
              return data
      
      
      app = EchoServer(8000)
      Debugger().register(app)
      app.run()
  Hello Web
      
      from circuits.web import Server, Controller
      class Root(Controller):
          def index(self):
              """Index Request Handler
              Controller(s) expose implicitly methods as request handlers.
              Request Handlers can still be customized by using the ``@expose``
              decorator. For example exposing as a different path.
              """
              return "Hello World!"
      app = Server(("0.0.0.0", 8000))
      Root().register(app)
      app.run()
  More `examples <https://github.com/circuits/circuits/tree/master/examples>`_...


pkgId: b9502bcd9a1371dc2e99e051ee311a5db49436411e9fdb320d4235cf5fc4810c
name: python-circular-dict
arch: src
version: 1.9
epoch: 0
release: 1
url: https://github.com/Eric-Canas/CircularDict
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circular-dict-1.9-1.src.rpm
checksum_type: sha256
summary:
  CircularDict is a high-performance Python data structure that blends the functionality of dictionaries and circular buffers. Inheriting the usage of traditional dictionaries, it allows you to define constraints on size and memory usage. This way, the CircularDict will be always up-to-date with the last N added elements, ensuring that neither the maximum length nor the memory usage limit is exceeded. It is ideal for caching large data structures while maintaining control over memory footprint.

description:
  <img alt="CircularDict" title="CircularDict" src="https://raw.githubusercontent.com/Eric-Canas/CircularDict/main/resources/logo.png" width="20%" align="left"> **CircularDict** is a Python `dict` that acts as a **Circular Buffer**. This dictionary maintains a **controlled size**, limited either by a specified **number of items** (_maxlen_) or **total size in bytes** (_maxsize_bytes_). Upon reaching the defined limit, **CircularDict** automatically removes the oldest entries, maintaining **memory usage** under control.

  Built upon Python's `OrderedDict`, **CircularDict** inherits all **standard dictionary usage** and operations, augmented by the capability of **memory management**. It's particularly useful in scenarios such as **caching**, where limiting **memory consumption** is crucial. The class combines _dictionary_ and _circular-queue_ behaviors, providing an efficient and scalable solution for various use cases.



  To install **CircularDict** simply run:

  ```bash
  pip install circular-dict
  ```



  Working with **CircularDict** is as simple as using a standard Python `dict`, with additional parameters `maxlen` or `maxsize_bytes` on the initialization to control the buffer size. You can use one of them or both.
  ```python
  from circular_dict import CircularDict

  my_dict = CircularDict(maxlen=3, maxsize_bytes=4*1024*1024)
  ```


  You can use `maxlen` to define the maximum amount of items that the dictionary can store. It is useful for defining fixed size buffers.

  ```python
  from circular_dict import CircularDict


  my_buffer = CircularDict(maxlen=3)


  my_buffer['item1'] = 'value1'
  my_buffer['item2'] = 'value2'
  my_buffer['item3'] = 'value3'

  print(f"When filling it: {circ_dict}")


  my_buffer['item4'] = 'value4'

  print(f"After adding an element beyond maxlen: {circ_dict}")
  ```

  Output:
  ```bash
  When filling it: {'item1': 'value1', 'item2': 'value2', 'item3': 'value3'}
  After adding an element beyond maxlen: {'item2': 'value2', 'item3': 'value3', 'item4': 'value4'}
  ```


  You can use `maxsize_bytes` to define the maximum amount of memory that the `dict` can store. It is particularly beneficial when defining **caches**, to prevent **memory overflows**.

  ```python
  from circular_dict import CircularDict
  import numpy as np
  import sys


  my_buffer = CircularDict(maxsize_bytes=100*1024)


  my_buffer['item1'] = np.zeros((10, 1024), dtype=np.int32)
  my_buffer['item2'] = np.ones((10, 1024), dtype=np.int32)

  print(f"{len(my_buffer)} Elements {tuple(my_buffer.keys())}. Dict size: {my_buffer.current_size/1024} Kb")


  my_buffer['item3'] = np.ones((8, 1024), dtype=np.int32)

  print(f"{len(my_buffer)} Elements {tuple(my_buffer.keys())}. Dict size: {my_buffer.current_size/1024} Kb")


  too_big_array = np.ones((40, 1024), dtype=np.int32)
  try:
    
    my_buffer['item4'] = too_big_array
  except MemoryError:
    print(f"Cannot add an element with {sys.getsizeof(too_big_array)/1024}Kb in a dict with"\
          f"maxsize_bytes of {my_buffer.maxsize_bytes/1024} Kb. Current elements {tuple(my_buffer.keys())}")
  ```

  Output

  ```bash
  2 Elements ('item1', 'item2'). Dict size: 80.35 Kb
  2 Elements ('item2', 'item3'). Dict size: 72.35 Kb
  Cannot add an element with 160.12Kb in a dict with maxsize_bytes of 100.0 Kb. Current elements ('item2', 'item3')
  ```

  Please remember that the `maxsize_bytes` parameter considers the **total** memory footprint, including the sizes of _keys_ and _values_. If you try to add an item that exceeds the `maxsize_bytes`, a `MemoryError` will be raised.


pkgId: 52ebd5c360353cd6b0d7cc8fce0a522ab344e5d5a618a77447c8fbd21ed4a0d7
name: python-circup
arch: src
version: 2.0.4
epoch: 0
release: 1
summary: A tool to manage/update libraries on CircuitPython devices.
description: A tool to manage and update libraries (modules) on a CircuitPython device.
url: https://pypi.org/project/circup/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circup-2.0.4-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2019 Adafruit Industries  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: e8c21cc9cd0ade2309cf170b1957da73ba04b812fb7d9dfd46c425f7a572dcd1
name: python-circus
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Circus is a program that will let you run and watch multiple processes and sockets.
url: https://pypi.org/project/circus/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-circus-0.18.0-1.src.rpm
checksum_type: sha256
description:
  ![Build Status](https://github.com/circus-tent/circus/workflows/ci/badge.svg)
  ![Coverage Status](https://coveralls.io/repos/github/circus-tent/circus/badge.svg?branch=master)
  ![PyPI](https://img.shields.io/pypi/v/circus)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/circus)


  Circus is a program that runs and watches processes and sockets.
  Circus can be used as a library or through the command line.



  - [Full Documentation](https://circus.readthedocs.io)
  - [How to Contribute](https://circus.readthedocs.io/en/latest/contributing/)
  - IRC: Freenode, channel #mozilla-circus


pkgId: 809ae1a6d2065a8b3f7005aa7e9fbf690ce9d8b67b21bf7f980e380cd382ea8e
name: python-cirq-iqm
arch: src
version: 14.6
epoch: 0
release: 1
summary: Google Cirq adapter for IQM's quantum architectures
url: https://pypi.org/project/cirq-iqm/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirq-iqm-14.6-1.src.rpm
checksum_type: sha256
description:
  Currently Cirq on IQM can
  * take an arbitrary quantum circuit created using Cirq or imported from an OpenQASM 2.0 file
  * map the circuit into an equivalent one compatible with the chosen IQM quantum architecture
  * optimize the circuit by commuting and merging gates
  * simulate the circuit using one of Cirq's simulators
  * run the circuit on an IQM quantum computer

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


pkgId: 5863a3fe4c347577d6d2d96e5b0a544ce0f73b81beee1fe979fb07bbab9c9198
name: python-cirq-superstaq
arch: src
version: 0.5.30
epoch: 0
release: 1
summary: The Cirq module that provides tools and access to Superstaq.
url: https://pypi.org/project/cirq-superstaq/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirq-superstaq-0.5.30-1.src.rpm
checksum_type: sha256
description:
  ![cirq-superstaq's default workflow](https://github.com/Infleqtion/client-superstaq/actions/workflows/ci.yml/badge.svg)

  This package is used to access Superstaq via a Web API through [Cirq](https://github.com/quantumlib/Cirq).
  Cirq programmers can take advantage of the applications, pulse level optimizations, and write-once-target-all
  features of Superstaq with this package.

  `cirq-superstaq` is [available on PyPI](https://pypi.org/project/cirq-superstaq) and can be installed with:

  ```
  pip install cirq-superstaq
  ```

  Please note that Python version `3.8` or higher is required. For further installation instructions, see [here](https://github.com/Infleqtion/client-superstaq#readme).


  ```python
  import cirq
  import cirq_superstaq as css

  q0 = cirq.LineQubit(0)
  q1 = cirq.LineQubit(1)

  circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0, q1), cirq.measure(q0))

  service = css.Service(
      api_key="""Insert superstaq token that you received from https://superstaq.infleqtion.com""",
      verbose=True,
  )


  job = service.create_job(circuit, repetitions=1, target="ibmq_brisbane_qpu", method="dry-run")
  print("This is the job that's created ", job.status())
  print(job.counts())
  ```


pkgId: 5bd9d78d40ce92a822c2755ce125567868dffe96b9722acb5d05edb2dcee7201
name: python-cirqqrack
arch: src
version: 0.8.2
epoch: 0
release: 1
summary: Cirq Qrack Plugin - Qrack High-Performance GPU simulation for Cirq
url: https://github.com/vm6502q/cirq-qrack
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirqqrack-0.8.2-1.src.rpm
checksum_type: sha256
description:
  This repository contains a Qrack plugin for Cirq, providing the Qrack QasmSimulator. The underlying Qrack simulator is a high-performance, GPU-accelerated, noiseless simulator, by design.

  This plugin is based on and adapted from work by the **qulacs team**, the **IBM Qiskit Team**, and **QCGPU's creator, Adam Kelly**. Quantum volume benchmarks come from the qulacs plugin for Cirq at [https://github.com/qulacs/cirq-qulacs](https://github.com/qulacs/cirq-qulacs). Attribution is also noted in content files, where appropriate. Original contributions and adaptations were made by Daniel Strano of the Qrack/VM6502Q Team.


pkgId: 382e6f835835cd6a444f40ef9c852f672a3f3f28dce21210d91b7ecf7eb5ffb6
name: python-cirro
arch: src
version: 1.2.10
epoch: 0
release: 1
summary: CLI tool and SDK for interacting with the Cirro platform
url: https://github.com/CirroBio/Cirro-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirro-1.2.10-1.src.rpm
checksum_type: sha256
description:
  [![Build Python package](https://github.com/FredHutch/Cirro-client/actions/workflows/package.yml/badge.svg)](https://github.com/FredHutch/Cirro-client/actions/workflows/package.yml)
  [![Lint and run tests](https://github.com/FredHutch/Cirro-client/actions/workflows/lint.yml/badge.svg)](https://github.com/FredHutch/Cirro-client/actions/workflows/lint.yml)
  ![](https://img.shields.io/pypi/v/cirro.svg)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=CirroBio_Cirro-client&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=CirroBio_Cirro-client)

  A Python 3.9+ library for the Cirro platform.



  You can install Cirro using pip:

  `pip install cirro`

  or you can install the main branch of the repo by running:

  `pip install git+https://github.com/CirroBio/Cirro-client.git`



  Upon first use, the Cirro client will ask you what Cirro instance to use and if you would like to save your login information.
  It will then give you a link to authenticate through the web browser.

  You can change your Cirro instance by running `cirro configure` and selecting the desired instance.

  If you need to change your credentials after this point, and you've opted to save your login, please see the [clearing saved login](#clearing-saved-login) section.




  ```bash
  Usage: cirro download [OPTIONS]

    Download dataset files

  Options:
    --project TEXT         Name or ID of the project
    --dataset TEXT         ID of the dataset
    --file... TEXT         Name and relative path of the file (optional)
    --data-directory TEXT  Directory to store the files
    -i, --interactive      Gather arguments interactively
    --help                 Show this message and exit.
  ```


  ```bash
  Usage: cirro upload [OPTIONS]

    Upload and create a dataset

  Options:
    --name TEXT             Name of the dataset
    --description TEXT      Description of the dataset (optional)
    --project TEXT          Name or ID of the project
    --process TEXT          Name or ID of the ingest process
    --data-directory TEXT   Directory you wish to upload
    -i, --interactive       Gather arguments interactively
    --help                  Show this message and exit.
  ```


  ```bash
  Usage: cirro list-datasets [OPTIONS]

    List available datasets

  Options:
    --project TEXT         ID of the project
    -i, --interactive      Gather arguments interactively
    --help                 Show this message and exit.
  ```



  When running a command, you can specify the `--interactive` flag to gather the command arguments interactively.

  Example:

  ```bash
  $ cirro upload --interactive
  ? What project is this dataset associated with?  Test project
  ? Enter the full path of the data directory  /shared/biodata/test
  ? Please confirm that you wish to upload 20 files (0.630 GB)  Yes
  ? What type of files?  Illumina Sequencing Run
  ? What is the name of this dataset?  test
  ? Enter a description of the dataset (optional)
  ```



  See the following set of Jupyter notebooks that contain examples on the following topics:

  | Jupyter Notebook                                                   | Topic                                |
  | ------------------------------------------------------------------ | ------------------------------------ |
  | [Introduction](samples/Getting_started.ipynb)                      | Installing and authenticating        |
  | [Uploading a dataset](samples/Uploading_a_dataset.ipynb)           | Uploading data                       |
  | [Downloading a dataset](samples/Downloading_a_dataset.ipynb)       | Downloading data                     |
  | [Interacting with a dataset](samples/Interacting_with_files.ipynb) | Calling data and reading into tables |
  | [Analyzing a dataset](samples/Analyzing_a_dataset.ipynb)           | Running analysis pipelines           |
  | [Using references](samples/Using_references.ipynb)                 | Managing reference data              |
  | [Advanced usage](samples/Advanced_usage.ipynb)                     | Advanced operations                  |



  | Jupyter Notebook                                    | Topic               |
  | --------------------------------------------------- | ------------------- |
  | [Downloading a dataset in R](samples/Using-R.ipynb) | Reading data with R |



  View the API documentation for this library [here](https://cirrobio.github.io/Cirro-client/).



  | Name           | Description                   | Default  |
  | -------------- | ----------------------------- | -------- |
  | CIRRO_HOME     | Local configuration directory | ~/.cirro |
  | CIRRO_BASE_URL | Base URL of the data portal   |          |



  The `cirro configure` command creates a file in `CIRRO_HOME` called `config.ini`.

  You can set the `base_url` property in the config file rather than using the environment variable.

  The `transfer_max_retries` configuration property specifies the maximum number of times to attempt uploading a file to Cirro in the event of a transfer failure.
  When uploading files to Cirro, network issues or temporary outages can occasionally cause a transfer to fail.
  It will pause for an increasing amount of time for each retry attempt.

  The `enable_additional_checksums` property manages the utilization of SHA-256 hashing for enhanced data integrity.
  This feature computes the SHA-256 hash of a file during the upload process, and subsequently cross-validates it with the server upon completion.
  When retrieving files, it ensures that the hash received matches the server's stored hash.
  The default hashing algorithm for files is MD5. In many cases, MD5 is sufficient to ensure data integrity upon upload.

  ```ini
  [General]
  base_url = cirro.bio
  transfer_max_retries = 15
  enable_additional_checksums = true
  ```



  You can clear your saved login information by removing the `~/.cirro/token.dat` file from your system or
  by running `cirro configure` and selecting **No** when it asks if you'd like to save your login information.


pkgId: b9b457ed805d5d449c9eeb82e94751635a3a251401f08f67a1ce219f202e6cc7
name: python-cirro
arch: src
version: 1.2.5
epoch: 0
release: 1
summary: CLI tool and SDK for interacting with the Cirro platform
url: https://github.com/CirroBio/Cirro-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirro-1.2.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Python package](https://github.com/FredHutch/Cirro-client/actions/workflows/package.yml/badge.svg)](https://github.com/FredHutch/Cirro-client/actions/workflows/package.yml)
  [![Lint and run tests](https://github.com/FredHutch/Cirro-client/actions/workflows/lint.yml/badge.svg)](https://github.com/FredHutch/Cirro-client/actions/workflows/lint.yml)
  ![](https://img.shields.io/pypi/v/cirro.svg)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=CirroBio_Cirro-client&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=CirroBio_Cirro-client)

  A Python 3.9+ library for the Cirro platform.



  You can install Cirro using pip:

  `pip install cirro`

  or you can install the main branch of the repo by running:

  `pip install git+https://github.com/CirroBio/Cirro-client.git`



  Upon first use, the Cirro client will ask you what Cirro instance to use and if you would like to save your login information.
  It will then give you a link to authenticate through the web browser.

  You can change your Cirro instance by running `cirro configure` and selecting the desired instance.

  If you need to change your credentials after this point, and you've opted to save your login, please see the [clearing saved login](#clearing-saved-login) section.




  ```bash
  Usage: cirro download [OPTIONS]

    Download dataset files

  Options:
    --project TEXT         Name or ID of the project
    --dataset TEXT         ID of the dataset
    --data-directory TEXT  Directory to store the files
    -i, --interactive      Gather arguments interactively
    --help                 Show this message and exit.
  ```


  ```bash
  Usage: cirro upload [OPTIONS]

    Upload and create a dataset

  Options:
    --name TEXT             Name of the dataset
    --description TEXT      Description of the dataset (optional)
    --project TEXT          Name or ID of the project
    --process TEXT          Name or ID of the ingest process
    --data-directory TEXT   Directory you wish to upload
    -i, --interactive       Gather arguments interactively
    --help                  Show this message and exit.
  ```


  ```bash
  Usage: cirro list-datasets [OPTIONS]

    List available datasets

  Options:
    --project TEXT         ID of the project
    -i, --interactive      Gather arguments interactively
    --help                 Show this message and exit.
  ```



  When running a command, you can specify the `--interactive` flag to gather the command arguments interactively.

  Example:

  ```bash
  $ cirro upload --interactive
  ? What project is this dataset associated with?  Test project
  ? Enter the full path of the data directory  /shared/biodata/test
  ? Please confirm that you wish to upload 20 files (0.630 GB)  Yes
  ? What type of files?  Illumina Sequencing Run
  ? What is the name of this dataset?  test
  ? Enter a description of the dataset (optional)
  ```



  See the following set of Jupyter notebooks that contain examples on the following topics:

  | Jupyter Notebook                                                   | Topic                                |
  |--------------------------------------------------------------------|--------------------------------------|
  | [Introduction](samples/Getting_started.ipynb)                      | Installing and authenticating        |
  | [Uploading a dataset](samples/Uploading_a_dataset.ipynb)           | Uploading data                       |
  | [Downloading a dataset](samples/Downloading_a_dataset.ipynb)       | Downloading data                     |
  | [Interacting with a dataset](samples/Interacting_with_files.ipynb) | Calling data and reading into tables |
  | [Analyzing a dataset](samples/Analyzing_a_dataset.ipynb)           | Running analysis pipelines           |
  | [Using references](samples/Using_references.ipynb)                 | Managing reference data              |
  | [Advanced usage](samples/Advanced_usage.ipynb)                     | Advanced operations                  |



  | Jupyter Notebook                                    | Topic               |
  |-----------------------------------------------------|---------------------|
  | [Downloading a dataset in R](samples/Using-R.ipynb) | Reading data with R |



  View the API documentation for this library [here](https://cirrobio.github.io/Cirro-client/).



  | Name           | Description                   | Default  |
  |----------------|-------------------------------|----------|
  | CIRRO_HOME     | Local configuration directory | ~/.cirro |
  | CIRRO_BASE_URL | Base URL of the data portal   |          |



  The `cirro configure` command creates a file in `CIRRO_HOME` called `config.ini`.

  You can set the `base_url` property in the config file rather than using the environment variable.

  The `transfer_max_retries` configuration property specifies the maximum number of times to attempt uploading a file to Cirro in the event of a transfer failure.
  When uploading files to Cirro, network issues or temporary outages can occasionally cause a transfer to fail.
  It will pause for an increasing amount of time for each retry attempt.

  The `enable_additional_checksums` property manages the utilization of SHA-256 hashing for enhanced data integrity.
  This feature computes the SHA-256 hash of a file during the upload process, and subsequently cross-validates it with the server upon completion.
  When retrieving files, it ensures that the hash received matches the server's stored hash.
  The default hashing algorithm for files is MD5. In many cases, MD5 is sufficient to ensure data integrity upon upload.

  ```ini
  [General]
  base_url = cirro.bio
  transfer_max_retries = 15
  enable_additional_checksums = true
  ```



  You can clear your saved login information by removing the `~/.cirro/token.dat` file from your system or
  by running `cirro configure` and selecting **No** when it asks if you'd like to save your login information.


pkgId: 508b5b12d1d0c3c57c5d7391edef9446e3239fe8e2e4604965346fa6172c7e18
name: python-cirro_api_client
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A client library for accessing Cirro
url: https://github.com/CirroBio/Cirro-client-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirro_api_client-0.2.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/v/cirro-api-client.svg)](https://pypi.org/project/cirro_api_client/)

  Low-level client for the Cirro API. Rather than using this package directly, we recommend using the [Cirro SDK](https://github.com/CirroBio/Cirro-client).

  This Python package is automatically generated by the [OpenAPI Python Client](https://github.com/openapi-generators/openapi-python-client) project.



  Python 3.8+.




  Via PyPI:
  ```sh
  pip install cirro-api-client
  ```

  You can also install it directory from the repository using:

  ```sh
  pip install git+https://github.com/CirroBio/Cirro-client-python.git
  ```





  ```python
  import os
  from typing import List
  from pprint import pprint

  from cirro_api_client import CirroApiClient, TokenAuth
  from cirro_api_client.v1.api.projects import get_projects
  from cirro_api_client.v1.models import Project
  from cirro_api_client.v1.types import Response


  auth_method = TokenAuth(token=os.environ['TOKEN'])




  client = CirroApiClient(base_url="https://api.cirro.bio",
                          auth_method=auth_method)


  projects: List[Project] = get_projects.sync(client=client)
  print("The response of get_projects:\n")
  pprint(projects)

  resp: Response[List[Project]] = get_projects.sync_detailed(client=client)
  projects = resp.parsed
  ```


  ```python
  import os
  from typing import List

  from cirro_api_client import CirroApiClient, TokenAuth
  from cirro_api_client.v1.api.projects import get_projects
  from cirro_api_client.v1.models import Project

  client = CirroApiClient(base_url="https://api.cirro.bio",
                          auth_method=TokenAuth(token=os.environ['TOKEN']))


  async with client as client:
      projects: List[Project] = await get_projects.asyncio(client=client)
  ```



  There are more settings on the generated `CirroApiClient` class which let you control more runtime behavior, check out the docstring on that class for more info. You can also customize the underlying `httpx.Client` or `httpx.AsyncClient` (depending on your use-case):

  ```python
  import os
  from cirro_api_client import CirroApiClient, TokenAuth

  def log_request(request):
      print(f"Request event hook: {request.method} {request.url} - Waiting for response")

  def log_response(response):
      request = response.request
      print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")

  client = CirroApiClient(
      base_url="https://api.cirro.bio",
      auth_method=TokenAuth(token=os.environ['TOKEN']),
      httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
  )


  ```

  You can even set the httpx client directly, but beware that this will override any existing settings (e.g., base_url):

  ```python
  import os
  import httpx
  from cirro_api_client import CirroApiClient, TokenAuth

  client = CirroApiClient(base_url="https://api.cirro.bio",
                          auth_method=TokenAuth(token=os.environ['TOKEN']))


  client.set_httpx_client(httpx.Client(base_url="https://api.cirro.bio", proxies="http://localhost:8030"))
  ```



  Re-generate the API client by running:

  ```sh
  openapi-python-client update --url https://dev.cirro.bio/openapi/cirro-data-latest.yml --config config.yml --custom-template-path=templates/
   ```


pkgId: 119ffe5ad7d57084b3fcd8bbdafbe52e553121dd3a64a59c58919f6045fecb29
name: python-cirrocumulus
arch: src
version: 1.1.58
epoch: 0
release: 1
summary: Bring your single-cell data to life
url: https://pypi.org/project/cirrocumulus/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirrocumulus-1.1.58-1.src.rpm
checksum_type: sha256
description:
  Cirrocumulus is an interactive visualization tool for large-scale single-cell genomics data, with the following features:
  * Visualize datasets in h5ad_, `10x h5`_, Xenium_, loom_, Seurat_, TileDB_, or zarr_ formats
  * View MERFISH_ or other spatial transcriptomics data overlaid on an image
  * Easily deploy on a laptop, on-premise server, cloud VM, or Google App Engine
  * Share the current visualization state in a URL
  * Share datasets securely with collaborators
  * Create dotplots, heatmaps, and violin plots to explore relationships between categorical variables and expression
  * Generate composition plots to inspect cluster makeup
  * Explore complete differential expression results generated by `Scanpy`_ or `Pegasus`_/`Cumulus`_
  * Interactively create and share “AND” or “OR” filters
  * Collaboratively annotate cell types in real time, optionally using a controlled vocabulary (`example ontology`_)
  * Quickly load multiple features from predefined lists (`see example`_)
  * Explore multiple features and embeddings simultaneously
  * Fast interactive exploration of 2 and 3-d embeddings of millions of cells, including zoom, pan, rotate (3-d), and lasso tools
  * Save publication quality images
  * Highly customizable - for example, set the color map, point size, or whether to use fog for 3-d embeddings to fade distant points

rpm_license:
  BSD 3-Clause License  Copyright (c) 2022, klarman-cell-observatory All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 933ae0493e90dd4bf7166ea8b3a59d6bc2f1e525cdb667169b20600cff352555
name: python-cirrus-geo
arch: src
version: 0.15.3
epoch: 0
release: 1
summary: cli for cirrus, a severless STAC-based processing pipeline
url: https://github.com/cirrus-geo/cirrus
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cirrus-geo-0.15.3-1.src.rpm
checksum_type: sha256
description:
  [![build-status-image]][build-status]
  [![coverage-status-image]][codecov]
  [![pypi-version]][pypi]



  Cirrus is a [STAC](https://stacspec.org/)-based geospatial processing pipeline platform,
  implemented using a scalable architecture deployed on AWS. Cirrus provides the generic
  infrastructure for processing, allowing a user to focus on implementing the specific
  processing logic for their data.

  ![](src/cirrus/docs/images/arch-overview.png)

  As input, Cirrus takes a STAC ItemCollection, with a process definition block.
  That input is called a Cirrus `ProcessPayload` (CPP).

  An input is run through a workflow that generates one or more output STAC Items.
  These output Items are added to the Cirrus static STAC catalog in S3,
  and are also broadcast via an SNS topic. Subscriptions to that topic can
  triggering additional workflows or external processes, such as indexing into a
  STAC API catalog (e.g.,
  [stac-server](https://github.com/stac-utils/stac-server)).

  Cirrus workflows range from the simple publishing of unmodified input items to
  the complex transformation of input Items and generation of wholly-new output
  Items. The current state of CPP processing is tracked in a state database
  to prevent duplicate processing and allow for a user to follow the state of any
  input through the pipeline.

  As shown in this high-level overview of Cirrus, users input data to Cirrus
  through the use of _feeders_. Feeders are simply programs that get/generate
  some type of STAC metadata, combine it with processing parameters, and pass it
  into Cirrus as a CPP.

  Because Cirrus output is published via SNS, a Feeder can be configured to
  subscribe to that SNS and thus workflows can be chained, such that the output
  of one workflow becomes the input to another workflow, creating multiple levels
  of products all with published STAC metadata and clear links showing data
  provenance.



  If developing new code for cirrus-geo, checkout the [Contributing Guide](CONTRIBUTING.md).



  A Cirrus project is managed via the `cirrus` cli tool.
  Here's everything required to create, modify, and deploy a new project:

  ```

  ❯ mkdir cirrus-project; cd cirrus-project


  ❯ python -m venv .venv


  ❯ . .venv/bin/activate


  ❯ pip install cirrus-geo
  ...


  ❯ cirrus
  Usage: cirrus [OPTIONS] COMMAND [ARGS]...

    cli for cirrus, a severless STAC-based processing pipeline

  Options:
    --cirrus-dir DIRECTORY
    -v, --verbose           Increase logging level. Can be specified multiple
                            times.  [x>=0]
    --help                  Show this message and exit.

  Commands:
    build             Build the cirrus configuration into a serverless.yml.
    clean             Remove all files from the cirrus build directory.
    create            Create a new component in the project.
    init              Initialize a cirrus project in DIRECTORY.
    serverless (sls)  Run serverless within the cirrus build directory.
    show              Multifunction command to list/show components,
                      component...



  ❯ cirrus init
  Succesfully initialized project in '/Users/jkeifer/cirrus-project'.

  ❯ ls
  .venv/	cirrus.yml  /cloudformation  feeders/  functions/  package.json  tasks/  workflows/




















  ❯ npm install
  ...


  ❯ cirrus show feeders
  feed-rerun (built-in): Rerun items in the database

  ❯ cirrus show tasks
  post-batch (built-in, lambda): Post process batch job by copying input from S3
  pre-batch (built-in, lambda): Pre process batch job by copying input to S3
  publish (built-in, lambda): Publish resulting STAC Collections and Items to catalog, and optionally SNS

  ❯ cirrus show workflows
  publish-only (built-in): Simple example that just published input Collections and Items


  ❯ cirrus create task -t lambda a_task "A task that doesn't do much yet"
  task a_task created

  ❯ cirrus show tasks
  post-batch (built-in, lambda): Post process batch job by copying input from S3
  pre-batch (built-in, lambda): Pre process batch job by copying input to S3
  publish (built-in, lambda): Publish resulting STAC Collections and Items to catalog, and optionally SNS
  a_task (lambda): A task that doesn't do much yet



  ❯ tree tasks
  tasks
  └── a_task
      ├── README.md
      ├── definition.yml
      └── lambda_function.py



  ❯ cirrus build


  ❯ ls .cirrus
  lambdas/  serverless.yml



  ❯ cirrus serverless deploy
  ```



  A Cirrus project, most basically, is a directory containing a cirrus.yml
  configuration file. However, several subfolders are used to organize
  additional object definitions for custom implementations.

  | Folder         | Purpose                                                            |
  | :------------- | ------------------------------------------------------------------ |
  | cloudformation | Raw cloudformation templates to include in the project             |
  | feeders        | Feeder Lambda functions used to add data to Cirrus                 |
  | functions      | Misc Lambda functions required by a project                        |
  | tasks          | Task Lambda function used within workflows                         |
  | workflows      | AWS Step Function definitions describing data processing workflows |



  Cirrus is divided up into several repositories, all under the
  [cirrus-geo](https://github.com/cirrus-geo) organization on GitHub,
  with this repository (`cirrus-geo`) the main one of interest to users.

  | Repository                                                             | Purpose                                                                                                                                         |
  | :--------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
  | cirrus-geo                                                             | Main Cirrus repo implementing the `cirrus` cli tool for managing Cirrus projects. Also provides the base set of lambda functions and workflows. |
  | [cirrus-lib](https://github.com/cirrus-geo/cirrus-lib)                 | A Python library of convenience functions to interact with Cirrus. Lambda functions are kept lightweight                                        |
  | [cirrus-task-images](https://github.com/cirrus-geo/cirrus-task-images) | Dockerfiles and code for publishing Cirrus Docker images to Docker Hub that are used in Cirrus Batch tasks                                      |

  The `cirrus` cli utilitiy is what is used to create, manage, and deploy
  Cirrus projects, and is pip-installable. The pip-installable python
  library `cirrus-lib` is used from all Cirrus Lambdas and tasks and is
  available to developers for writing their own tasks.



  Documentation for deploying, using, and customizing Cirrus is contained
  within the [docs](https://cirrus-geo.github.io/cirrus-geo/) directory:

  - Learn how to [get started](https://cirrus-geo.github.io/cirrus-geo/stable/cirrus/10_intro.html)
  - Understand the [architecture](https://cirrus-geo.github.io/cirrus-geo/stable/cirrus/20_arch.html) of Cirrus and key concepts
  - [Use](https://cirrus-geo.github.io/cirrus-geo/stable/cirrus/30_payload.html) Cirrus to process input data and publish resulting STAC Items
  - Cirrus features several [component types](https://cirrus-geo.github.io/cirrus-geo/stable/cirrus/60_components.html) that each represent a specific role within the Cirrus architecture



  Cirrus is an Open-Source pipeline for processing geospatial data in AWS.
  Cirrus was developed by [Element 84](https://element84.com/) originally
  under a [NASA ACCESS project](https://earthdata.nasa.gov/esds/competitive-programs/access)
  called [Community Tools for Analysis of NASA Earth Observation System Data in the Cloud](https://earthdata.nasa.gov/esds/competitive-programs/access/eos-data-cloud).

  [build-status-image]: https://github.com/cirrus-geo/cirrus-geo/actions/workflows/python-test.yml/badge.svg
  [build-status]: https://github.com/cirrus-geo/cirrus-geo/actions/workflows/python-test.yml
  [coverage-status-image]: https://img.shields.io/codecov/c/github/cirrus-geo/cirrus-geo/master.svg
  [codecov]: https://codecov.io/github/cirrus-geo/cirrus-geo?branch=master
  [pypi-version]: https://img.shields.io/pypi/v/cirrus-geo.svg
  [pypi]: https://pypi.org/project/cirrus-geo/


pkgId: 0c666bf75493e244fca90dd4300da01c504be99d7109a35f26a9630778383b06
name: python-cisco-config-parser
arch: src
version: 2.2.7
epoch: 0
release: 1
url: https://github.com/arezazadeh/cisco_config_parser
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cisco-config-parser-2.2.7-1.src.rpm
checksum_type: sha256
summary:
  This library is used for Network Automation involving Cisco Routers and Switch. It will parse Cisco IOS, IOS-XE, IOS-XR, and NXOS configuration file into objects and/or json format

description:
  with open("show_run.txt", "r") as file_output:
      content = file_output.read()
  obj = ConfigParser(content)
  obj.get_static_routes() << Returns a list of objects
  obj.get_static_routes(return_json=True) << Returns a list of dictionaries
  ```


  ```python
  >>> ios_file = "/Users/fileFolder/devFolder/config.txt"
  >>> with open(ios_file, "r") as f:
          running_config = f.read()
  >>> from cisco_config_parser import ConfigParser
  >>>
  >>> parser = ConfigParser(running_config)
  ```

  In layer-3 interface, the class attempts to capture all the important attributes of the interface, such as:
  - IPv4 Address
  - Subnet
  - Subnet Mask
  - Secondary IPv4 Address
  - Secondary Subnet
  - Secondary Subnet Mask
  - HSRP or VRRP Config
      - VIP

  One of the great feature in this library is it captures all the subnets that are being used in your Network Device along with their usage.
  Also it tells you how many of each subnet masks are being used as well. I personaly use this feature when i need to automate DHCP/IPAM documentaion cleanup.
  **Example below illustriates this feature:**
  ```python
  >>> subnet_usage = parser.get_subnet_and_usage(include_subnet_count=True)
  >>> print(json.dumps(subnet_usage, indent=4))
  {
      "Loopback100": "10.241.17.8/32",
      "Loopback200": "10.252.248.1/32",
      "Vlan200": "10.252.182.0/23",
      "Vlan300": "10.244.16.160/27",
      "Vlan310": "10.241.101.80/28",
      "Vlan400": "10.39.10.32/27",
      "Vlan700": "172.31.81.0/25",
      "Vlan1100": "10.242.12.0/26",
      "Vlan1125": "10.241.8.0/27",
      "Vlan1126": "10.241.8.32/27",
      "Vlan1127": "10.241.8.64/27",
      "subnet_count": {
          "/32": 2,
          "/23": 1,
          "/27": 5,
          "/28": 1,
          "/25": 1,
          "/26": 1,
      }
  }
  ```

  ```python
  >>> l3_interfaces = parser.get_l3_interfaces()
  >>>for l3 in l3_interfaces:
          print(l3.name)
          print(l3.ip_address, l3.subnet)
          print("!")
  Loopback100
  10.241.17.8 10.241.17.8/32
  !
  Loopback200
  10.252.248.1 10.252.248.1/32
  !
  Loopback202
  10.245.0.199 10.245.0.199/32
  ```

  ```python
  >>> l3_interfaces = parser.get_l3_interfaces(return_json=True)
  >>> print(json.dumps(l3_interfaces, indent=4))
  [
      {
          "name": "Loopback100",
          "description": "SWITCH01-SA01 Loopback IP",
          "ip_address": "10.241.17.8",
          "mask": "255.255.255.255",
          "subnet": "10.241.17.8/32",
          "helpers": null,
          "sec_ip_address": null,
          "sec_mask": null,
          "sec_subnet": null,
          "vrf": "mgt100",
          "state": null,
          "vip": null,
          "children": [
              "description SWITCH01-SA01 Loopback IP",
              "ip vrf forwarding mgt100",
              "ip address 10.241.17.8 255.255.255.255",
              "ip pim sparse-mode",
              "ip ospf 100 area 0"
          ]
      },
  ]
  ```

  ```python
  >>> l3_interfaces = parser.get_l3_interfaces(ip_pim="ip pim.*")
  >>> for i in l3_interfaces:
          print(i.name)
          print(i.ip_pim)
          print("!")
  Loopback100
  ip pim sparse-mode
  !
  Loopback200
  ip pim sparse-mode
  !
  ```


  ```python
  >>> access_ports = parser.get_l2_access_interfaces()
  >>>
  >>> for intf in access_ports:
      print(intf.name)
      print(intf.description)
      print(intf.children)
      print("!")
  GigabitEthernet1/1
  Data Users
  ['description Data Users', 'switchport access vlan 200', 'switchport mode access', 'switchport voice vlan 700', 'no logging event power-inline-status', 'ip dhcp snooping information option allow-untrusted']
  !
  GigabitEthernet1/2
  Data Users
  ['description Data Users', 'switchport access vlan 200', 'switchport mode access', 'switchport voice vlan 700', 'no logging event power-inline-status', 'ip dhcp snooping information option allow-untrusted']
  !
  ```

  ```python
  >>> access_ports = parser.get_l2_access_interfaces(return_json=True)
  >>> print(json.dumps(access_ports, indent=4))
  [
      {
          "name": "GigabitEthernet1/1",
          "description": "DATA Users",
          "data_vlan": "200",
          "voice_vlan": "700",
          "state": null,
          "spanning_tree": null,
          "native_vlan": null,
          "children": [
              "description DATA Users",
              "switchport access vlan 200",
              "switchport mode access",
              "switchport voice vlan 700",
              "no logging event power-inline-status",
              "ip dhcp snooping information option allow-untrusted"
          ]
      },
  ]
  ```

  You can use your own custom regex with your own key, this key then become a dynamic method of the class where you can either call it or recieve it as json format.
  ```python
  >>> access_ports = parser.get_l2_access_interfaces(logging="no loggin.*", return_json=True)
  >>> print(json.dumps(access_ports, indent=4))
  [
      {
          "name": "GigabitEthernet1/1",
          "description": "SHC-Users",
          "data_vlan": "200",
          "voice_vlan": "700",
          "state": null,
          "spanning_tree": null,
          "native_vlan": null,
          "children": [
              "description SHC-Users",
              "switchport access vlan 200",
              "switchport mode access",
              "switchport voice vlan 700",
              "no logging event power-inline-status",
              "ip dhcp snooping information option allow-untrusted"
          ],
          "logging": "no logging event power-inline-status"                       <<<<< custom Key to find logging command
      },
  ]
  ```

  ```python
  >>> trunk_interfaces = parser.get_l2_trunk_interfaces()
  >>> for intf in trunk_interfaces:
          print(intf.name)
          print(intf.description)
          print("!")
  TenGigabitEthernet5/1
  (MP)SWITCH-SD03:Twe1/0/6
  !
  TenGigabitEthernet5/2
  Link to SWITCH-SA01 Te6/2 Decomm
  !
  TenGigabitEthernet6/1
  (MP)SWITCH-SD04:Te1/1
  !
  ```

  ```python
  >>> trunk_interfaces = parser.get_l2_trunk_interfaces(return_json=True)
  >>> print(json.dumps(trunk_interfaces, indent=4))
  [
      {
          "name": "TenGigabitEthernet5/1",
          "description": "(MP)SWITCH-SD03:Twe1/0/6",
          "allowed_vlans": null,
          "dhcp_snooping": null,
          "dhcp_relay": null,
          "voice_vlan": null,
          "state": null,
          "spanning_tree": null,
          "native_vlan": "256",
          "children": [
              "description (MP)SWITCH-SD03:Twe1/0/6",
              "switchport trunk native vlan 256",
              "switchport trunk allowed vlan 182,256,504,1100,3101,3201,3301,3311,3321,3331",
              "switchport trunk allowed vlan add 3351,3401,3411,3911",
              "switchport mode trunk",
              "load-interval 30",
              "udld port aggressive",
              "service-policy output egress_queueing",
              "ip dhcp snooping trust"
          ],
          "allowed_vlan": "182,256,504,1100,3101,3201,3301,3311,3321,3331"
      },
  ]
  ```

  ```python
  >>> access_ports = parser.parser.get_l2_trunk_interfaces(load="load.*", return_json=True)
  >>> print(json.dumps(access_ports, indent=4))
      {
          "name": "TenGigabitEthernet5/1",
          "description": "(MP)SWITCH-SD03:Twe1/0/6",
          "allowed_vlans": null,
          "dhcp_snooping": null,
          "dhcp_relay": null,
          "voice_vlan": null,
          "state": null,
          "spanning_tree": null,
          "native_vlan": "256",
          "children": [
              "description (MP)STNMED-LPCH-SD03:Twe1/0/6",
              "switchport trunk native vlan 256",
              "switchport trunk allowed vlan 182,256,504,1100,3101,3201,3301,3311,3321,3331",
              "switchport trunk allowed vlan add 3351,3401,3411,3911",
              "switchport mode trunk",
              "load-interval 30",
              "udld port aggressive",
              "service-policy output egress_queueing",
              "ip dhcp snooping trust"
          ],
          "allowed_vlan": "182,256,504,1100,3101,3201,3301,3311,3321,3331",
          "load": "load-interval 30"                                      <<<<< Custom Key and Value
      },
  ```

  **Features**
  - Parse Static Routes: Extract and parse static routing commands (ip route entries) from Cisco running configurations.
  - Convert to Python Objects: Represent these routes as structured Python objects, enabling programmatic manipulation and easy integration with Python-based tools.
  - Export to JSON/Dict: Convert static routing information into JSON or dictionary format, making it straightforward to use in web applications, APIs, or data storage solutions.

  **Python Object:**
  ```python
  >>> static = parser.get_static_config()
  >>> for i in static:
          print(i.subnet, i.name, i.nexthop_ip)
  0.0.0.0/0 MC-RS01 10.240.129.3
  0.0.0.0/0 NC-RS01 10.240.129.11
  10.243.98.32/28 P2P_Subnet 10.243.99.186
  ```
  **Json/Dict:**
  ```python
  static = parser.get_static_config()
  [
      {
          "network": "0.0.0.0",
          "mask": "0.0.0.0",
          "nexthop_ip": "10.240.129.3",
          "subnet": "0.0.0.0/0",
          "vrf": "default",
          "name": "MC-RS01",
          "admin_distance": null
      },
  ]
  ```


  `eigrp_configs = parser.get_eigrp_config(return_json=True)`
  ```json
  [
      {
          "as_number": 300,
          "network": [
              {
                  "network": "10.242.96.240",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              },
              {
                  "network": "10.242.97.244",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              },
              {
                  "network": "10.242.98.248",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              },
              {
                  "network": "10.242.99.252",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              }
          ],
          "vrf": "Global",
          "wild_card_mask": null,
          "subnet": null,
          "has_vrf": true,
          "vrf_count": 8,
          "passive_interface": null,
          "no_passive_interface": null,
          "auto_cost": null,
          "interfaces": null,
          "children": [
              "network 10.242.96.240 0.0.0.3",
              "network 10.242.97.244 0.0.0.3",
              "network 10.242.98.248 0.0.0.3",
              "network 10.242.99.252 0.0.0.3",
              "no passive-interface GigabitEthernet1/9",
              "no passive-interface GigabitEthernet1/10",
              "passive-interface default",
              "no auto-summary"
          ],
          "vrf_children": [
              {
                  "vrf": "mgt100",
                  "network": [
                      {
                          "network": "10.242.96.240",
                          "subnet_mask": "255.255.255.252",
                          "wildcard_mask": "0.0.0.3"
                      }
                  ],
                  "wild_card_mask": null,
                  "subnet": null,
                  "passive_interface": null,
                  "no_passive_interface": null,
                  "auto_cost": null,
                  "interfaces": null,
                  "children": [
                      "redistribute bgp 65240 metric 1000 100 255 1 1500 route-map MGT100_EIGRP_REDIST_BGP",
                      "network 10.242.96.240 0.0.0.3",
                      "passive-interface default",
                      "no passive-interface TenGigabitEthernet1/9.3131",
                      "distribute-list route-map route_map_inbound in",
                      "autonomous-system 300",
                      "exit-address-family"
                  ]
              },
          ]
      }
  ]
  ```

  **Example:**
  `bgp_configs = parser.get_bgp_config(return_json=True)`
  ```json
  [
      {
          "router_id": "10.240.129.45",
          "vrf_list": [
              "blu300",
          ],
          "vrf": "Global",
          "network": [
              "10.245.49.132/32"
          ],
          "peer_group": [
              {
                  "peer_group": {
                      "name": "RR",
                      "remote_as": "65234",
                      "update_source": "Loopback1",
                      "route_map": {
                          "in": "PEER_GROUP_RR_INBOUND",
                          "out": "PEER_GROUP_RR_OUTBOUND"
                      },
                      "neighbors": [
                          {
                              "ip": "10.252.248.251",
                              "description": "RR-Router-01"
                          },
                      ]
                  }
              },
          ],
          "neighbors": null,
          "redistribute": [
              {
                  "vrf": "Global",
                  "protocol": "eigrp 100",
                  "route_map": ""
              }
          ],
          "vrf_children": [
              {
                  "vrf": "blu300",
                  "network": [
                      "10.245.17.132/32"
                  ],
                  "peer_group": null,
                  "neighbors": [
                      {
                          "vrf": "blu300",
                          "ip": "10.245.20.30",
                          "remote_as": "65245",
                          "description": "REMOTE_ROUTER-SA01_BLU300",
                          "update_source": "TenGigabitEthernet10/14.3301",
                          "route_map": {
                              "in": "ALLVRF_BGP_RM_INBOUND",
                              "out": "ALLVRF_BGP_RM_OUTBOUND"
                          }
                      }
                  ],
                  "redistribute": [
                      {
                          "vrf": "blu300",
                          "protocol": "eigrp 252",
                          "route_map": " BLU300_BGP_REDIST_EIGRP"
                      },
                      {
                          "vrf": "blu300",
                          "protocol": "static",
                          "route_map": " BLU300_BGP_REDIST_STATIC"
                      }
                  ],
              }
          ]
      }
  ]
  ```

  In ospf, ConfigParser attemps to capture any interfaces that are participating in OSPF as well.
  **Example:**
  `ospf = parser.get_ospf_config(return_json=True)`
  ```json
  [
      {
          "process_id": "240",
          "router_id": "10.240.129.45",
          "network": [
              {
                  "network": "10.3.3.0",
                  "subnet_mask": "255.255.255.0",
                  "wildcard_mask": "0.0.0.255",
                  "area": "0"
              }
          ],
          "wild_card_mask": null,
          "subnet": null,
          "vrf": null,
          "passive_interface": [
              {
                  "interface": "default"
              }
          ],
          "no_passive_interface": [
              {
                  "interface": "GigabitEthernet1/0"
              }
          ],
          "auto_cost": "10000",
          "interfaces": [
              {
                  "interface": "Loopback0",
                  "area": "0",
                  "process_id": "240"
              }
          ]
      }
  ]
  ```

  **Example:**
  `custom_search = parser.get_parent_child(parent_regex="aaa.*", child_regex="server.*", return_json=True)`
  ```json
  [
      {
          "parent": "aaa group server tacacs+ ISE_TACACS",
          "children": "server tacacs+ ISE_TACACS"
      }
  ]
  ```

  I am actively working on expanding the capabilities of this library. Upcoming features include:
  - **Enhanced support for NXOS**: Additional parsing for NXOS-specific configurations and features.
  - **Full support for IOS-XR**: Expanding coverage for IOS-XR configurations to include more advanced routing and service configurations.
  - **More configuration sections**: Additional Cisco configuration types and attributes will be parsed in future releases.
  Stay tuned for these updates and more in future versions of the library!

  Contributions are welcome! To contribute:
  1. Fork this repository.
  2. Create a feature branch.
  3. Make your changes and add tests if applicable.
  4. Submit a pull request for review.
  5. Feel free to open an issue for any bug reports or feature requests.

  This project is licensed under the MIT License.

  1. **Title and Overview:** I emphasized the functionality of the library with clear mention of automation, parsing, and supported platforms.
  2. **Key Features:** I made the features section clearer and more structured.
  3. **Usage Example:** Added a usage example to make it easy for users to get started.
  4. **Installation:** Provided simple installation instructions using `pip`.
  5. **Contribution and License Sections:** These are standard in open-source projects and help potential contributors know how to get involved.


pkgId: d0e7302c5b0b7761985c775d5e68579b87f216f905a93d7ae1d9e8fb38ee6c4b
name: python-cisco-config-parser
arch: src
version: 2.3.0
epoch: 0
release: 1
url: https://github.com/arezazadeh/cisco_config_parser
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cisco-config-parser-2.3.0-1.src.rpm
checksum_type: sha256
summary:
  This library is used for Network Automation involving Cisco Routers and Switch. It will parse Cisco IOS, IOS-XE, IOS-XR, and NXOS configuration file into objects and/or json format

description:
  with open("show_run.txt", "r") as file_output:
      content = file_output.read()
  obj = ConfigParser(content)
  obj.get_static_routes() << Returns a list of objects
  obj.get_static_routes(return_json=True) << Returns a list of dictionaries
  ```


  ```python
  >>> ios_file = "/Users/fileFolder/devFolder/config.txt"
  >>> with open(ios_file, "r") as f:
          running_config = f.read()
  >>> from cisco_config_parser import ConfigParser
  >>>
  >>> parser = ConfigParser(running_config)
  ```

  In layer-3 interface, the class attempts to capture all the important attributes of the interface, such as:
  - IPv4 Address
  - IPv6 Address
  - Subnet
  - Subnet Mask
  - Secondary IPv4 Address
  - Secondary Subnet
  - Secondary Subnet Mask
  - HSRP or VRRP Config
      - VIP

  One of the great feature in this library is it captures all the subnets that are being used in your Network Device along with their usage.
  Also it tells you how many of each subnet masks are being used as well. I personaly use this feature when i need to automate DHCP/IPAM documentaion cleanup.
  **Example below illustriates this feature:**
  ```python
  >>> subnet_usage = parser.get_subnet_and_usage(include_subnet_count=True)
  >>> print(json.dumps(subnet_usage, indent=4))
  {
      "Loopback100": "10.241.17.8/32",
      "Loopback200": "10.252.248.1/32",
      "Vlan200": "10.252.182.0/23",
      "Vlan300": "10.244.16.160/27",
      "Vlan310": "10.241.101.80/28",
      "Vlan400": "10.39.10.32/27",
      "Vlan700": "172.31.81.0/25",
      "Vlan1100": "10.242.12.0/26",
      "Vlan1125": "10.241.8.0/27",
      "Vlan1126": "10.241.8.32/27",
      "Vlan1127": "10.241.8.64/27",
      "subnet_count": {
          "/32": 2,
          "/23": 1,
          "/27": 5,
          "/28": 1,
          "/25": 1,
          "/26": 1,
      }
  }
  ```

  ```python
  >>> l3_interfaces = parser.get_l3_interfaces()
  >>>for l3 in l3_interfaces:
          print(l3.name)
          print(l3.ip_address, l3.subnet)
          print("!")
  Loopback100
  10.241.17.8 10.241.17.8/32
  !
  Loopback200
  10.252.248.1 10.252.248.1/32
  !
  Loopback202
  10.245.0.199 10.245.0.199/32
  ```

  ```python
  >>> l3_interfaces = parser.get_l3_interfaces(return_json=True)
  >>> print(json.dumps(l3_interfaces, indent=4))
  [
      {
          "name": "Loopback100",
          "description": "SWITCH01-SA01 Loopback IP",
          "ip_address": "10.241.17.8",
          "ipv6_address": "2001:DB8::1/64",
          "mask": "255.255.255.255",
          "subnet": "10.241.17.8/32",
          "helpers": null,
          "sec_ip_address": null,
          "sec_mask": null,
          "sec_subnet": null,
          "vrf": "mgt100",
          "state": null,
          "vip": null,
          "children": [
              "description SWITCH01-SA01 Loopback IP",
              "ip vrf forwarding mgt100",
              "ip address 10.241.17.8 255.255.255.255",
              "ipv6 address 2001:DB8::1/64",
              "ip pim sparse-mode",
              "ip ospf 100 area 0"
          ]
      },
  ]
  ```

  ```python
  >>> l3_interfaces = parser.get_l3_interfaces(ip_pim="ip pim.*")
  >>> for i in l3_interfaces:
          print(i.name)
          print(i.ip_pim)
          print("!")
  Loopback100
  ip pim sparse-mode
  !
  Loopback200
  ip pim sparse-mode
  !
  ```


  ```python
  >>> access_ports = parser.get_l2_access_interfaces()
  >>>
  >>> for intf in access_ports:
      print(intf.name)
      print(intf.description)
      print(intf.children)
      print("!")
  GigabitEthernet1/1
  Data Users
  ['description Data Users', 'switchport access vlan 200', 'switchport mode access', 'switchport voice vlan 700', 'no logging event power-inline-status', 'ip dhcp snooping information option allow-untrusted']
  !
  GigabitEthernet1/2
  Data Users
  ['description Data Users', 'switchport access vlan 200', 'switchport mode access', 'switchport voice vlan 700', 'no logging event power-inline-status', 'ip dhcp snooping information option allow-untrusted']
  !
  ```

  ```python
  >>> access_ports = parser.get_l2_access_interfaces(return_json=True)
  >>> print(json.dumps(access_ports, indent=4))
  [
      {
          "name": "GigabitEthernet1/1",
          "description": "DATA Users",
          "data_vlan": "200",
          "voice_vlan": "700",
          "state": null,
          "spanning_tree": null,
          "native_vlan": null,
          "children": [
              "description DATA Users",
              "switchport access vlan 200",
              "switchport mode access",
              "switchport voice vlan 700",
              "no logging event power-inline-status",
              "ip dhcp snooping information option allow-untrusted"
          ]
      },
  ]
  ```

  You can use your own custom regex with your own key, this key then become a dynamic method of the class where you can either call it or recieve it as json format.
  ```python
  >>> access_ports = parser.get_l2_access_interfaces(logging="no loggin.*", return_json=True)
  >>> print(json.dumps(access_ports, indent=4))
  [
      {
          "name": "GigabitEthernet1/1",
          "description": "SHC-Users",
          "data_vlan": "200",
          "voice_vlan": "700",
          "state": null,
          "spanning_tree": null,
          "native_vlan": null,
          "children": [
              "description SHC-Users",
              "switchport access vlan 200",
              "switchport mode access",
              "switchport voice vlan 700",
              "no logging event power-inline-status",
              "ip dhcp snooping information option allow-untrusted"
          ],
          "logging": "no logging event power-inline-status"                       <<<<< custom Key to find logging command
      },
  ]
  ```

  ```python
  >>> trunk_interfaces = parser.get_l2_trunk_interfaces()
  >>> for intf in trunk_interfaces:
          print(intf.name)
          print(intf.description)
          print("!")
  TenGigabitEthernet5/1
  (MP)SWITCH-SD03:Twe1/0/6
  !
  TenGigabitEthernet5/2
  Link to SWITCH-SA01 Te6/2 Decomm
  !
  TenGigabitEthernet6/1
  (MP)SWITCH-SD04:Te1/1
  !
  ```

  ```python
  >>> trunk_interfaces = parser.get_l2_trunk_interfaces(return_json=True)
  >>> print(json.dumps(trunk_interfaces, indent=4))
  [
      {
          "name": "TenGigabitEthernet5/1",
          "description": "(MP)SWITCH-SD03:Twe1/0/6",
          "allowed_vlans": null,
          "dhcp_snooping": null,
          "dhcp_relay": null,
          "voice_vlan": null,
          "state": null,
          "spanning_tree": null,
          "native_vlan": "256",
          "children": [
              "description (MP)SWITCH-SD03:Twe1/0/6",
              "switchport trunk native vlan 256",
              "switchport trunk allowed vlan 182,256,504,1100,3101,3201,3301,3311,3321,3331",
              "switchport trunk allowed vlan add 3351,3401,3411,3911",
              "switchport mode trunk",
              "load-interval 30",
              "udld port aggressive",
              "service-policy output egress_queueing",
              "ip dhcp snooping trust"
          ],
          "allowed_vlan": "182,256,504,1100,3101,3201,3301,3311,3321,3331"
      },
  ]
  ```

  ```python
  >>> access_ports = parser.parser.get_l2_trunk_interfaces(load="load.*", return_json=True)
  >>> print(json.dumps(access_ports, indent=4))
      {
          "name": "TenGigabitEthernet5/1",
          "description": "(MP)SWITCH-SD03:Twe1/0/6",
          "allowed_vlans": null,
          "dhcp_snooping": null,
          "dhcp_relay": null,
          "voice_vlan": null,
          "state": null,
          "spanning_tree": null,
          "native_vlan": "256",
          "children": [
              "description (MP)STNMED-LPCH-SD03:Twe1/0/6",
              "switchport trunk native vlan 256",
              "switchport trunk allowed vlan 182,256,504,1100,3101,3201,3301,3311,3321,3331",
              "switchport trunk allowed vlan add 3351,3401,3411,3911",
              "switchport mode trunk",
              "load-interval 30",
              "udld port aggressive",
              "service-policy output egress_queueing",
              "ip dhcp snooping trust"
          ],
          "allowed_vlan": "182,256,504,1100,3101,3201,3301,3311,3321,3331",
          "load": "load-interval 30"                                      <<<<< Custom Key and Value
      },
  ```

  **Features**
  - Parse Static Routes: Extract and parse static routing commands (ip route entries) from Cisco running configurations.
  - Convert to Python Objects: Represent these routes as structured Python objects, enabling programmatic manipulation and easy integration with Python-based tools.
  - Export to JSON/Dict: Convert static routing information into JSON or dictionary format, making it straightforward to use in web applications, APIs, or data storage solutions.

  **Python Object:**
  ```python
  >>> static = parser.get_static_config()
  >>> for i in static:
          print(i.subnet, i.name, i.nexthop_ip)
  0.0.0.0/0 MC-RS01 10.240.129.3
  0.0.0.0/0 NC-RS01 10.240.129.11
  10.243.98.32/28 P2P_Subnet 10.243.99.186
  ```
  **Json/Dict:**
  ```python
  static = parser.get_static_config()
  [
      {
          "network": "0.0.0.0",
          "mask": "0.0.0.0",
          "nexthop_ip": "10.240.129.3",
          "subnet": "0.0.0.0/0",
          "vrf": "default",
          "name": "MC-RS01",
          "admin_distance": null
      },
  ]
  ```


  `eigrp_configs = parser.get_eigrp_config(return_json=True)`
  ```json
  [
      {
          "as_number": 300,
          "network": [
              {
                  "network": "10.242.96.240",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              },
              {
                  "network": "10.242.97.244",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              },
              {
                  "network": "10.242.98.248",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              },
              {
                  "network": "10.242.99.252",
                  "subnet_mask": "255.255.255.252",
                  "wildcard_mask": "0.0.0.3"
              }
          ],
          "vrf": "Global",
          "wild_card_mask": null,
          "subnet": null,
          "has_vrf": true,
          "vrf_count": 8,
          "passive_interface": null,
          "no_passive_interface": null,
          "auto_cost": null,
          "interfaces": null,
          "children": [
              "network 10.242.96.240 0.0.0.3",
              "network 10.242.97.244 0.0.0.3",
              "network 10.242.98.248 0.0.0.3",
              "network 10.242.99.252 0.0.0.3",
              "no passive-interface GigabitEthernet1/9",
              "no passive-interface GigabitEthernet1/10",
              "passive-interface default",
              "no auto-summary"
          ],
          "vrf_children": [
              {
                  "vrf": "mgt100",
                  "network": [
                      {
                          "network": "10.242.96.240",
                          "subnet_mask": "255.255.255.252",
                          "wildcard_mask": "0.0.0.3"
                      }
                  ],
                  "wild_card_mask": null,
                  "subnet": null,
                  "passive_interface": null,
                  "no_passive_interface": null,
                  "auto_cost": null,
                  "interfaces": null,
                  "children": [
                      "redistribute bgp 65240 metric 1000 100 255 1 1500 route-map MGT100_EIGRP_REDIST_BGP",
                      "network 10.242.96.240 0.0.0.3",
                      "passive-interface default",
                      "no passive-interface TenGigabitEthernet1/9.3131",
                      "distribute-list route-map route_map_inbound in",
                      "autonomous-system 300",
                      "exit-address-family"
                  ]
              },
          ]
      }
  ]
  ```

  **Example:**
  `bgp_configs = parser.get_bgp_config(return_json=True)`
  ```json
  [
      {
          "router_id": "10.240.129.45",
          "vrf_list": [
              "blu300",
          ],
          "vrf": "Global",
          "network": [
              "10.245.49.132/32"
          ],
          "peer_group": [
              {
                  "peer_group": {
                      "name": "RR",
                      "remote_as": "65234",
                      "update_source": "Loopback1",
                      "route_map": {
                          "in": "PEER_GROUP_RR_INBOUND",
                          "out": "PEER_GROUP_RR_OUTBOUND"
                      },
                      "neighbors": [
                          {
                              "ip": "10.252.248.251",
                              "description": "RR-Router-01"
                          },
                      ]
                  }
              },
          ],
          "neighbors": null,
          "redistribute": [
              {
                  "vrf": "Global",
                  "protocol": "eigrp 100",
                  "route_map": ""
              }
          ],
          "vrf_children": [
              {
                  "vrf": "blu300",
                  "network": [
                      "10.245.17.132/32"
                  ],
                  "peer_group": null,
                  "neighbors": [
                      {
                          "vrf": "blu300",
                          "ip": "10.245.20.30",
                          "remote_as": "65245",
                          "description": "REMOTE_ROUTER-SA01_BLU300",
                          "update_source": "TenGigabitEthernet10/14.3301",
                          "route_map": {
                              "in": "ALLVRF_BGP_RM_INBOUND",
                              "out": "ALLVRF_BGP_RM_OUTBOUND"
                          }
                      }
                  ],
                  "redistribute": [
                      {
                          "vrf": "blu300",
                          "protocol": "eigrp 252",
                          "route_map": " BLU300_BGP_REDIST_EIGRP"
                      },
                      {
                          "vrf": "blu300",
                          "protocol": "static",
                          "route_map": " BLU300_BGP_REDIST_STATIC"
                      }
                  ],
              }
          ]
      }
  ]
  ```

  In ospf, ConfigParser attemps to capture any interfaces that are participating in OSPF as well.
  **Example:**
  `ospf = parser.get_ospf_config(return_json=True)`
  ```json
  [
      {
          "process_id": "240",
          "router_id": "10.240.129.45",
          "network": [
              {
                  "network": "10.3.3.0",
                  "subnet_mask": "255.255.255.0",
                  "wildcard_mask": "0.0.0.255",
                  "area": "0"
              }
          ],
          "wild_card_mask": null,
          "subnet": null,
          "vrf": null,
          "passive_interface": [
              {
                  "interface": "default"
              }
          ],
          "no_passive_interface": [
              {
                  "interface": "GigabitEthernet1/0"
              }
          ],
          "auto_cost": "10000",
          "interfaces": [
              {
                  "interface": "Loopback0",
                  "area": "0",
                  "process_id": "240"
              }
          ]
      }
  ]
  ```

  **Example:**
  `custom_search = parser.get_parent_child(parent_regex="aaa.*", child_regex="server.*", return_json=True)`
  ```json
  [
      {
          "parent": "aaa group server tacacs+ ISE_TACACS",
          "children": "server tacacs+ ISE_TACACS"
      }
  ]
  ```

  I am actively working on expanding the capabilities of this library. Upcoming features include:
  - **Enhanced support for NXOS**: Additional parsing for NXOS-specific configurations and features.
  - **Full support for IOS-XR**: Expanding coverage for IOS-XR configurations to include more advanced routing and service configurations.
  - **More configuration sections**: Additional Cisco configuration types and attributes will be parsed in future releases.
  Stay tuned for these updates and more in future versions of the library!

  Contributions are welcome! To contribute:
  1. Fork this repository.
  2. Create a feature branch.
  3. Make your changes and add tests if applicable.
  4. Submit a pull request for review.
  5. Feel free to open an issue for any bug reports or feature requests.

  This project is licensed under the MIT License.

  1. **Title and Overview:** I emphasized the functionality of the library with clear mention of automation, parsing, and supported platforms.
  2. **Key Features:** I made the features section clearer and more structured.
  3. **Usage Example:** Added a usage example to make it easy for users to get started.
  4. **Installation:** Provided simple installation instructions using `pip`.
  5. **Contribution and License Sections:** These are standard in open-source projects and help potential contributors know how to get involved.


pkgId: e10bbddfc081fb5d81c7a59d38b70b6b6ced3ee375544afa5e87cca8d2b1c8be
name: python-cisco-gnmi
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: This library wraps gNMI functionality to ease usage with Cisco implementations.
url: https://github.com/cisco-ie/cisco-gnmi-python
rpm_license: Apache License (2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cisco-gnmi-1.0.16-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)

  This library wraps gNMI functionality to ease usage with Cisco implementations in Python programs. Derived from [openconfig/gnmi](https://github.com/openconfig/gnmi/tree/master/proto).

  **This is not an officially supported Cisco product.** This library is intended to serve as a gNMI client reference implementation and streamline development with Cisco products.

  - [cisco-gnmi-python](#cisco-gnmi-python)
    - [Usage](#usage)
      - [cisco-gnmi CLI](#cisco-gnmi-cli)
      - [ClientBuilder](#clientbuilder)
        - [Initialization Examples](#initialization-examples)
      - [Client](#client)
      - [NXClient](#nxclient)
      - [XEClient](#xeclient)
      - [XRClient](#xrclient)
    - [gNMI](#gnmi)
    - [Development](#development)
      - [Get Source](#get-source)
      - [Code Hygiene](#code-hygiene)
      - [Recompile Protobufs](#recompile-protobufs)
    - [CLI Usage](#cli-usage)
      - [Capabilities](#capabilities)
        - [Usage](#usage-1)
        - [Output](#output)
      - [Get](#get)
        - [Usage](#usage-2)
        - [Output](#output-1)
      - [Set](#set)
        - [Usage](#usage-3)
        - [Output](#output-2)
      - [Subscribe](#subscribe)
        - [Usage](#usage-4)
        - [Output](#output-3)
    - [Licensing](#licensing)
    - [Issues](#issues)
    - [Related Projects](#related-projects)


  ```bash
  pip install cisco-gnmi
  python -c "import cisco_gnmi; print(cisco_gnmi)"
  cisco-gnmi --help
  ```

  This library covers the gNMI defined `Capabilities`, `Get`, `Set`, and `Subscribe` RPCs, and helper clients provide OS-specific recommendations. A CLI (`cisco-gnmi`) is also available upon installation. As commonalities and differences are identified between OS functionality this library will be refactored as necessary.

  Several examples of library usage are available in [`examples/`](examples/). The `cisco-gnmi` CLI script found at [`src/cisco_gnmi/cli.py`](src/cisco_gnmi/cli.py) may also be useful.

  It is *highly* recommended that users of the library learn [Google Protocol Buffers](https://developers.google.com/protocol-buffers/) syntax to significantly ease usage. Understanding how to read Protocol Buffers, and reference [`gnmi.proto`](https://github.com/openconfig/gnmi/blob/master/proto/gnmi/gnmi.proto), will be immensely useful for utilizing gNMI and any other gRPC interface.


  Since `v1.0.5` a gNMI CLI is available as `cisco-gnmi` when this module is installed. `Capabilities`, `Get`, rudimentary `Set`, and `Subscribe` are supported. The CLI may be useful for simply interacting with a Cisco gNMI service, and also serves as a reference for how to use this `cisco_gnmi` library. CLI usage is documented at the bottom of this README in [CLI Usage](#cli-usage).


  Since `v1.0.0` a builder pattern is available with `ClientBuilder`. `ClientBuilder` provides several `set_*` methods which define the intended `Client` connectivity and a `construct` method to construct and return the desired `Client`. There are several major methods involved here:

  ```
      set_target(...)
          Specifies the network element to build a client for.
      set_os(...)
          Specifies which OS wrapper to deliver.
      set_secure(...)
          Specifies that a secure gRPC channel should be used.
      set_secure_from_file(...)
          Loads certificates from file system for secure gRPC channel.
      set_secure_from_target(...)
          Attempts to utilize available certificate from target for secure gRPC channel.
      set_call_authentication(...)
          Specifies username/password to utilize for authentication.
      set_ssl_target_override(...)
          Sets the gRPC option to override the SSL target name.
      set_channel_option(...)
          Sets a gRPC channel option. Implies knowledge of channel options.
      construct()
          Constructs and returns the built Client.
  ```


  `ClientBuilder` can be chained for initialization or instantiated line-by-line.

  ```python
  from cisco_gnmi import ClientBuilder

  builder = ClientBuilder('127.0.0.1:9339')
  builder.set_os('IOS XR')
  builder.set_secure_from_target()
  builder.set_call_authentication('admin', 'its_a_secret')
  client = builder.construct()



  client = ClientBuilder('127.0.0.1:9339').set_os('IOS XR').set_secure_from_target().set_call_authentication('admin', 'its_a_secret').construct()
  ```

  Using an encrypted channel automatically getting the certificate from the device, quick for testing:

  ```python
  from cisco_gnmi import ClientBuilder

  client = ClientBuilder(
      '127.0.0.1:9339'
  ).set_os('IOS XR').set_secure_from_target().set_call_authentication(
      'admin',
      'its_a_secret'
  ).construct()
  ```

  Using an owned root certificate on the filesystem:

  ```python
  from cisco_gnmi import ClientBuilder

  client = ClientBuilder(
      '127.0.0.1:9339'
  ).set_os('IOS XR').set_secure_from_file(
      'ems.pem'
  ).set_call_authentication(
      'admin',
      'its_a_secret'
  ).construct()
  ```

  Passing certificate content to method:

  ```python
  from cisco_gnmi import ClientBuilder


  with open('ems.pem', 'rb') as cert_fd:
      root_cert = cert_fd.read()

  client = ClientBuilder(
      '127.0.0.1:9339'
  ).set_os('IOS XR').set_secure(
      root_cert
  ).set_call_authentication(
      'admin',
      'its_a_secret'
  ).construct()
  ```

  Usage with root certificate, private key, and cert chain:

  ```python
  from cisco_gnmi import ClientBuilder

  client = ClientBuilder(
      '127.0.0.1:9339'
  ).set_os('IOS XE').set_secure_from_file(
      root_certificates='rootCA.pem',
      private_key='client.key',
      certificate_chain='client.crt',
  ).set_call_authentication(
      'admin',
      'its_a_secret'
  ).construct()
  ```



  `Client` is a very barebones class simply implementing `capabilities`, `get`, `set`, and `subscribe` methods. It provides some context around the expectation for what should be supplied to these RPC functions and helpers for validation.

  Methods are documented in [`src/cisco_gnmi/client.py`](src/cisco_gnmi/client.py).


  `NXClient` inherits from `Client` and provides several wrapper methods which aid with NX-OS gNMI implementation usage. These are `subscribe_xpaths`, and the removal of `get` and `set` as they are not yet supported operations. These methods have some helpers and constraints around what is supported by the implementation.

  Methods and usage examples are documented in [`src/cisco_gnmi/nx.py`](src/cisco_gnmi/nx.py).


  `XEClient` inherits from `Client` and provides several wrapper methods which aid with IOS XE gNMI implementation usage. These are `delete_xpaths`, `get_xpaths`, `set_json`, and `subscribe_xpaths`. These methods have some helpers and constraints around what is supported by the implementation.

  Methods and usage examples are documented in [`src/cisco_gnmi/xe.py`](src/cisco_gnmi/xe.py).


  `XRClient` inherits from `Client` and provides several wrapper methods which aid with IOS XR gNMI implementation usage. These are `delete_xpaths`, `get_xpaths`, `set_json`, and `subscribe_xpaths`. These methods have some helpers and constraints around what is supported by the implementation.

  Methods and usage examples are documented in [`src/cisco_gnmi/xr.py`](src/cisco_gnmi/xr.py).


  gRPC Network Management Interface (gNMI) is a service defining an interface for a network management system (NMS) to interact with a network element. It may be thought of as akin to NETCONF or other control protocols which define operations and behaviors. The scope of gNMI is relatively simple - it seeks to "[[define](https://github.com/openconfig/reference/blob/master/rpc/gnmi/gnmi-specification.md)] a gRPC-based protocol for the modification and retrieval of configuration from a target device, as well as the control and generation of telemetry streams from a target device to a data collection system. The intention is that a single gRPC service definition can cover both configuration and telemetry - allowing a single implementation on the target, as well as a single NMS element to interact with the device via telemetry and configuration RPCs".

  gNMI is a specification developed by [OpenConfig](https://openconfig.net), an operator-driven working-group. It is important to note that gNMI only defines a protocol of behavior - not data models. This is akin to SNMP/MIBs and NETCONF/YANG. SNMP and NETCONF are respectively decoupled from the data itself in MIBs and YANG modules. gNMI is a control protocol, not a standardization of data. OpenConfig does develop standard data models as well, and does have some specialized behavior with OpenConfig originating models, but the data models themselves are out of the scope of gNMI.


  Requires Python and utilizes `pipenv` for environment management. Manual usage of `pip`/`virtualenv` is not covered. Uses `black` for code formatting and `pylint` for code linting. `black` is not explicitly installed as it requires Python 3.6+.


  ```bash
  git clone https://github.com/cisco-ie/cisco-gnmi-python.git
  cd cisco-gnmi-python

  pip install --user pipenv

  make setup

  pipenv --three install --dev

  pipenv shell

  exit
  ```


  We use [`black`](https://github.com/ambv/black) for code formatting and [`pylint`](https://www.pylint.org/) for code linting. `hygiene.sh` will run `black` against all of the code under `gnmi/` except for `protoc` compiled protobufs, and run `pylint` against Python files directly under `gnmi/`. They don't totally agree, so we're not looking for perfection here. `black` is not automatically installed due to requiring Python 3.6+. `hygiene.sh` will check for regular path availability and via `pipenv`, and otherwise falls directly to `pylint`. If `black` usage is desired, please install it into `pipenv` if using Python 3.6+ or separate methods e.g. `brew install black`.

  ```bash

  pipenv install --dev black

  ./hygiene.sh
  ```


  If a new `gnmi.proto` definition is released, use `update_protos.sh` to recompile. If breaking changes are introduced the wrapper library must be updated.

  ```bash
  ./update_protos.sh
  ```


  The below details the current `cisco-gnmi` usage options. Please note that `Set` operations may be destructive to operations and should be tested in lab conditions.

  ```
  cisco-gnmi --help
  usage:
  cisco-gnmi <rpc> [<args>]

  Supported RPCs:
  capabilities
  subscribe
  get
  set

  cisco-gnmi capabilities 127.0.0.1:57500
  cisco-gnmi get 127.0.0.1:57500
  cisco-gnmi set 127.0.0.1:57500 -delete_xpath Cisco-IOS-XR-shellutil-cfg:host-names/host-name
  cisco-gnmi subscribe 127.0.0.1:57500 -debug -auto_ssl_target_override -dump_file intfcounters.proto.txt

  See <rpc> --help for RPC options.


  gNMI CLI demonstrating library usage.

  positional arguments:
    rpc         gNMI RPC to perform against network element.

  optional arguments:
    -h, --help  show this help message and exit
  ```


  This command will output the `CapabilitiesResponse` to `stdout`.
  ```
  cisco-gnmi capabilities 127.0.0.1:57500 -auto_ssl_target_override
  ```


  ```
  cisco-gnmi capabilities --help
  usage: cisco-gnmi [-h] [-os {None,IOS XR,NX-OS,IOS XE}]
                    [-root_certificates ROOT_CERTIFICATES]
                    [-private_key PRIVATE_KEY]
                    [-certificate_chain CERTIFICATE_CHAIN]
                    [-ssl_target_override SSL_TARGET_OVERRIDE]
                    [-auto_ssl_target_override] [-debug]
                    netloc

  Performs Capabilities RPC against network element.

  positional arguments:
    netloc                <host>:<port>

  optional arguments:
    -h, --help            show this help message and exit
    -os {None,IOS XR,NX-OS,IOS XE}
                          OS wrapper to utilize. Defaults to IOS XR.
    -root_certificates ROOT_CERTIFICATES
                          Root certificates for secure connection.
    -private_key PRIVATE_KEY
                          Private key for secure connection.
    -certificate_chain CERTIFICATE_CHAIN
                          Certificate chain for secure connection.
    -ssl_target_override SSL_TARGET_OVERRIDE
                          gRPC SSL target override option.
    -auto_ssl_target_override
                          Use root_certificates first CN as
                          grpc.ssl_target_name_override.
    -debug                Print debug messages.
  ```


  ```
  [cisco-gnmi-python] cisco-gnmi capabilities redacted:57500 -auto_ssl_target_override
  Username: admin
  Password:
  WARNING:root:Overriding SSL option from certificate could increase MITM susceptibility!
  INFO:root:supported_models {
    name: "Cisco-IOS-XR-qos-ma-oper"
    organization: "Cisco Systems, Inc."
    version: "2019-04-05"
  }
  ...
  ```


  This command will output the `GetResponse` to `stdout`. `-xpath` may be specified multiple times to specify multiple `Path`s for the `GetRequest`.
  ```
  cisco-gnmi get 127.0.0.1:57500 -os "IOS XR" -xpath /interfaces/interface/state/counters -auto_ssl_target_override
  ```


  ```
  cisco-gnmi get --help
  usage: cisco-gnmi [-h] [-xpath XPATH]
                    [-encoding {JSON,BYTES,PROTO,ASCII,JSON_IETF}]
                    [-data_type {ALL,CONFIG,STATE,OPERATIONAL}] [-dump_json]
                    [-os {None,IOS XR,NX-OS,IOS XE}]
                    [-root_certificates ROOT_CERTIFICATES]
                    [-private_key PRIVATE_KEY]
                    [-certificate_chain CERTIFICATE_CHAIN]
                    [-ssl_target_override SSL_TARGET_OVERRIDE]
                    [-auto_ssl_target_override] [-debug]
                    netloc

  Performs Get RPC against network element.

  positional arguments:
    netloc                <host>:<port>

  optional arguments:
    -h, --help            show this help message and exit
    -xpath XPATH          XPaths to Get.
    -encoding {JSON,BYTES,PROTO,ASCII,JSON_IETF}
                          gNMI Encoding.
    -data_type {ALL,CONFIG,STATE,OPERATIONAL}
                          gNMI GetRequest DataType
    -dump_json            Dump as JSON instead of textual protos.
    -os {None,IOS XR,NX-OS,IOS XE}
                          OS wrapper to utilize. Defaults to IOS XR.
    -root_certificates ROOT_CERTIFICATES
                          Root certificates for secure connection.
    -private_key PRIVATE_KEY
                          Private key for secure connection.
    -certificate_chain CERTIFICATE_CHAIN
                          Certificate chain for secure connection.
    -ssl_target_override SSL_TARGET_OVERRIDE
                          gRPC SSL target override option.
    -auto_ssl_target_override
                          Use root_certificates first CN as
                          grpc.ssl_target_name_override.
    -debug                Print debug messages.
  ```


  ```
  [cisco-gnmi-python] cisco-gnmi get redacted:57500 -os "IOS XR" -xpath /interfaces/interface/state/counters -auto_ssl_target_override
  Username: admin
  Password:
  WARNING:root:Overriding SSL option from certificate could increase MITM susceptibility!
  INFO:root:notification {
    timestamp: 1585607100869287743
    update {
      path {
        elem {
          name: "interfaces"
        }
        elem {
          name: "interface"
        }
        elem {
          name: "state"
        }
        elem {
          name: "counters"
        }
      }
      val {
        json_ietf_val: "{\"in-unicast-pkts\":\"0\",\"in-octets\":\"0\"...
  ```


  Please note that `Set` operations may be destructive to operations and should be tested in lab conditions. Behavior is not fully validated.


  ```
  cisco-gnmi set --help
  usage: cisco-gnmi [-h] [-update_json_config UPDATE_JSON_CONFIG]
                    [-replace_json_config REPLACE_JSON_CONFIG]
                    [-delete_xpath DELETE_XPATH] [-no_ietf] [-dump_json]
                    [-os {None,IOS XR,NX-OS,IOS XE}]
                    [-root_certificates ROOT_CERTIFICATES]
                    [-private_key PRIVATE_KEY]
                    [-certificate_chain CERTIFICATE_CHAIN]
                    [-ssl_target_override SSL_TARGET_OVERRIDE]
                    [-auto_ssl_target_override] [-debug]
                    netloc

  Performs Set RPC against network element.

  positional arguments:
    netloc                <host>:<port>

  optional arguments:
    -h, --help            show this help message and exit
    -update_json_config UPDATE_JSON_CONFIG
                          JSON-modeled config to apply as an update.
    -replace_json_config REPLACE_JSON_CONFIG
                          JSON-modeled config to apply as a replace.
    -delete_xpath DELETE_XPATH
                          XPaths to delete.
    -no_ietf              JSON is not IETF conformant.
    -dump_json            Dump as JSON instead of textual protos.
    -os {None,IOS XR,NX-OS,IOS XE}
                          OS wrapper to utilize. Defaults to IOS XR.
    -root_certificates ROOT_CERTIFICATES
                          Root certificates for secure connection.
    -private_key PRIVATE_KEY
                          Private key for secure connection.
    -certificate_chain CERTIFICATE_CHAIN
                          Certificate chain for secure connection.
    -ssl_target_override SSL_TARGET_OVERRIDE
                          gRPC SSL target override option.
    -auto_ssl_target_override
                          Use root_certificates first CN as
                          grpc.ssl_target_name_override.
    -debug                Print debug messages.
  ```


  Let's create a harmless loopback interface based from [`openconfig-interfaces.yang`](https://github.com/openconfig/public/blob/master/release/models/interfaces/openconfig-interfaces.yang).

  `config.json`
  ```json
  {
      "openconfig-interfaces:interfaces": {
          "interface": [
              {
                  "name": "Loopback9339"
              }
          ]
      }
  }
  ```

  ```
  [cisco-gnmi-python] cisco-gnmi set redacted:57500 -os "IOS XR" -auto_ssl_target_override -update_json_config config.json
  Username: admin
  Password:
  WARNING:root:Overriding SSL option from certificate could increase MITM susceptibility!
  INFO:root:response {
    path {
      origin: "openconfig-interfaces"
      elem {
        name: "interfaces"
      }
    }
    message {
    }
    op: UPDATE
  }
  message {
  }
  timestamp: 1585715036783451369
  ```

  And on IOS XR...a loopback interface!
  ```
  ...
  interface Loopback9339
  !
  ...
  ```


  This command will output the `SubscribeResponse` to `stdout` or `-dump_file`. `-xpath` may be specified multiple times to specify multiple `Path`s for the `GetRequest`.

  ```
  cisco-gnmi subscribe 127.0.0.1:57500 -os "IOS XR" -xpath /interfaces/interface/state/counters -auto_ssl_target_override
  ```


  ```
  cisco-gnmi subscribe --help
  usage: cisco-gnmi [-h] [-xpath XPATH] [-interval INTERVAL]
                    [-mode {TARGET_DEFINED,ON_CHANGE,SAMPLE}]
                    [-suppress_redundant]
                    [-heartbeat_interval HEARTBEAT_INTERVAL]
                    [-dump_file DUMP_FILE] [-dump_json] [-sync_stop]
                    [-sync_start] [-encoding {JSON,BYTES,PROTO,ASCII,JSON_IETF}]
                    [-os {None,IOS XR,NX-OS,IOS XE}]
                    [-root_certificates ROOT_CERTIFICATES]
                    [-private_key PRIVATE_KEY]
                    [-certificate_chain CERTIFICATE_CHAIN]
                    [-ssl_target_override SSL_TARGET_OVERRIDE]
                    [-auto_ssl_target_override] [-debug]
                    netloc

  Performs Subscribe RPC against network element.

  positional arguments:
    netloc                <host>:<port>

  optional arguments:
    -h, --help            show this help message and exit
    -xpath XPATH          XPath to subscribe to.
    -interval INTERVAL    Sample interval in seconds for Subscription. Defaults
                          to 10.
    -mode {TARGET_DEFINED,ON_CHANGE,SAMPLE}
                          SubscriptionMode for Subscription. Defaults to SAMPLE.
    -suppress_redundant   Suppress redundant information in Subscription.
    -heartbeat_interval HEARTBEAT_INTERVAL
                          Heartbeat interval in seconds.
    -dump_file DUMP_FILE  Filename to dump to. Defaults to stdout.
    -dump_json            Dump as JSON instead of textual protos.
    -sync_stop            Stop on sync_response.
    -sync_start           Start processing messages after sync_response.
    -encoding {JSON,BYTES,PROTO,ASCII,JSON_IETF}
                          gNMI Encoding. Defaults to whatever Client wrapper
                          prefers.
    -os {None,IOS XR,NX-OS,IOS XE}
                          OS wrapper to utilize. Defaults to IOS XR.
    -root_certificates ROOT_CERTIFICATES
                          Root certificates for secure connection.
    -private_key PRIVATE_KEY
                          Private key for secure connection.
    -certificate_chain CERTIFICATE_CHAIN
                          Certificate chain for secure connection.
    -ssl_target_override SSL_TARGET_OVERRIDE
                          gRPC SSL target override option.
    -auto_ssl_target_override
                          Use root_certificates first CN as
                          grpc.ssl_target_name_override.
    -debug                Print debug messages.
  ```


  ```
  [cisco-gnmi-python] cisco-gnmi subscribe redacted:57500 -os "IOS XR" -xpath /interfaces/interface/state/counters -auto_ssl_target_override
  Username: admin
  Password:
  WARNING:root:Overriding SSL option from certificate could increase MITM susceptibility!
  INFO:root:Dumping responses to stdout as textual proto ...
  INFO:root:Subscribing to:
  /interfaces/interface/state/counters
  INFO:root:update {
    timestamp: 1585607768601000000
    prefix {
      origin: "openconfig"
      elem {
        name: "interfaces"
      }
      elem {
        name: "interface"
        key {
          key: "name"
          value: "Null0"
        }
      }
      elem {
        name: "state"
      }
      elem {
        name: "counters"
      }
    }
    update {
      path {
        elem {
          name: "in-octets"
        }
      }
      val {
        uint_val: 0
      }
    }
  ...
  ```


  `cisco-gnmi-python` is licensed as [Apache License, Version 2.0](LICENSE).


  Open an issue :)


  1. [openconfig/gnmi](https://github.com/openconfig/gnmi)
  2. [google/gnxi](https://github.com/google/gnxi)
  3. [Telegraf Cisco gNMI Plugin](https://github.com/influxdata/telegraf/tree/master/plugins/inputs/cisco_telemetry_gnmi)


pkgId: 760a7c0e249c0df40f41026f9fde0398e5d890b76790a9bd839c44c9d2f15c6c
name: python-cisco-sdwan
arch: src
version: 1.24
epoch: 0
release: 1
summary: Cisco-SDWAN Automation Toolset
url: https://github.com/CiscoDevNet/sastre
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cisco-sdwan-1.24-1.src.rpm
checksum_type: sha256
description:
  tag: template_feature
  name_template:
    regex: "^All-"
    name_regex: "{name ^All-(.+)}"
  name_map:
    DC1-VPN10-Interface-Template: DC-VPN10-Interface_v01
    DC1-VPN20-Interface-Template: DC-VPN20-Interface_v01
  % sdwan --verbose transform recipe --from-file recipe.yaml test-transform
  INFO: Transform task: vManage URL: "https://198.18.1.10" -> Local output dir: "test-transform"
  << snip >>
  INFO: Matched feature template All-VPN0-TEMPLATE_cEdge
  INFO: Replacing feature template: All-VPN0-TEMPLATE_cEdge -> VPN0-TEMPLATE_cEdge
  INFO: Inspecting template_device items
  INFO: Task completed successfully
  ```
  Push changes to vManage using the restore task:
  ```
  % sdwan --verbose restore all --workdir test-transform --update
  INFO: Restore task: Local workdir: "test-transform" -> vManage URL: "https://198.18.1.10"
  << snip >>
  INFO: Task completed successfully
  ```

  Transform task also supports updating vManage-encrypted values, allowing configuration items with values containing a CRYPT_CLUSTER prefix to be transferred to a different vManage.
  The first step is to find out the vManage-encrypted values present on vManage or a backup. This is accomplished with the transform build-recipe task.
  Generate a recipe skeleton for the transform task:
  ```
  % sdwan --verbose transform build-recipe --workdir dcloud-clean-mar4 recipe.yml
  INFO: Transform build-recipe task: Local workdir: "dcloud-clean-mar4" -> Recipe file: "recipe.yml"
  INFO: Inspecting policy_customapp items
  INFO: Inspecting policy_list items
  INFO: Inspecting policy_definition items
  INFO: Inspecting parent_policy_definition items
  INFO: Inspecting policy_voice items
  INFO: Inspecting policy_security items
  INFO: Inspecting policy_vedge items
  INFO: Inspecting policy_vsmart items
  INFO: Inspecting template_feature items
  INFO: Found 1 crypt value in feature template VIP23-SIG-Credentials
  INFO: Found 1 crypt value in feature template SNMP-Basic_cEdge_v5
  INFO: Found 1 crypt value in feature template AddOnFeature_v1
  INFO: Inspecting template_device items
  INFO: Found 2 crypt values in device template test-cli-template
  INFO: Inspecting feature_profile items
  INFO: Inspecting config_group items
  INFO: Recipe file saved as "recipe.yml"
  INFO: Task completed successfully
  ```
  The generated recipe file contains all the current vManage-encrypted values found:
  ```
  % cat recipe.yml
  tag: all
  crypt_updates:
  - resource_name: VIP23-SIG-Credentials
    replacements:
    - from_value: $CRYPT_CLUSTER$ToFuObeWUxN4nDPeds7FYA==$7Pzo514ANxdOCusPP+ZDth43Pp9S57xtjR1ofNjcszoKHhZ+zgAVbxUoN5rC7Pcz
      to_value: < CHANGE ME >
  - resource_name: SNMP-Basic_cEdge_v5
    replacements:
    - from_value: $CRYPT_CLUSTER$yGGUchXoTPJxctd+VFSYlw==$rv5ExxoXKv4Jm5lTiVGE/w==
      to_value: < CHANGE ME >
  - resource_name: AddOnFeature_v1
    replacements:
    - from_value: $CRYPT_CLUSTER$BJdUV6XNOPOiwv+51QU73A==$fs+9bcddKYs4uJn0TbpgRA==
      to_value: < CHANGE ME >
  - resource_name: test-cli-template
    replacements:
    - from_value: $CRYPT_CLUSTER$E/HhaXuj1/AzVLJgpbB0CA==$CbBdt/32vEqxpfhB+DShww==
      to_value: < CHANGE ME >
    - from_value: $CRYPT_CLUSTER$sVhKHHjEsFNv4TwqWBgK4g==$cA2R+9ozdQWlgnCwjXWB3A==
      to_value: < CHANGE ME >
  ```
  Entries with a '< CHANGE ME >' placeholder need to be replaced with new values encrypted by the target vManage where you need to restore this backup to. This is done using the encrypt task.
  Using the encrypt recipe task, Sastre will update the recipe file by requesting a new clear text value for each '< CHANGE ME >' entry, requesting the target vManage to encrypt it and update the corresponding to_value field with the new encrypted value.
  Update '< CHANGE ME >' entries in the recipe file:
  ```
  % sdwan --verbose encrypt recipe recipe.yml
  INFO: Encrypt task: vManage URL: "https://198.18.133.200:8443"
  Interactive update of recipe file "recipe.yml", press <ENTER> on empty value or ^C to abort without saving.
  Resource VIP23-SIG-Credentials, from_value: $CRYPT_CLUSTER$ToFuObeWUxN4nDPeds7FYA==$7Pzo514ANxdOCusPP+ZDth43Pp9S57xtjR1ofNjcszoKHhZ+zgAVbxUoN5rC7Pcz
  Value to encrypt:
  Encrypted to_value: $CRYPT_CLUSTER$1JePUtTFGJuRf7PjK7IPIg==$VewhaXqfRvD/OUM7L9GqXg==
  Resource SNMP-Basic_cEdge_v5, from_value: $CRYPT_CLUSTER$yGGUchXoTPJxctd+VFSYlw==$rv5ExxoXKv4Jm5lTiVGE/w==
  Value to encrypt:
  Encrypted to_value: $CRYPT_CLUSTER$IqogLSUdq/7X3ydwTgvYwg==$3m0OXrYsYBJ2yFHBAK9acw==
  Resource AddOnFeature_v1, from_value: $CRYPT_CLUSTER$BJdUV6XNOPOiwv+51QU73A==$fs+9bcddKYs4uJn0TbpgRA==
  Value to encrypt:
  Encrypted to_value: $CRYPT_CLUSTER$epLo7ASRew0KNnHAq04h8A==$bU2mGCvHP3ajiBzTAHzhmw==
  Resource test-cli-template, from_value: $CRYPT_CLUSTER$E/HhaXuj1/AzVLJgpbB0CA==$CbBdt/32vEqxpfhB+DShww==
  Value to encrypt:
  Encrypted to_value: $CRYPT_CLUSTER$DwZgpdH/23nINU7Wyg20QA==$ns4BwWhn9J6P9kOhJ+C6VA==
  Resource test-cli-template, from_value: $CRYPT_CLUSTER$sVhKHHjEsFNv4TwqWBgK4g==$cA2R+9ozdQWlgnCwjXWB3A==
  Value to encrypt:
  Encrypted to_value: $CRYPT_CLUSTER$Li8Rp7YiBfuGMjx2wXw+LQ==$WduQWN+mBUF58U2QH2vdLA==
  INFO: Recipe file "recipe.yml" updated
  INFO: Task completed successfully
  ```
  The recipe file is updated with the newly encrypted values:
  ```
  % cat recipe.yml
  tag: all
  crypt_updates:
  - resource_name: VIP23-SIG-Credentials
    replacements:
    - from_value: $CRYPT_CLUSTER$ToFuObeWUxN4nDPeds7FYA==$7Pzo514ANxdOCusPP+ZDth43Pp9S57xtjR1ofNjcszoKHhZ+zgAVbxUoN5rC7Pcz
      to_value: $CRYPT_CLUSTER$1JePUtTFGJuRf7PjK7IPIg==$VewhaXqfRvD/OUM7L9GqXg==
  - resource_name: SNMP-Basic_cEdge_v5
    replacements:
    - from_value: $CRYPT_CLUSTER$yGGUchXoTPJxctd+VFSYlw==$rv5ExxoXKv4Jm5lTiVGE/w==
      to_value: $CRYPT_CLUSTER$IqogLSUdq/7X3ydwTgvYwg==$3m0OXrYsYBJ2yFHBAK9acw==
  - resource_name: AddOnFeature_v1
    replacements:
    - from_value: $CRYPT_CLUSTER$BJdUV6XNOPOiwv+51QU73A==$fs+9bcddKYs4uJn0TbpgRA==
      to_value: $CRYPT_CLUSTER$epLo7ASRew0KNnHAq04h8A==$bU2mGCvHP3ajiBzTAHzhmw==
  - resource_name: test-cli-template
    replacements:
    - from_value: $CRYPT_CLUSTER$E/HhaXuj1/AzVLJgpbB0CA==$CbBdt/32vEqxpfhB+DShww==
      to_value: $CRYPT_CLUSTER$DwZgpdH/23nINU7Wyg20QA==$ns4BwWhn9J6P9kOhJ+C6VA==
    - from_value: $CRYPT_CLUSTER$sVhKHHjEsFNv4TwqWBgK4g==$cA2R+9ozdQWlgnCwjXWB3A==
      to_value: $CRYPT_CLUSTER$Li8Rp7YiBfuGMjx2wXw+LQ==$WduQWN+mBUF58U2QH2vdLA==
  ```
  Note that the 'recipe.yml' recipe file can also include name_template and/or name_map statements. This allows configuration items to be renamed or copied from, in addition to the crypt_updates.
  Processing of crypt_updates happen after name_map and name_template. This means that resource_name entries under crypt_update match on the new names, post name_map and name_template processing.
  As an example, this is a new version of 'recipe.yml' that also rename templates in the process:
  ```
  tag: all
  name_template:
    regex: '^All-'
    name_regex: '{name ^All-(.+)}'
  name_map:
     SNMP-Basic_cEdge_v5: SNMP-Basic_cEdge_v6
  crypt_updates:
  - resource_name: VIP23-SIG-Credentials
    replacements:
    - from_value: $CRYPT_CLUSTER$ToFuObeWUxN4nDPeds7FYA==$7Pzo514ANxdOCusPP+ZDth43Pp9S57xtjR1ofNjcszoKHhZ+zgAVbxUoN5rC7Pcz
      to_value: $CRYPT_CLUSTER$1JePUtTFGJuRf7PjK7IPIg==$VewhaXqfRvD/OUM7L9GqXg==
  - resource_name: SNMP-Basic_cEdge_v6
    replacements:
    - from_value: $CRYPT_CLUSTER$yGGUchXoTPJxctd+VFSYlw==$rv5ExxoXKv4Jm5lTiVGE/w==
      to_value: $CRYPT_CLUSTER$IqogLSUdq/7X3ydwTgvYwg==$3m0OXrYsYBJ2yFHBAK9acw==
  - resource_name: AddOnFeature_v1
    replacements:
    - from_value: $CRYPT_CLUSTER$BJdUV6XNOPOiwv+51QU73A==$fs+9bcddKYs4uJn0TbpgRA==
      to_value: $CRYPT_CLUSTER$epLo7ASRew0KNnHAq04h8A==$bU2mGCvHP3ajiBzTAHzhmw==
  - resource_name: test-cli-template
    replacements:
    - from_value: $CRYPT_CLUSTER$E/HhaXuj1/AzVLJgpbB0CA==$CbBdt/32vEqxpfhB+DShww==
      to_value: $CRYPT_CLUSTER$DwZgpdH/23nINU7Wyg20QA==$ns4BwWhn9J6P9kOhJ+C6VA==
    - from_value: $CRYPT_CLUSTER$sVhKHHjEsFNv4TwqWBgK4g==$cA2R+9ozdQWlgnCwjXWB3A==
      to_value: $CRYPT_CLUSTER$Li8Rp7YiBfuGMjx2wXw+LQ==$WduQWN+mBUF58U2QH2vdLA==
  ```
  Note that crypt_update resource_name SNMP-Basic_cEdge_v6 is matching the new name post name_map update.
  With the new recipe file prepared, the next step is to execute the transform recipe command.
  Transform backup using the recipe file:
  ```
  % sdwan --verbose transform recipe --from-file recipe.yml --workdir dcloud-clean-mar4 dcloud-clean-mar4-transformed
  INFO: Transform task: Local workdir: "dcloud-clean-mar4" -> Local output dir: "dcloud-clean-mar4-transformed"
  <snip>
  INFO: Inspecting template_feature items
  INFO: Matched feature template VIP23-SIG-Credentials
  INFO: Replacing feature template: VIP23-SIG-Credentials -> VIP23-SIG-Credentials
  INFO: Matched feature template All-VPN0-TEMPLATE_cEdge
  INFO: Replacing feature template: All-VPN0-TEMPLATE_cEdge -> VPN0-TEMPLATE_cEdge
  INFO: Matched feature template All-Banner-dCloud_cEdge
  INFO: Replacing feature template: All-Banner-dCloud_cEdge -> Banner-dCloud_cEdge
  INFO: Matched feature template All-SNMP-Basic_cEdge
  INFO: Replacing feature template: All-SNMP-Basic_cEdge -> SNMP-Basic_cEdge
  INFO: Matched feature template All-OMP-Basic_cEdge
  INFO: Replacing feature template: All-OMP-Basic_cEdge -> OMP-Basic_cEdge
  INFO: Matched feature template All-System-Template_cEdge
  INFO: Replacing feature template: All-System-Template_cEdge -> System-Template_cEdge
  INFO: Matched feature template All-BFDTemplate_cEdge
  INFO: Replacing feature template: All-BFDTemplate_cEdge -> BFDTemplate_cEdge
  INFO: Matched feature template All-SNMP-Basic
  INFO: Replacing feature template: All-SNMP-Basic -> SNMP-Basic
  INFO: Matched feature template SNMP-Basic_cEdge_v5
  INFO: Replacing feature template: SNMP-Basic_cEdge_v5 -> SNMP-Basic_cEdge_v6
  INFO: Matched feature template AddOnFeature_v1
  INFO: Replacing feature template: AddOnFeature_v1 -> AddOnFeature_v1
  INFO: Inspecting template_device items
  INFO: Matched device template test-cli-template
  INFO: Replacing device template: test-cli-template -> test-cli-template
  INFO: Inspecting feature_profile items
  INFO: Inspecting config_group items
  INFO: Task completed successfully
  ```
  The final step is to restore 'dcloud-clean-mar4-transformed' to vManage:
  ```
  % sdwan --verbose restore all --workdir dcloud-clean-mar4-transformed --update
  INFO: Restore task: Local workdir: "dcloud-clean-mar4-transformed" -> vManage URL: "https://198.18.133.200:8443"
  <snip>
  INFO: Pushing items to vManage
  INFO: Done: Update feature template VIP23-SIG-Credentials
  INFO: Done: Create feature template VPN0-TEMPLATE_cEdge
  INFO: Done: Create feature template Banner-dCloud_cEdge
  INFO: Done: Create feature template SNMP-Basic_cEdge
  INFO: Done: Create feature template OMP-Basic_cEdge
  INFO: Done: Create feature template System-Template_cEdge
  INFO: Done: Create feature template BFDTemplate_cEdge
  INFO: Done: Create feature template SNMP-Basic
  INFO: Done: Create feature template SNMP-Basic_cEdge_v6
  INFO: Done: Update feature template AddOnFeature_v1
  INFO: Updating device template test-cli-template requires reattach
  INFO: Template attach: test-cli-template (Site100-cE1)
  INFO: Reattaching templates
  INFO: Waiting...
  INFO: Waiting...
  INFO: Waiting...
  INFO: Completed test-cli-template
  INFO: Completed reattaching templates
  INFO: Done: Update device template test-cli-template
  INFO: Done: Update device template BranchType1Template-cEdge
  INFO: Task completed successfully
  ```


  It is recommended to always use single quotes when specifying a regular expression to --regex option:
  ```
  sdwan --verbose restore all --regex 'VPN1'
  ```
  This is to prevent the shell from interpreting special characters that could be part of the pattern provided.
  Matching done by --regex is un-anchored. That is, unless anchor marks are provided (e.g. ^ or $), the specified pattern matches if present anywhere in the string. In other words, this is a search function.
  The regular expression syntax supported is described in https://docs.python.org/3/library/re.html

  - --regex is used to select items to include (i.e. perform task operation)
  - --not-regex is used to define items not to include. That is, select all items, except the ones matching --not-regex.
  - When --regex match on multiple fields (e.g. item name, item ID), an item is selected if the item name OR item ID match the regular expression provided.
  - With --not-regex, when it matches on multiple fields (e.g. item name, item ID), all items are selected, except the ones where item name OR item ID match the regular expression.

  Multiple Sastre tasks utilize name-regex for name manipulation:
  - Migrate task --name option accepts a name-regex.
  - Transform copy/rename tasks have a `<name-regex>` mandatory parameter.
  - Transform recipe task allow `name_regex` under `name_template` section of the recipe YAML file.
  - The 'list transform' task also take a `<name-regex>` parameter. This task was designed to facilitate testing of those expressions.
  A name-regex is a template for creating a new name based on segments of an original name.
  The following rules apply:
  - Occurrences of {name} are replaced with the original item name.
  - Sections of the original item name can be captured by providing a regular expression in the format: {name &lt;regex&gt;}. This regular expression must contain one or more capturing groups, which define segments of the original name to "copy". Segments matching each capturing group are concatenated and "pasted" to the {name} position.
  - If the regular expression does not match, {name &lt;regex&gt;} is replaced with an empty string.
  Example:
  ```
  Consider the template name "G_Branch_184_Single_cE4451-X_2xWAN_DHCP_L2_v01".
  In order to get the migrated name as "G_Branch_201_Single_cE4451-X_2xWAN_DHCP_L2_v01", one can use --name '{name (G_.+)_184_.+}_201_{name G.+_184_(.+)}'.
  % sdwan list transform template_device --regex 'G_Branch_184_Single_cE4451' --workdir sastre_cx_golden_repo '{name (G_.+)_184_.+}_201_{name G.+_184_(.+)}'
  +===================================================================================================================================================================+
  | Name                                                          | Transformed                                                   | Tag             | Type            |
  +===================================================================================================================================================================+
  | G_Branch_184_Single_cE4451-X_2xWAN_Static_2xSLAN_Trunk_L2_v01 | G_Branch_201_Single_cE4451-X_2xWAN_Static_2xSLAN_Trunk_L2_v01 | template_device | device template |
  | G_Branch_184_Single_cE4451-X_2xWAN_DHCP_L2_v01                | G_Branch_201_Single_cE4451-X_2xWAN_DHCP_L2_v01                | template_device | device template |
  +---------------------------------------------------------------+---------------------------------------------------------------+-----------------+-----------------+
  ```

  Sastre logs messages to the terminal and to log files (under the logs/ directory).
  Debug-level and higher severity messages are always saved to the log files.
  The --verbose flag controls the severity of messages printed to the terminal. If --verbose is not specified, only warning-level and higher messages are logged. When --verbose is specified, informational-level and higher messages are printed.

  By default, restore will skip items with the same name. If an existing item on vManage has the same name as an item in the backup this item is skipped from restore.
  Any references/dependencies on that item are properly updated. For instance, if a feature template is not pushed to vManage because an item with the same name is already present, device templates being pushed will now point to the feature template which is already on vManage.
  **Restore with --update:**
  Adding the --update option to restore modifies this behavior. In this case, Sastre will update existing items containing the same name as in the backup, but only if their content is different.
  When an existing vManage item is modified, device templates may need to be reattached or vSmart policies may need to be re-activated. This is handled as follows:
  - Updating items associated with an active vSmart policy may require this policy to be re-activated. In this case, Sastre will request the policy reactivate automatically.
  - On updates to master templates (e.g. device template) containing attached devices, Sastre will re-attach the device templates.
  - On Updates to child templates (e.g. feature template) associated with master templates containing attached devices, Sastre will re-attach the affected master template(s).
  - In all re-attach cases, Sastre will use the existing attachment values on vManage to feed the attach request.
  The implication is that if modified templates define new variables re-attach will fail, because not all variables would have values assigned. In this case, the recommended procedure is to detach the master template (e.g. using detach task), re-run "restore --update", then re-attach the device-template from vManage, where one would be able to supply any missing variable values.
  **Factory default items:**
  If a factory-default item in the backup is a dependency (referenced by other items) that is missing on the target vManage, it is converted to a non-default item and pushed to vManage.
  A WARNING message is displayed when this condition happens. The user may want to review the corresponding templates/policies and update them to reference newer versions or equivalent factory-defaults that may be available on vManage.

  Sastre requires Python 3.9 or newer. This can be verified by pasting the following to a terminal window:
  ```
  % python3 -c "import sys;assert sys.version_info>(3,9)" && echo "ALL GOOD"
  ```
  If 'ALL GOOD' is printed it means Python requirements are met. If not, download and install the latest 3.x version at Python.org (https://www.python.org/downloads/).
  The recommended way to install Sastre is via pip. For development purposes, Sastre can be installed from the GitHub repository. Both methods are described in this section.

  Create a directory to store the virtual environment and runtime files:
  ```
  % mkdir sastre
  % cd sastre
  ```
  Create virtual environment:
  ```
  % python3 -m venv venv
  ```
  Activate virtual environment:
  ```
  % source venv/bin/activate
  (venv) %
  ```
  - Note that the prompt is updated with the virtual environment name (venv), indicating that the virtual environment is active.
  Upgrade initial virtual environment packages:
  ```
  (venv) % pip install --upgrade pip setuptools
  ```
  Install Sastre:
  ```
  (venv) % pip install --upgrade cisco-sdwan
  ```
  Verify that Sastre can run:
  ```
  (venv) % sdwan --version
  ```
  Notes:
  - The virtual environment is deactivated by typing 'deactivate' at the command prompt.
  - Before running Sastre, make sure to activate the virtual environment back again (source venv/bin/activate).

  With this option you will likely need to run the pip commands as sudo.
  Install Sastre:
  ```
  % python3 -m pip install --upgrade cisco-sdwan
  ```
  Verify that Sastre can run:
  ```
  % sdwan --version
  ```

  Clone from the GitHub repository:
  ```
  % git clone https://github.com/CiscoDevNet/sastre
  ```
  Move to the clone directory:
  ```
  % cd sastre
  ```
  Create virtual environment:
  ```
  % python3 -m venv venv
  ```
  Activate virtual environment:
  ```
  % source venv/bin/activate
  (venv) %
  ```
  - Note that the prompt is updated with the virtual environment name (venv), indicating that the virtual environment is active.
  Upgrade initial virtual environment packages:
  ```
  (venv) % pip install --upgrade pip setuptools
  ```
  Install required Python packages:
  ```
  (venv) % pip install -r requirements.txt
  ```
  Verify that Sastre can run:
  ```
  (venv) % python3 sdwan.py --version
  ```

  First, proceed with the [GitHub install](#GitHub-install) outlined above.
  Ensure you are within the directory cloned from GitHub:
  ```
  % cd sastre
  ```
  Then proceed as follows to build the docker container:
  ```
  % docker build -t sastre .
  Sending build context to Docker daemon    220MB
  Step 1/12 : ARG http_proxy
  Step 2/12 : ARG https_proxy
  Step 3/12 : ARG no_proxy

rpm_license:
  MIT License  Copyright (c) 2019-2024 Cisco Systems, Inc. and/or its affiliates  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: 9ca046c1e53de7917e7188f64d17c2196383972d5e791bde5b6c3be31b092b52
name: python-cisco-telescope
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: Cisco Distribution for OpenTelemetry
url: https://github.com/cisco-open/otel-py
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cisco-telescope-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [![PIP Published Version][pip-image]][pip-url]
  [![Apache License][license-image]][license-image]
  [![Coverage][coverage-image]][coverage-url]

  ![Trace](trace.png)

  This package provides OpenTelemetry-compliant tracing to Python
  applications for the collection of distributed tracing and performance metrics in [Cisco Telescope](https://console.telescope.app/?utm_source=github).



  - [Installation](#installation)
    - [Install Packages](#install-packages)
    - [Install Dependencies](#install-dependencies)
    - [Library initialization](#library-initialization)
    - [OpenTelemetry Collector Configuration](#opentelemetry-collector-configuration)
    - [Existing OpenTelemetry Instrumentation](#existing-opentelemetry-instrumentation)
  - [Supported Runtimes](#supported-runtimes)
  - [Supported Libraries](#supported-libraries)
  - [Configuration](#configuration)
  - [Getting Help](#getting-help)
  - [Opening Issues](#opening-issues)
  - [License](#license)





  `Python >=3.8, <4.0`
  `pip3 >= 22.0`


  > To install Cisco OpenTelemetry Distribution simply run:

  ```sh
  pip install cisco-telescope
  ```



  To install the required dependencies for all relevant supported instrumentation frameworks run:
  ```sh
  telescope-bootstrap
  ```



  Cisco OpenTelemetry Distribution is activated and instruments the supported libraries once the `tracing.init()` has returned.

  To initialize the library, you'll need a cisco-token, which is taken from your [Account tab on the Telescope console Settings page](https://console.telescope.app/settings/account).


  ```python
  from cisco_telescope import tracing

  tracing.init(
    service_name="<your-service-name>",
    cisco_token="<your-cisco-token>"
  )
  ```



  By default, Cisco OpenTelemetry Distribution exports data directly to [Cisco Telescope's](https://console.telescope.app/?utm_source=github) infrastructure backend.
  **Existing** OpenTelemetery Collector is supported, the following configuration can be applied



  Cisco OpenTelemetry Distribution supports the configuration of multiple custom exporters. Note that you will need to handle your exporter authorization.
  Example for creating OtlpGrpc Span exporter to local OpenTelemetry collector:

  ```python
  from cisco_telescope import tracing, options

  tracing.init(
    service_name="<your-service-name>",
    exporters=[
      options.ExporterOptions(
        exporter_type="otlp-grpc",
        collector_endpoint="grpc://localhost:4317"
      ),
    ]
  )

  ```



  ```yaml
  collector.yaml ...

  exporters:
    otlphttp:
      traces_endpoint: https://production.cisco-udp.com/trace-collector
      headers:
        authorization: Bearer <Your Telescope Token>
      compression: gzip


  service:
    pipelines:
      traces:
        exporters: [otlphttp]
  ```



  > Notice: Only relevant if interested in streaming existing OpenTelemetry workloads.
  > [Cisco Telescope](https://console.telescope.app/?utm_source=github). supports native OpenTelemetery traces.
  ```python
  from opentelemetry import trace
  from opentelemetry.sdk.resources import Resource
  from opentelemetry.sdk.trace import TracerProvider
  from opentelemetry.sdk.trace.export import BatchSpanProcessor

  from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
      OTLPSpanExporter as OTLPHTTPExporter,
  )

  provider = TracerProvider(resource=Resource.create())
  trace.set_tracer_provider(provider)

  http_exporter = OTLPHTTPExporter(
    endpoint="https://production.cisco-udp.com/trace-collector",
    headers= {
      "authorization": "Bearer <Your Telescope Token>",
    },
  )

  processor = BatchSpanProcessor(http_exporter)
  provider.add_span_processor(processor)
  ```


  Cisco OpenTelemetry Distribution supports Python 3.6+



  > Cisco OpenTelemetry Python Distribution is extending Native OpenTelemetry, supported libraries [available here](https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation).

  Cisco OpenTelemetry Python Distribution provides out-of-the-box instrumentation (tracing) and advanced **payload collections** for many popular frameworks and libraries.

  | Library  | Extended Support Version    |
  |----------|-----------------------------|
  | requests | Fully supported             |
  | aiohttp  | Fully supported             |
  | grpc     | Client/Server Unary support |




  Advanced options can be configured as a parameter to the init() method:

  | Parameter        | Env                    | Type    | Default       | Description                                                       |
  |------------------|------------------------| ------- |---------------| ----------------------------------------------------------------- |
  | cisco_token      | CISCO_TOKEN            | string  | -             | Cisco account token                                               |
  | service_name     | OTEL_SERVICE_NAME      | string  | `application` | Application name that will be set for traces                      |
  | debug            | CISCO_DEBUG            | string  | `False`       | Debug logs                                                        |
  | payloads_enabled | CISCO_PAYLOADS_ENABLED | string  | `True`        | Debug logs                                                        |

  Exporter options

  | Parameter          | Env                     | Type                | Default                                               | Description                                                                                                                                |
  |--------------------| ----------------------- | ------------------- | ----------------------------------------------------- |--------------------------------------------------------------------------------------------------------------------------------------------|
  | collector_endpoint | OTEL_COLLECTOR_ENDPOINT | string              | `https://production.cisco-udp.com/trace-collector`    | The address of the trace collector to send traces to                                                                                       |
  | type               | OTEL_EXPORTER_TYPE      | string              | `otlp-http`                                           | The exporter type to use (Currently only `otlp-http` is supported). Multiple exporter option available via init function see example below |



  If you have any issue around using the library or the product, please don't hesitate to:

  - Use the [documentation](https://docs.telescope.app).
  - Use the help widget inside the product.
  - Open an issue in GitHub.



  Provided under the Apache 2.0. See LICENSE for details.

  Copyright 2022, Cisco

  [pip-url]: https://pypi.org/project/cisco-telescope/
  [pip-image]: https://img.shields.io/github/v/release/cisco-open/otel-py?include_prereleases&style=for-the-badge
  [license-url]: https://github.com/https://github.com/cisco-open/otel-py/blob/main/LICENSE
  [license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=for-the-badge
  [coverage-url]: https://codecov.io/gh/cisco-open/otel-py/branch/main/
  [coverage-image]: https://img.shields.io/codecov/c/github/cisco-open/otel-py?style=for-the-badge


pkgId: 4ac3fd1a8ae0378193a5f7d74370a314365d9167fd56e375d8919e5236025175
name: python-ciscoconfparse
arch: src
version: 1.9.51
epoch: 0
release: 1
summary: Parse, Audit, Query, Build, and Modify Cisco IOS-style and JunOS-style configs
url: https://pypi.org/project/ciscoconfparse/
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ciscoconfparse-1.9.51-1.src.rpm
checksum_type: sha256
description:
  Interface FastEthernet0/0: 172.16.2.1/24
    Interface FastEthernet0/0 description: [IPv4 and IPv6 desktop / laptop hosts on 2nd-floor North LAN]


pkgId: acdb36fa69ec5eb1c6f0e303d58e839c372a45d047fb471b0944c2a69cdc7a09
name: python-ciscoconfparse2
arch: src
version: 0.7.74
epoch: 0
release: 1
summary: Parse, Audit, Query, Build, and Modify Cisco IOS-style and JunOS-style configs
url: https://pypi.org/project/ciscoconfparse2/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ciscoconfparse2-0.7.74-1.src.rpm
checksum_type: sha256
description:
  [![logo][66]][66]



  [![git commits][41]][42] [![Version][2]][3] [![Downloads][6]][7] [![License][8]][9] [![Hatch project][68]][69]

  [![SonarCloud][51]][52] [![SonarCloud Maintainability Rating][53]][54] [![SonarCloud Lines of Code][55]][56] [![SonarCloud Bugs][59]][60] [![SonarCloud Code Smells][57]][58] [![SonarCloud Tech Debt][61]][62]





  [ciscoconfparse2][17] is similar to an advanced grep and diff that
  handles **multi-vendor network configuration files** (such as those from
  Arista, Cisco, F5, Juniper, Palo Alto, etc); it is the next generation of
  [ciscoconfparse][64], which was the primary development package
  from 2007 until 2023.



  Assume you have a bunch of interfaces in a configuration.  How do you find which ones are shutdown?

  One way is manually reading the whole Cisco IOS-XE configuration.  Another option is [ciscoconfparse2][17]

  ```python
  >>> from ciscoconfparse2 import CiscoConfParse
  >>>
  >>> parse = CiscoConfParse('/path/to/config/file')
  >>> intf_cmds = parse.find_parent_objects(['interface', 'shutdown'])
  >>>
  >>> shut_intf_names = [" ".join(cmd.split()[1:]) for cmd in intf_cmds]
  >>>
  >>> shut_intf_names
  ['GigabitEthernet1/5', 'TenGigabitEthernet2/2', 'TenGigabitEthernet2/3']
  >>>
  ```




  Assume you have this IOS-XR bgp configuration:

  ```none
  router bgp 65534
    bgp router-id 10.0.0.100
    address-family ipv4 unicast
    !
    neighbor 10.0.0.37
      remote-as 64000
      route-policy EBGP_IN in
      route-policy EBGP_OUT out
    !
    neighbor 10.0.0.1
      remote-as 65534
      update-source Loopback0
      route-policy MANGLE_IN in
      route-policy MANGLE_OUT out
        next-hop-self
    !
    neighbor 10.0.0.34
      remote-as 64000
      route-policy EBGP_IN in
      route-policy EBGP_OUT out
  ```

  You can generate the list of EBGP peers pretty quickly with this script:

  ```python
  from ciscoconfparse2 import CiscoConfParse

  parse = CiscoConfParse('/path/to/config/file')   # Or read directly from a list of strings


  branches = parse.find_object_branches(('router bgp',
                                         'neighbor',
                                         'remote-as'))


  bgp_cmd = branches[0][0]
  local_asn = bgp_cmd.split()[-1]


  for branch in branches:
      neighbor_addr = branch[1].split()[-1]
      remote_asn = branch[2].split()[-1]
      if local_asn != remote_asn:
          print("EBGP NEIGHBOR", neighbor_addr)
  ```

  When you run that, you'll see:

  ```none
  $ python example.py
  EBGP NEIGHBOR 10.0.0.37
  EBGP NEIGHBOR 10.0.0.34
  $
  ```

  There is a lot more possible; see the [tutorial](http://www.pennington.net/py/ciscoconfparse2/tutorial.html).



  [ciscoconfparse2][17] distributes a [CLI tool][67] that will diff and grep various
  network configuration or text files.



  The API examples are [documented on the web][70]




  [ciscoconfparse2][17] is a [Python][10] library
  that helps you quickly search for questions like these in your
  router / switch / firewall / load-balancer / wireless text
  configurations:

  - What interfaces are shutdown?
  - Which interfaces are in trunk mode?
  - What address and subnet mask is assigned to each interface?
  - Which interfaces are missing a critical command?
  - Is this configuration missing a standard config line?

  It can help you:

  - Audit existing router / switch / firewall / wlc configurations
  - Modify existing configurations
  - Build new configurations

  Speaking generally, the library examines a text network config and breaks
  it into a set of linked parent / child relationships. You can perform
  complex queries about these relationships.

  [![Cisco IOS config: Parent / child][11]][11]



  In late 2023, I started a rewrite because [ciscoconfparse][64] is too large
  and has some defaults that I wish it didn't have.  I froze
  [ciscoconfparse][64] PYPI releases at [version 1.9.41][65]; there will be no
  more [ciscoconfparse][64] PYPI releases.

  What do you do?  Upgrade to [ciscoconfparse2][17]!

  Here's why, it:

  - Includes a handy [CLI command][67] (including greps for mac addresses and IPv4 / IPv6 subnets)
  - Streamlines the API towards a simpler user interface.
  - Removes legacy and flawed methods from the original (this could be a breaking change for old scripts).
  - Adds string methods to `BaseCfgLine()` objects
  - Defaults `ignore_blank_lines=False` (this could be a breaking change for old scripts).
  - Is better at handling multiple-child-level configurations (such as IOS XR and JunOS)
  - Can search for parents and children using an *arbitrary list of ancestors*
  - Adds the concept of change commits; this is a config-modification safety feature that [ciscoconfparse][64] lacks
  - Adds an `auto_commit` keyword, which defaults True
  - Documents much more of the API
  - Intentionally requires a different import statement to minimize confusion between the original and [ciscoconfparse2][17]
  - Vasly improves Cisco IOS diffs



  - The latest copy of the docs are [archived on the web][15]



  -   Use `pip` for Python3.x\... :

          python -m pip install ciscoconfparse2



  - [Python 3](https://python.org/)
  - [attrs](https://github.com/python-attrs/attrs)
  - [passlib](https://github.com/glic3rinu/passlib)
  - [tomlkit](https://github.com/sdispater/tomlkit)
  - [dnspython](https://github.com/rthalley/dnspython)
  - [`hier_config`](https://github.com/netdevops/hier_config)
  - [`PyYAML`](https://github.com/yaml/pyyaml)
  - [`pyparsing`](https://github.com/pyparsing/pyparsing)
  - [typeguard](https://github.com/agronholm/typeguard)
  - [loguru](https://github.com/Delgan/loguru)




  [The ciscoconfparse2 python package][3] requires Python versions 3.7+.

  Type-hinting (work-in-progress) targets Python3.9+ due to the need for `tuple[str, ...]` hints.



  1. Never hard-code credentials
  2. Use [python-dotenv](https://github.com/theskumar/python-dotenv)



  - [Dive into Python3](http://www.diveintopython3.net/) is a good way to learn Python
  - [Team CYMRU][30] has a [Secure IOS Template][29], which is especially useful for external-facing routers / switches
  - [Cisco\'s Guide to hardening IOS devices][31]
  - [Center for Internet Security Benchmarks][32] (An email address, cookies, and javascript are required)



  I will not. however, if it's truly a problem for your company, there are commercial solutions available (to include purchasing the project, or hiring me).



  - Please report any suggestions, bug reports, or annoyances with a [github bug report][24].
  - If you\'re having problems with general python issues, consider searching for a solution on [Stack Overflow][33].  If you can\'t find a solution for your problem or need more help, you can [ask on Stack Overflow][34] or [reddit/r/Python][39].
  - If you\'re having problems with your Cisco devices, you can contact:
    - [Cisco TAC][28]
    - [reddit/r/Cisco][35]
    - [reddit/r/networking][36]
    - [NetworkEngineering.se][23]



  [ciscoconfparse2][3] is licensed [GPLv3][21]

  - Copyright (C) 2023-2024 David Michael Pennington

  The word \"Cisco\" is a registered trademark of [Cisco Systems][27].



  [ciscoconfparse2][3] was written by [David Michael Pennington][25].



    [1]: https://github.com/mpenning/ciscoconfparse2/blob/main/.github/workflows/tests.yml
    [2]: https://img.shields.io/pypi/v/ciscoconfparse2.svg
    [3]: https://pypi.python.org/pypi/ciscoconfparse2/
    [4]: https://github.com/mpenning/ciscoconfparse2/actions/workflows/tests.yml/badge.svg
    [5]: https://github.com/mpenning/ciscoconfparse2/actions/workflows/tests.yml
    [6]: https://pepy.tech/badge/ciscoconfparse2
    [7]: https://pepy.tech/project/ciscoconfparse2
    [8]: http://img.shields.io/badge/license-GPLv3-blue.svg
    [9]: https://www.gnu.org/copyleft/gpl.html
    [10]: https://www.python.org
    [11]: https://raw.githubusercontent.com/mpenning/ciscoconfparse/master/sphinx-doc/_static/ciscoconfparse_overview_75pct.png
    [12]: https://github.com/mpenning/ciscoconfparse2/blob/main/pyproject.toml
    [13]: https://github.com/mpenning/ciscoconfparse2/blob/master/configs/sample_01.junos
    [14]: https://github.com/mpenning/ciscoconfparse/issues/17
    [15]: http://www.pennington.net/py/ciscoconfparse2/
    [16]: http://pennington.net/tutorial/ciscoconfparse2/ccp_tutorial.html
    [17]: https://github.com/mpenning/ciscoconfparse2
    [18]: https://github.com/mpenning/ciscoconfparse/issues/117
    [19]: https://github.com/mpenning/ciscoconfparse/issues/13
    [20]: https://github.com/CrackerJackMack/
    [21]: http://www.gnu.org/licenses/gpl-3.0.html
    [22]: https://pypy.org
    [23]: https://networkengineering.stackexchange.com/
    [24]: https://github.com/mpenning/ciscoconfparse2/issues/new/choose
    [25]: https://github.com/mpenning
    [26]: https://github.com/muir
    [27]: https://www.cisco.com/
    [28]: https://www.cisco.com/go/support
    [29]: https://www.cymru.com/Documents/secure-ios-template.html
    [30]: https://team-cymru.com/company/
    [31]: http://www.cisco.com/c/en/us/support/docs/ip/access-lists/13608-21.html
    [32]: https://learn.cisecurity.org/benchmarks
    [33]: https://stackoverflow.com
    [34]: http://stackoverflow.com/questions/ask
    [35]: https://www.reddit.com/r/Cisco/
    [36]: https://www.reddit.com/r/networking
    [37]: https://snyk.io/advisor/python/ciscoconfparse2/badge.svg
    [38]: https://snyk.io/advisor/python/ciscoconfparse2
    [39]: https://www.reddit.com/r/Python/
    [41]: https://img.shields.io/github/commit-activity/m/mpenning/ciscoconfparse2
    [42]: https://img.shields.io/github/commit-activity/m/mpenning/ciscoconfparse2
    [43]: https://www.codefactor.io/Content/badges/B.svg
    [44]: https://www.codefactor.io/repository/github/mpenning/ciscoconfparse2/
    [45]: https://fossa.com/blog/open-source-software-licenses-101-gpl-v3/
    [46]: https://app.codacy.com/project/badge/Grade/4774ebb0292d4e1d9dc30bf263d9df14
    [47]: https://app.codacy.com/gh/mpenning/ciscoconfparse2/dashboard
    [48]: https://commitizen-tools.github.io/commitizen/
    [49]: https://semver.org/
    [50]: https://www.conventionalcommits.org/en/v1.0.0/
    [51]: https://sonarcloud.io/api/project_badges/measure?project=mpenning_ciscoconfparse2&metric=alert_status
    [52]: https://sonarcloud.io/summary/new_code?id=mpenning_ciscoconfparse2
    [53]: https://sonarcloud.io/api/project_badges/measure?project=mpenning_ciscoconfparse2&metric=sqale_rating
    [54]: https://sonarcloud.io/summary/new_code?id=mpenning_ciscoconfparse2
    [55]: https://sonarcloud.io/api/project_badges/measure?project=mpenning_ciscoconfparse2&metric=ncloc
    [56]: https://sonarcloud.io/summary/new_code?id=mpenning_ciscoconfparse2
    [57]: https://sonarcloud.io/api/project_badges/measure?project=mpenning_ciscoconfparse2&metric=code_smells
    [58]: https://sonarcloud.io/summary/new_code?id=mpenning_ciscoconfparse2
    [59]: https://sonarcloud.io/api/project_badges/measure?project=mpenning_ciscoconfparse2&metric=bugs
    [60]: https://sonarcloud.io/summary/new_code?id=mpenning_ciscoconfparse2
    [61]: https://sonarcloud.io/api/project_badges/measure?project=mpenning_ciscoconfparse2&metric=sqale_index
    [62]: https://sonarcloud.io/summary/new_code?id=mpenning_ciscoconfparse2
    [63]: https://docs.pytest.org/en/
    [64]: https://github.com/mpenning/ciscoconfparse
    [65]: https://pypi.org/project/ciscoconfparse/1.9.41/
    [66]: https://raw.githubusercontent.com/mpenning/ciscoconfparse2/main/sphinx-doc/_static/ciscoconfparse_logo_bw_01.png
    [67]: http://www.pennington.net/py/ciscoconfparse2/cli.html
    [68]: https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg
    [69]: https://github.com/pypa/hatch
    [70]: http://www.pennington.net/py/ciscoconfparse2/examples.html


