# packages

pkgId: bdcc34b7b61f652f47990e0f0e635cf7b0f34e3f441fc97608fcc139a224d1cf
name: python-conda-docker
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Create minimal docker images from conda environments
url: https://github.com/regro/conda-docker
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-docker-0.0.3-1.src.rpm
checksum_type: sha256
description:
  Conda Docker is an extension to the docker concept by having declarative
  environments that are associated with docker images. In addition this
  tool does not require docker to build images. Thus allowing for
  interesting caching behavior and tricks that docker would not normally
  allow.
  Features:
  -   `docker` is not needed to build images
  -   declarative environments that map 1:1 to docker images
  -   significantly faster build times since builds can take advantage of
      package cache
  -   interesting opportunities for layering (e.g. mkl gets separate
      layer)
  -   no dependencies allowing for library packaged as
      [zipapp](https://docs.python.org/3/library/zipapp.html)


pkgId: d1113ed2c0e558a148cca415a204ef43b57627bc58b152deeb34668b2c16201a
name: python-conda-forge-metadata
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: programatic access to conda-forge's metadata
url: https://pypi.org/project/conda-forge-metadata/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-forge-metadata-0.11.0-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/conda-forge/conda-forge-metadata/actions/workflows/tests.yml/badge.svg)](https://github.com/conda-forge/conda-forge-metadata/actions/workflows/tests.yml) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/conda-forge/conda-forge-metadata/main.svg)](https://results.pre-commit.ci/latest/github/conda-forge/conda-forge-metadata/main)
  [![Publish to PyPI](https://github.com/conda-forge/conda-forge-metadata/actions/workflows/pypi.yml/badge.svg)](https://github.com/conda-forge/conda-forge-metadata/actions/workflows/pypi.yml)

  programatic access to conda-forge's metadata

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, Re(search) Gro(up)  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: 2113cd94eaf97a95f541ba46743ad518f0ca340c4b2acc867f40eea8bae2754e
name: python-conda-inject
arch: src
version: 1.3.2
epoch: 0
release: 1
url: https://pypi.org/project/conda-inject/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-inject-1.3.2-1.src.rpm
checksum_type: sha256
summary:
  Helper functions for injecting a conda environment into the current python environment (by modifying sys.path, without actually changing the current python environment).

description:
  Helper functions for injecting a conda environment into the current python environment.
  This happens by modifying sys.path, without actually changing the current python environment.


pkgId: 14a9154eceb1c20144cad607eca58f43ee06cff057be342c05c980b1da5d8428
name: python-conda-lock
arch: src
version: 2.5.7
epoch: 0
release: 1
summary: Lockfiles for conda
url: https://github.com/conda/conda-lock
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-lock-2.5.7-1.src.rpm
checksum_type: sha256
description:
  [![GitHub deployments](https://img.shields.io/github/deployments/conda/conda-lock/github-pages?label=docs&style=for-the-badge)](https://conda.github.io/conda-lock/)
  [![PyPI](https://img.shields.io/pypi/v/conda-lock?style=for-the-badge)](https://pypi.org/project/conda-lock/)
  [![Conda](https://img.shields.io/conda/v/conda-forge/conda-lock?style=for-the-badge)](https://github.com/conda-forge/conda-lock-feedstock)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?style=for-the-badge)](https://results.pre-commit.ci/latest/github/conda/conda-lock/main)
  [![codecov](https://img.shields.io/codecov/c/github/conda/conda-lock/main?style=for-the-badge)](https://codecov.io/gh/conda/conda-lock)

  Conda lock is a lightweight library that can be used to generate fully reproducible lock files for [conda][conda]
  environments.

  It does this by performing a conda solve for each platform you desire a lockfile for.

  This also has the added benefit of acting as an external pre-solve for conda as the lockfiles it generates
  results in the conda solver *not* being invoked when installing the packages from the generated lockfile.



  Conda [`environment.yml`][envyaml] files are very useful for defining desired environments but there are times when we want to
  be able to EXACTLY reproduce an environment by just installing and downloading the packages needed.

  This is particularly handy in the context of a gitops style setup where you use conda to provision environments in
  various places.



  Use *one* of the following commands:

  ```bash
  pipx install conda-lock
  condax install conda-lock
  pip install conda-lock
  conda install --channel=conda-forge --name=base conda-lock
  mamba install --channel=conda-forge --name=base conda-lock
  ```

  The first two options are recommended since they install conda-lock into an isolated environment. (Otherwise there is a risk of dependency conflicts.)



  If you would like to contribute to conda-lock, please refer to the [Contributing Guide](CONTRIBUTING.md) for instructions on how to set up your development environment.



  ```bash

  conda-lock -f environment.yml -p osx-64 -p linux-64



  conda-lock --update pydantic


  conda-lock install [-p {prefix}|-n {name}]


  conda-lock render -p linux-64
  conda create -n my-locked-env --file conda-linux-64.lock
  ```



  If you were making use of conda-lock before the 1.0 release that added unified lockfiles
  you can still get that behaviour by making use of the `explicit` output kind.

  ```bash
  conda-lock --kind explicit -f environment.yml
  ```





  By default, `conda-lock` store its output in `conda-lock.yml` in the current
  working directory. This file will also be used by default for render, install,
  and update operations. You can supply a different filename with e.g.

  ```bash
  conda-lock --lockfile superspecial.conda-lock.yml
  ```

  Rendered `explicit` and `env` lockfiles will be named as `"conda-{platform}.lock"` and `"conda-{platform}.lock.yml` respectively by default.

  If you want to override that call conda-lock as follows.

  ```bash
  conda-lock -k explicit --filename-template "specific-{platform}.conda.lock"
  ```



  Conda-lock will build a spec list from several files if requested.

  ```bash
  conda-lock -f base.yml -f specific.yml -p linux-64 -k explicit --filename-template "specific-{platform}.lock"
  ````

  In this case all dependencies are combined, and the ordered union of all `channels` is used as the final
  specification.

  This works for all supported file types.



  You can override the channels that are used by conda-lock in case you need to override the ones specified in
  an [environment.yml][envyaml]

  ```bash
  conda-lock -c conda-forge -p linux-64
  ```



  You may specify the platforms you wish to target by default directly in an [environment.yml][envyaml] using the (nonstandard) `platforms` key:

  ```yaml

  channels:
    - conda-forge
  dependencies:
    - python=3.9
    - pandas
  platforms:
    - linux-64
    - osx-64
    - win-64
    - osx-arm64  # For Apple Silicon, e.g. M1/M2
    - linux-aarch64  # aka arm64, use for Docker on Apple Silicon
    - linux-ppc64le
  ```

  If you specify target platforms on the command line with `-p`, these will
  override the values in the environment specification. If neither `platforms` nor
  `-p` are provided, `conda-lock` will fall back to a default set of platforms.



  You can may wish to split your dependencies into separate files for better
  organization, e.g. a `environment.yml` for production dependencies and a
  `dev-environment.yml` for development dependencies. You can assign all the
  dependencies parsed from a single file to a category using the (nonstandard)
  `category` key.

  ```yaml

  channels:
    - conda-forge
  dependencies:
    - pytest
    - mypy=0.910
  category: dev
  ```

  The default category is `main`.



  `conda-lock` can also lock the `dependencies.pip` section of
  [environment.yml][envyaml], using a vendored copy of [Poetry's][poetry] dependency solver.



  Right now `conda-lock` only supports [legacy](https://warehouse.pypa.io/api-reference/legacy.html) pypi repos with basic auth. Most self-hosted repositories like Nexus, Artifactory etc. use this. You can configure private pip repositories in a similar way to channels, for example:

  ```yaml
  channels:
    - conda-forge
  pip-repositories:
    - http://$PIP_USER:$PIP_PASSWORD@private-pypi.org/api/pypi/simple
  dependencies:
    - python=3.11
    - requests=2.26
    - pip:
      - fake-private-package==1.0.0
  ```

  See [the related docs for private channels](./docs/authenticated_channels.md#what_gets_stored) to understand the rules regarding environment variable substitution.

  Alternatively, you can use the `poetry` configuration file format to configure private PyPi repositories. The configuration file should be named `config.toml` and have the following format:

  ```toml
  [repositories.example]
  url = "https://username:password@example.repo/simple"
  ```

  The location of this file can be determined with `python -c 'from conda_lock._vendor.poetry.locations import CONFIG_DIR; print(CONFIG_DIR)'`

  Private repositories will be used in addition to `pypi.org`. For projects using `pyproject.toml`, it is possible to [disable `pypi.org` entirely](#disabling-pypiorg).



  By default conda-lock will include dev dependencies in the specification of the lock (if the files that the lock
  is being built from support them).  This can be disabled easily

  ```bash
  conda-lock --no-dev-dependencies -f ./recipe/meta.yaml
  ```



  Under some situation you may want to run conda lock in some kind of automated way (eg as a precommit) and want to not
  need to regenerate the lockfiles if the underlying input specification for that particular lock as not changed.

  ```bash
  conda-lock --check-input-hash -p linux-64
  ```

  When the input_hash of the input files, channels match those present in a given lockfile, that lockfile will not be regenerated.



  By default `conda-lock` will leave basic auth credentials for private conda channels in the lock file. If you wish to strip authentication from the file, provide the `--strip-auth` argument.

  ```shell
  conda-lock --strip-auth -f environment.yml
  ```

  In order to `conda-lock install` a lock file with its basic auth credentials stripped, you will need to create an authentication file in `.json` format like this:

  ```json
  {
    "domain": "username:password"
  }
  ```

  If you have multiple channels that require different authentication within the same domain, you can additionally specify the channel like this:

  ```json
  {
    "domain.org/channel1": "username1:password1",
    "domain.org/channel2": "username2:password2"
  }
  ```

  You can provide the authentication either as string through `--auth` or as a filepath through `--auth-file`.

  ```bash
  conda-lock install --auth-file auth.json conda-linux-64.lock
  ```



  Conda makes use of [virtual packages](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-virtual.html) that are available at
  runtime to gate dependency on system features.  Due to these not generally existing on your local execution platform conda-lock will inject
  them into the solution environment with a reasonable guess at what a default system configuration should be.

  If you want to override which virtual packages are injected you can create a file like

  ```yaml

  subdirs:
    linux-64:
      packages:
        __glibc: "2.17"
        __cuda: "11.4"
    win-64:
      packages:
        __cuda: "11.4"
  ```

  conda-lock will automatically use a `virtual-packages.yml` it finds in the the current working directory.  Alternatively one can be specified
  explicitly via the flag.

  ```bash
  conda lock --virtual-package-spec virtual-packages-cuda.yml -p linux-64
  ```



  Virtual packages take part in the input hash so if you build an environment with a different set of virtual packages the input hash will change.
  Additionally the default set of virtual packages may be augmented in future versions of conda-lock.  If you desire very stable input hashes
  we recommend creating a `virtual-packages.yml` file to lock down the virtual packages considered.



  Micromamba does not presently support some of the overrides to remove all discovered virtual packages, consequently the set of virtual packages
  available at solve time may be larger than those specified in your specification.



  Conda lock supports more than just [environment.yml][envyaml] specifications!

  Additionally conda-lock supports [meta.yaml][metayaml] (conda-build)
  and `pyproject.toml` (
  [flit](https://flit.readthedocs.io/en/latest/), [pdm](https://pdm.fming.dev) and
  [poetry](https://python-poetry.org) based).  These do come with some gotchas but
  are generally good enough for the 90% use-case.



  Conda-lock will attempt to make an educated guess at the desired environment spec in a meta.yaml.  This is
  not guaranteed to work for complex recipes with many selectors and outputs.  For multi-output recipes, conda-lock
  will fuse all the dependencies together.  If that doesn't work for your case fall back to specifying the specification
  as an [environment.yml][envyaml]

  Since a meta.yaml doesn't contain channel information we make use of the following extra key to specify channels

  ```yaml


  extra:
    channels:
      - conda-forge
      - defaults
  ```



  Since `pyproject.toml` files are commonly used by python packages it can be desirable to create a lock
  file directly from those dependencies to single-source a package's dependencies.  This makes use of some
  conda-forge infrastructure ([pypi-mapping][mapping]) to do a lookup of the PyPI package name to a corresponding
  conda package name (e.g. `docker` -> `docker-py`).  In cases where there exists no lookup for the package it assumes that
  the PyPI name, and the conda name are the same.



  ```toml


  [tool.conda-lock]
  channels = [
      'conda-forge', 'defaults'
  ]
  ```



  Like in [environment.yml][envyaml], you can specify default platforms to target:

  ```toml


  [tool.conda-lock]
  platforms = [
      'osx-arm64', 'linux-64'
  ]
  ```



  If your pyproject.toml file contains optional dependencies/extras these can be referred to by using the `--extras` flag

  ```toml


  [tool.poetry.dependencies]
  mandatory = "^1.0"
  psycopg2 = { version = "^2.7", optional = true }
  mysqlclient = { version = "^1.3", optional = true }

  [tool.poetry.extras]
  mysql = ["mysqlclient"]
  pgsql = ["psycopg2"]

  ```

  These can be referened as follows

  ```shell
  conda-lock --extra mysql --extra pgsql -f pyproject.toml
  ```

  When generating lockfiles that make use of extras it is recommended to make use of `--filename-template` covered [here](#file-naming).



   By default conda-lock will attempt to solve for *ALL* extras/categories it discovers in sources.  This allows you to render explicit locks with subset of extras, without needing a new solve.

  However this does make the assumption that your extras can all be installed in conjunction with each other.  If you want extras filtering
  to happen at the solve stage use the flag `--filter-extras`

  ```sh
  conda-lock --extra incompatiblea --filter-extras -f pyproject.toml
  ```



  Since in a `pyproject.toml` all the definitions are python dependencies if you need
  to specify some non-python dependencies as well this can be accomplished by adding
  the following sections to the `pyproject.toml`

  ```toml


  [tool.conda-lock.dependencies]
  sqlite = ">=3.34"
  ```



  If a dependency refers directly to a URL rather than a package name and version,
  `conda-lock` will assume it is pip-installable, e.g.:

  ```toml

  [tool.poetry.dependencies]
  python = "3.9"
  pymage = {url = "https://github.com/MickaelRigault/pymage/archive/v1.0.tar.gz#sha256=11e99c4ea06b76ca7fb5b42d1d35d64139a4fa6f7f163a2f0f9cc3ea0b3c55eb"}
  ```

  Similarly, if a dependency is explicitly marked with `source = "pypi"`, it will
  be treated as a `pip` dependency, e.g.:

  ```toml
  [tool.poetry.dependencies]
  python = "3.9"
  ampel-ztf = {version = "^0.8.0-alpha.2", source = "pypi"}
  ```

  A dependency will also be treated as a `pip` dependency if explicitly marked with `source = "pypi"` in the `[tool.conda-lock.dependencies]` section, e.g.:

  ```toml
  [tool.conda-lock.dependencies]
  ampel-ztf = {source = "pypi"}
  ```



  Alternatively, the above behavior is defaulted for all dependencies defined outside of `[tool.conda-lock.dependencies]`, i.e.:

  - Default to `pip` dependencies for `[tool.poetry.dependencies]`, `[project.dependencies]`, etc.
  - Default to `conda` dependencies for `[tool.conda-lock.dependencies]`

  by explicitly providing  `default-non-conda-source = "pip"` in the `[tool.conda-lock]` section, e.g.:

  ```toml
  [tool.conda-lock]
  default-non-conda-source = "pip"
  ```

  In all cases, the dependencies of `pip`-installable packages will also be
  installed with `pip`, unless they were already requested by a `conda`
  dependency.



  To lock only dependencies specified under `[tool.conda-lock]` (i.e. skipping all dependencies specified elsewhere), explicitly provide `skip-non-conda-lock = true` in the `[tool.conda-lock]` section, e.g.:

  ```toml
  [tool.conda-lock]
  skip-non-conda-lock = true
  ```



  When using private pip repos, it is possible to disable `pypi.org` entirely. This can be useful when using `conda-lock` behind a network proxy that does not allow access to `pypi.org`.

  ```toml
  [tool.conda-lock]
  allow-pypi-requests = false
  ```



  In order to use conda-lock in a docker-style context you want to add the lockfile to the
  docker container.  In order to refresh the lock file just run `conda-lock` again.

  Given a file tree like

  ```text
    Dockerfile
    environment.yaml
  * conda-linux-64.lock
  ```

  You want a dockerfile that is structured something similar to this

  ```Dockerfile



  FROM continuumio/miniconda:latest as conda

  ADD conda-linux-64.lock /locks/conda-linux-64.lock
  RUN conda create -p /opt/env --copy --file /locks/conda-linux-64.lock



  FROM gcr.io/distroless/base-debian10

  COPY --from=conda /opt/env /opt/env
  ```

  [conda]: https://docs.conda.io/projects/conda
  [metayaml]: https://docs.conda.io/projects/conda-build/en/latest/resources/define-metadata.html
  [mapping]: https://github.com/regro/cf-graph-countyfair/blob/master/mappings/pypi/grayskull_pypi_mapping.yaml
  [envyaml]: https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html#create-env-file-manually
  [poetry]: https://python-poetry.org


pkgId: 6b076a9b55c624d05dc5ffd7b73e1c3275f99119302400ad271a69a6fa062f01
name: python-conda-merge
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Tool for merging conda environment files
url: https://github.com/amitbeka/conda-merge
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-merge-0.2.0-1.src.rpm
checksum_type: sha256
description:
  Tool for merging Conda (Anaconda) environment files into one file.
  This is used to merge your application environment file with any other
  environment file you might need (e.g. unit-tests, debugging, jupyter notebooks)
  and create a consistent environment without breaking dependencies from the
  previous environment files.
  **Installation**:
      pip install conda-merge
  **Usage**:
      conda-merge FILE1 FILE2 ... FILE-N > OUTPUT-FILE
  A common problem with multiple environment files is that of pinned dependencies:
  let's say ``environment.yml`` contains the dependency ``numpy=1.7``, and your
  ``dev-environment.yml`` contains ``pandas`` as a dependency. If you sequentially
  apply the environment files (``conda env update -f environment.yml`` and then
  ``conda env update -f dev-environment.yml``) ``numpy`` will no longer be pinned
  and will be upgraded to the latest version.
  One option to solve it is by using the pinned dependencies file in the environment
  directory, but this means storing your dependencies in another file which interacts
  with ``environment.yml``, and makes the dependencies less clear to other users.
  This script enables you to merge the two environment files and then run only
  one ``conda env`` command to apply the change.


pkgId: 83f7725b369eca33e0e324de06c76b2851e218cfe0a9c9923654bdaacf84a504
name: python-conda-mirror
arch: src
version: 0.10.0
epoch: 0
release: 1
summary: Mirror an upstream conda channel to a local directory
url: https://github.com/regro/conda-mirror
rpm_license: BSD 3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-mirror-0.10.0-1.src.rpm
checksum_type: sha256
description:
  platform linux -- Python 3.5.3, pytest-3.0.6, py-1.4.31, pluggy-0.4.0 -- /home/edill/miniconda/bin/python
  cachedir: .cache
  rootdir: /home/edill/dev/maxpoint/github/conda-mirror, inifile:
  plugins: xonsh-0.5.2, ordering-0.4
  collected 4 items
  test/test_conda_mirror.py::test_match PASSED
  test/test_conda_mirror.py::test_cli[https://repo.continuum.io/pkgs/free-linux-64] PASSED
  test/test_conda_mirror.py::test_cli[conda-forge-linux-64] PASSED


pkgId: 7700c9fa00d080788ba89efcefc4313978bead40748ab3dfd93b0ca8d254d800
name: python-conda-pack
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Package conda environments for redistribution
url: https://conda.github.io/conda-pack/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-pack-0.8.0-1.src.rpm
checksum_type: sha256
description:
  `conda-pack` is a command line tool for creating relocatable conda
  environments. This is useful for deploying code in a consistent environment,
  potentially in locations where python or conda isn't already installed.

  See the <a href="https://conda.github.io/conda-pack/">documentation</a>
  for more information.

  Conda-pack is offered under a New BSD license; see the
  <a href="https://github.com/conda/conda-pack/blob/main/LICENSE.txt">license file</a>.



  | [![Build status](https://github.com/conda/conda-pack/actions/workflows/main.yml/badge.svg)](https://github.com/conda/conda-pack/actions/workflows/main.yml) [![codecov](https://codecov.io/gh/conda/conda-pack/branch/main/graph/badge.svg)](https://codecov.io/gh/conda/conda-pack) [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/conda/conda-pack/main.svg)](https://results.pre-commit.ci/latest/github/conda/conda-pack/main) | [![Anaconda-Server Badge](https://anaconda.org/ctools/conda-pack/badges/latest_release_date.svg)](https://anaconda.org/ctools/conda-pack) |
  | --- | :-: |
  | [`conda install ctools/label/dev::conda-pack`](https://anaconda.org/ctools/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/ctools/conda-pack/badges/version.svg)](https://anaconda.org/ctools/conda-pack) |
  | [`conda install defaults::conda-pack`](https://anaconda.org/anaconda/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/anaconda/conda-pack/badges/version.svg)](https://anaconda.org/anaconda/conda-pack) |
  | [`conda install conda-forge::conda-pack`](https://anaconda.org/conda-forge/conda-pack) | [![Anaconda-Server Badge](https://anaconda.org/conda-forge/conda-pack/badges/version.svg)](https://anaconda.org/conda-forge/conda-pack) |


pkgId: f171db6019c4e36a5f9d8a04c4c0b3fe212e230561757c1e4d0a9e7e608b3c7a
name: python-conda-package-handling
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: Create and extract conda packages of various formats.
url: https://github.com/conda/conda-package-handling
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-package-handling-2.4.0-1.src.rpm
checksum_type: sha256
description:
  [![pre-commit.ci status](https://results.pre-commit.ci/badge/github/conda/conda-package-handling/main.svg)](https://results.pre-commit.ci/latest/github/conda/conda-package-handling/main)

  Create and extract conda packages of various formats.

  `conda` and `conda-build` use `conda_package_handling.api` to create and extract
  conda packages. This package also provides the `cph` command line tool to
  extract, create, and convert between formats.

  See also
  [conda-package-streaming](https://conda.github.io/conda-package-streaming), an
  efficient library to read from new and old format .conda and .tar.bz2 conda
  packages.

  Full documentation at [https://conda.github.io/conda-package-handling/](https://conda.github.io/conda-package-handling/)


pkgId: 18072195a33ca46ec8213ca250ca5b8c9d6b7859ec54224cd1fcb4504627e2b7
name: python-conda-project
arch: src
version: 0.4.2
epoch: 0
release: 1
summary: Tool for encapsulating, running, and reproducing projects with conda environments
url: https://pypi.org/project/conda-project/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-project-0.4.2-1.src.rpm
checksum_type: sha256
description:
  ![GitHub Release Date](https://img.shields.io/github/release-date/conda-incubator/conda-project?style=for-the-badge&logo=github)
  ![GitHub Release](https://img.shields.io/github/v/release/conda-incubator/conda-project?style=for-the-badge&logo=github)


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

  [![Conda-Forge](https://img.shields.io/conda/v/conda-forge/conda-project?style=for-the-badge&logo=conda-forge&color=blue)](https://github.com/conda-forge/conda-project-feedstock)
  ![Conda Downloads](https://img.shields.io/conda/d/conda-forge/conda-project?style=for-the-badge&logo=conda-forge&label=downloads)


  [![Docs](https://img.shields.io/github/deployments/conda-incubator/conda-project/github-pages?style=for-the-badge&label=docs&logo=github)](https://conda-incubator.github.io/conda-project)


  ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/conda-incubator/conda-project/main.yaml?style=for-the-badge&label=tests&logo=github)
  ![Codecov](https://img.shields.io/codecov/c/github/conda-incubator/conda-project?style=for-the-badge&logo=codecov)
  [![pre-commit.ci status](https://img.shields.io/badge/pre--commit-enabled-brightgreen?style=for-the-badge&logo=pre-commit)](https://results.pre-commit.ci/latest/github/conda-incubator/conda-project/main)


  <!-- ![defaults](https://img.shields.io/conda/v/anaconda/conda-project?style=for-the-badge&logo=anaconda) -->

  Tool for encapsulating, running, and reproducing projects with conda environments.




  Sharing your work is more than sharing your code in a script file or notebook. To make your work properly reproducible, it is necessary to include the list of required third-party dependencies, specifications for how to run your code, and
  any other files that it may need.

  See [8 Levels of Reproduciblity](https://www.anaconda.com/blog/8-levels-of-reproducibility) for an in-depth
  discussion of the differences between "It works for me." to "I've made sure that anyone can reliably execute my work."
  Conda Project is a framework that aims to help you to ensure a high degree of reproducibility in the projects you
  create.



  This package is intended as a successor to [Anaconda Project](https://github.com/Anaconda-Platform/anaconda-project).
  We chose to create Conda Project to foster community involvement, adopt newer standards like conda-lock, and provide
  a conda-native workflow. A standalone conversion script is provided in this repo at `scripts/ap-to-cp.py`. You can run
  it as follows. By default it will write Conda Project files into your current working directory. You can read anaconda-project.yml file from any other directory or output Conda Project files to any other directory.

  You'll need `pydantic` and `ruamel.yaml` installed.

  ```text
  python ap-to-cp.py /path/to/anaconda-project.yml [/output/directory]
  ```



  You can install conda-project using the conda package manager:

  ```text
  conda install -c conda-forge conda-project
  ```



  Let's start a new project using Python, Pandas, and Jupyter Notebooks.
  The commands below will work on terminals in Mac, Linux, and Windows.
  For Windows you can use either `cmd.exe` or Powershell.

  We first create a directory and initialize a new project, which will create a new conda environment and lock the dependencies:

  ```text
  (base) > conda project init --directory my-project python=3.9 notebook pandas
  Locking dependencies for environment default on platforms osx-64, osx-arm64, linux-64, win-64: done
  Project created at /Users/adefusco/Development/conda-incubator/conda-project/examples/my-project
  ```

  The goal of Conda Project is to maintain a conda enviroment specifically for the new `my-project` directory.
  You'll see that this directory contains it's own `environment.yml` file a [Conda Lock](https://conda.github.io/conda-lock/) file and a `conda-project.yml`
  file. You can learn more about these files in the [User Guide](https://conda-incubator.github.io/conda-project/user_guide.html)

  ```text
  (base) > tree ./
  ├── conda-project.yml
  ├── default.conda-lock.yml
  ├── environment.yml
  ```

  You can activate the environment, which will install packages locally to this project according to the lock file.
  Notice that after running `conda project activate` the shell prompt switches to `(default)`, which is the name
  of the local environment for this project.

  ```text
  (base) > cd my-project
  (base) > conda project activate

  Downloading and Extracting Packages


  Downloading and Extracting Packages

  Preparing transaction: done
  Verifying transaction: done
  Executing transaction: done
  environment created at /Users/adefusco/Development/conda-incubator/conda-project/examples/my-project/envs/default


  ```

  And in the activated environment you can launch editors or run commands. For example, since we included
  the `notebook` package we can launch Jupyter Notebook from the activated environment:

  ```text
  (default) > jupyter notebook
  [I 12:23:03.632 NotebookApp] Serving notebooks from local directory: /Users/adefusco/Development/conda-incubator/conda-project/examples/my-project
  [I 12:23:03.632 NotebookApp] Jupyter Notebook 6.5.2 is running at:
  [I 12:23:03.632 NotebookApp] http://localhost:8888/?token=1208a3441039526c03b44c233f07436321ad4fd3cced443d
  [I 12:23:03.632 NotebookApp]  or http://127.0.0.1:8888/?token=1208a3441039526c03b44c233f07436321ad4fd3cced443d
  [I 12:23:03.632 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
  [C 12:23:03.635 NotebookApp]
  ```

  Continue reading the [User Guide](https://conda-incubator.github.io/conda-project/user_guide.html) to learn more.


pkgId: 5bffaec9218bea8f7f28a90fe4bf5988cc60e810cb6e98e90bc78744c510edf8
name: python-conda-sphinx-theme
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Conda theme for Sphinx
url: https://pypi.org/project/conda-sphinx-theme/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-sphinx-theme-0.2.2-1.src.rpm
checksum_type: sha256
description:
  This is the Conda Sphinx Theme. It extends the [PyData Sphinx Theme][pydata-sphinx-theme]
  project  by adding custom styling.



  You can install the `conda-sphinx-theme` via conda-forge:

  ```
  conda install -c conda-forge conda-sphinx-theme
  ```

  or PyPI:

  ```
  pip install conda-sphinx-theme
  ```



  When creating a conda subproject you can include this theme by changing this
  line in your conf.py file

  ```python
  html_theme = 'conda_sphinx_theme'
  ```

  [pydata-sphinx-theme]: https://pydata-sphinx-theme.readthedocs.io/en/stable/

rpm_license:
  BSD 3-Clause License  Copyright (c) 2023, conda-incubator  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: 3be14b3c99859c4aacd4ae938721daa4abe907ce178c89fb748de501c923beb2
name: python-conda-store
arch: src
version: 2024.11.1
epoch: 0
release: 1
summary: conda-store client
url: https://conda.store/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conda-store-2024.11.1-1.src.rpm
checksum_type: sha256
description:
  Check the full documentation at [conda.store](https://conda.store/).

  A client library which provides a CLI for interacting with conda-store-server.

  ```shell
  $ conda-store --help
  ```


pkgId: edb6e7cf8cc04adc7aaee520eadd7aaf2948bbbc634d68662bacd1c5cb3603c8
name: python-condacolab
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Install Conda and friends on Google Colab, easily
url: https://github.com/jaimergp/condacolab
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-condacolab-0.1.9-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/condacolab/week)](https://pypi.org/project/condacolab)
  [![Downloads](https://pepy.tech/badge/condacolab/month)](https://pypi.org/project/condacolab)
  [![Downloads](https://pepy.tech/badge/condacolab)](https://pypi.org/project/condacolab)

  Install Conda and friends on Google Colab, easily.

  ![CondaColab](https://github.com/jaimergp/condacolab/raw/main/condacolab.png)



  > **TLDR**: Check the [example notebook here](https://colab.research.google.com/drive/1c_RGCgQeLHVXlF44LyOFjfUW32CmG6BP)!

  On your Colab notebook, run the following code as the _first executable cell_:

  ```python
  !pip install -q condacolab
  import condacolab
  condacolab.install()
  ```

  After the kernel restart, you can optionally add a new cell to check that everything is in place:

  ```python
  import condacolab
  condacolab.check()
  ```

  > It is important that you perform the installation first thing in the notebook because it will require a kernel restart, thus resetting the variables set up to that point.

  The default `condacolab.install()` provides Mambaforge, but there are other `conda` distributions to choose from:

  - `install_miniconda()`: This will install the Miniconda distribution, using a version built for Python 3.10. Unlike Anaconda, this distribution only contains `python` and `conda`.
  - `install_miniforge()`: Like Miniconda, but built off `conda-forge` packages. The Miniforge distribution is officially provided by [conda-forge](https://github.com/conda-forge/miniforge).
  - `install_mambaforge()`: Like Miniforge, but with `mamba` included. The Mambaforge distribution is officially provided by [conda-forge](https://github.com/conda-forge/miniforge).

  For advanced users, `install_from_url()` is also available. It expects a URL pointing to a [`constructor`-like installer](https://github.com/conda/constructor), so you can prebuild a Python 3.10 distribution that fulfills your own needs.

  > If you want to build your own `constructor`-based installer, check the FAQ below!

  Once the installation is done, you can use `conda` and/or `mamba` to install the needed packages:

  ```bash
  !conda install openmm


  !mamba install openmm
  ```

  If you have a environment file (e.g. `environment.yml`), you can use it like this:

  ```bash
  !conda env update -n base -f environment.yml


  !mamba env update -n base -f environment.yml
  ```




  - The Python kernel needs to be restarted for changes to be applied. This happens automatically. If you are wondering why you are seeing a message saying _"Your session crashed for an unknown reason"_, this is why. You can safely ignore this message!
  - You can only use the `base` environment, so do not try to create more environments with `conda create`. If you have an environment file, use `conda env update -n base -f <your-file.yml>`.





  Google Colab runs on Python 3.10. We install the Miniconda distribution on top of the existing one at `/usr/local`, add a few configuration files so we stay with Python 3.10 and the newly installed packages are available. Finally, we wrap the Python executable to redirect and inject some environment variables needed to load the new libraries. Since we need to re-read `LD_LIBRARY_PATH`, a kernel restart is needed.



  The recommended approach is to build your own `constructor`-based installer. We have provided an example in `constructor-example/construct.yaml`.

  > You can generate a `constructor` installer on Colab too! Follow [this tutorial](https://colab.research.google.com/github/jaimergp/condacolab/blob/main/constructor-example/condacolab_constructor_tutorial.ipynb).

  Locally, follow these steps:

  1. In your local computer:

  ```bash
  conda create -n constructor -c conda-forge constructor
  conda activate constructor
  mkdir my-installer
  cd my-installer
  curl -sLO https://raw.githubusercontent.com/jaimergp/condacolab/main/constructor-example/construct.yaml
  curl -sLO https://raw.githubusercontent.com/jaimergp/condacolab/main/constructor-example/pip-dependencies.sh
  ```

  2. Add your `conda` packages to `construct.yaml` in the `specs` section. Read the comments to respect the constrains already present! You can also adapt the metadata to your liking.
  3. If you _do_ need to install `pip` requirements, uncomment the `post_install` line and edit `pip-dependencies.sh`.
  4. Run `constructor --platform linux-64 .`
  5. Upload the resulting `.sh` to an online location with a permanent URL. GitHub Releases is great for this!
  6. In Colab, run:

  ```python
  !pip install -q condacolab
  import condacolab
  condacolab.install_from_url(URL_TO_YOUR_CUSTOM_CONSTRUCTOR_INSTALLER)
  ```



  Yes, as long as you make sure you also install `rpy2` to overwrite Colab's installation.
  See [issue #26](https://github.com/conda-incubator/condacolab/issues/26) for more details.


pkgId: 3ea37dcb717a140ef1519a54c3ce2f09c2c1d0901e748ac25771a16e867c4be2
name: python-condensetech.cdk-constructs
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Condense's opinionated constructs and stacks for AWS CDK
url: https://github.com/cdklabs/cdk-monitoring-constructs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-condensetech.cdk-constructs-0.5.2-1.src.rpm
checksum_type: sha256
description:
  This library contains constructs and stacks we use across our projects.



  <details>
    <summary>Node.js</summary>
    Install the package:

  ```bash
  npm install @condensetech/cdk-constructs # or
  yarn add @condensetech/cdk-constructs # or
  pnpm add @condensetech/cdk-constructs
  ```

  Import it:

  ```python
  import * as condense from '@condensetech/cdk-constructs';
  ```

  </details>
  <details>
    <summary>Python</summary>
    Install the package:

  ```bash
  pip install condensetech.cdk-constructs
  ```

  Import it:

  ```py
  from condensetech import cdk_constructs
  ```

  </details>
  <details>
    <summary>.NET</summary>
    Install the package:

  ```bash
  dotnet add package CondenseTech.CdkConstructs
  ```

  Import it:

  ```csharp
  using CondenseTech.CdkConstructs;
  ```

  </details>
  <details>
    <summary>Go</summary>
    Install the package:

  ```bash
  go get github.com/condensetech/cdk-constructs
  ```

  Import it:

  ```go
  import "github.com/condensetech/cdk-constructs"
  ```

  </details>



  All API docs can be found in the [API.md](./API.md).



  Readability and maintainability are key factors when writing IaC. By defining some high level interfaces, we can easily write constructs which don't need to be tied to the specific implementation of a resource.

  For example, the [INetworking](lib/interfaces.ts), defines some high level methods to interact with a VPC. Often a VPC contains a bastion host, which should be whitelisted to databases, so the interface has a `bastionHost` property which can return the bastion host. This allows to write code like the following:

  ```python
  interface MyDatabaseStackProps extends cdk.StackProps {
    networking: INetworking;
  }
  class MyDatabaseStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: MyDatabaseStackProps) {
      super(scope, id, props);

      const db = new rds.DatabaseInstance(this, 'Database', {
        vpc: props.networking.vpc,
        ...
      });
      if (props.networking.bastionHost) {
        db.connections.allowDefaultPortFrom(props.networking.bastionHost);
      }
    }
  }
  ```

  If a certain point we want to add a bastion host, we just need to flip one single switch in the networking props, to have the bastion host able to connect to all the resources in the VPC.

  Constructs and Stacks in this area:

  * [Networking](lib/constructs/networking.ts) and [NetworkingStack](lib/stacks/networking.ts)
  * [Aurora Cluster](lib/constructs/aurora-cluster.ts) and [AuroraClusterStack](lib/stacks/aurora-cluster.ts)
  * [RDS Instance](lib/constructs/database-instance.ts) and [DatabaseInstanceStack](lib/stacks/database-instance.ts)



  A typical scenario is to have one single Application Load Balancer in a VPC, which routes traffic to different services. The [Entrypoint Construct](lib/constructs/entrypoint.ts) and the [Entrypoint Stack](lib/stacks/entrypoint-stack.ts) allow to easily define this entrypoint load balancer.

  The [Entrypoint#allocateListenerRule](API.md#@condensetech/cdk-constructs.Entrypoint.allocateListenerRule) method tracks in a DynamoDB table the priority of the listener rules that are being created and generates a unique priority if one is not provided. This allows to operate in scenarios where different stacks are creating listener rules for the same load balancer.



  The [CloudwatchAlarmsTopicStack](lib/stacks/cloudwatch-alarms-topic-stack.ts) creates an SNS Topic which can be used as a target for Cloudwatch Alarms. In addition to link the topic to HTTPS endpoints, it can also create a Lambda function which can be used to send messages to Discord.



  [NaiveBasicAuthCloudfrontFunction](lib/constructs/naive-basic-auth-cloudfront-function.ts) is useful when a basic protection layer must be added to Cloudfront (for SPAs or static sites) and you just need to avoid crawlers and unwanted visitors.



  By instantiating a [MonitoringFacade](lib/constructs/monitoring/monitoring-facade.ts) in your stack, you can easily add monitoring to your resources. The facade will create a Cloudwatch Dashboard, and will add alarms to the resources you want to monitor.


pkgId: 7f22950f0475b27fd9b7faea4e843d0f0fb263f5921c9a0ef01430d826507538
name: python-condensetech.cdk-constructs
arch: src
version: 0.5.5
epoch: 0
release: 1
summary: Condense's opinionated constructs and stacks for AWS CDK
url: https://github.com/cdklabs/cdk-monitoring-constructs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-condensetech.cdk-constructs-0.5.5-1.src.rpm
checksum_type: sha256
description:
  This library contains constructs and stacks we use across our projects.



  <details>
    <summary>Node.js</summary>
    Install the package:

  ```bash
  npm install @condensetech/cdk-constructs # or
  yarn add @condensetech/cdk-constructs # or
  pnpm add @condensetech/cdk-constructs
  ```

  Import it:

  ```python
  import * as condense from '@condensetech/cdk-constructs';
  ```

  </details>
  <details>
    <summary>Python</summary>
    Install the package:

  ```bash
  pip install condensetech.cdk-constructs
  ```

  Import it:

  ```py
  from condensetech import cdk_constructs
  ```

  </details>
  <details>
    <summary>.NET</summary>
    Install the package:

  ```bash
  dotnet add package CondenseTech.CdkConstructs
  ```

  Import it:

  ```csharp
  using CondenseTech.CdkConstructs;
  ```

  </details>
  <details>
    <summary>Go</summary>
    Install the package:

  ```bash
  go get github.com/condensetech/cdk-constructs
  ```

  Import it:

  ```go
  import "github.com/condensetech/cdk-constructs"
  ```

  </details>



  All API docs can be found in the [API.md](./API.md).



  Readability and maintainability are key factors when writing IaC. By defining some high level interfaces, we can easily write constructs which don't need to be tied to the specific implementation of a resource.

  For example, the [INetworking](lib/interfaces.ts), defines some high level methods to interact with a VPC. Often a VPC contains a bastion host, which should be whitelisted to databases, so the interface has a `bastionHost` property which can return the bastion host. This allows to write code like the following:

  ```python
  interface MyDatabaseStackProps extends cdk.StackProps {
    networking: INetworking;
  }
  class MyDatabaseStack extends cdk.Stack {
    constructor(scope: Construct, id: string, props: MyDatabaseStackProps) {
      super(scope, id, props);

      const db = new rds.DatabaseInstance(this, 'Database', {
        vpc: props.networking.vpc,
        ...
      });
      if (props.networking.bastionHost) {
        db.connections.allowDefaultPortFrom(props.networking.bastionHost);
      }
    }
  }
  ```

  If a certain point we want to add a bastion host, we just need to flip one single switch in the networking props, to have the bastion host able to connect to all the resources in the VPC.

  Constructs and Stacks in this area:

  * [Networking](lib/constructs/networking.ts) and [NetworkingStack](lib/stacks/networking.ts)
  * [Aurora Cluster](lib/constructs/aurora-cluster.ts) and [AuroraClusterStack](lib/stacks/aurora-cluster.ts)
  * [RDS Instance](lib/constructs/database-instance.ts) and [DatabaseInstanceStack](lib/stacks/database-instance.ts)



  A typical scenario is to have one single Application Load Balancer in a VPC, which routes traffic to different services. The [Entrypoint Construct](lib/constructs/entrypoint.ts) and the [Entrypoint Stack](lib/stacks/entrypoint-stack.ts) allow to easily define this entrypoint load balancer.

  The [Entrypoint#allocateListenerRule](API.md#@condensetech/cdk-constructs.Entrypoint.allocateListenerRule) method tracks in a DynamoDB table the priority of the listener rules that are being created and generates a unique priority if one is not provided. This allows to operate in scenarios where different stacks are creating listener rules for the same load balancer.



  The [CloudwatchAlarmsTopicStack](lib/stacks/cloudwatch-alarms-topic-stack.ts) creates an SNS Topic which can be used as a target for Cloudwatch Alarms. In addition to link the topic to HTTPS endpoints, it can also create a Lambda function which can be used to send messages to Discord or Slack.



  [NaiveBasicAuthCloudfrontFunction](lib/constructs/naive-basic-auth-cloudfront-function.ts) is useful when a basic protection layer must be added to Cloudfront (for SPAs or static sites) and you just need to avoid crawlers and unwanted visitors.



  By instantiating a [MonitoringFacade](lib/constructs/monitoring/monitoring-facade.ts) in your stack, you can easily add monitoring to your resources. The facade will create a Cloudwatch Dashboard, and will add alarms to the resources you want to monitor.


pkgId: f04d151208c5d2fde71a52f4b0cd43d47d1dee407eaf5a6481a9d47a9a246ac0
name: python-conditional-get
arch: src
version: 0.3
epoch: 0
release: 1
summary: CLI tool for fetching data using HTTP conditional get
url: https://github.com/simonw/conditional-get
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conditional-get-0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/conditional-get.svg)](https://pypi.org/project/conditional-get/)
  [![Changelog](https://img.shields.io/github/v/release/simonw/conditional-get?include_prereleases&label=changelog)](https://github.com/simonw/conditional-get/releases)
  [![Tests](https://github.com/simonw/conditional-get/workflows/Test/badge.svg)](https://github.com/simonw/conditional-get/actions?query=workflow%3ATest)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/dogsheep/conditional-get/blob/main/LICENSE)

  CLI tool for fetching data using [HTTP conditional get](https://developer.mozilla.org/en-US/docs/Web/HTTP/Conditional_requests).



      pip install conditional-get



  The first time you run this command it will download the file and store the ETag (if one was returned) in a file called `etags.json`.

  The second time you run this command against the same URL it will use that ETag, potentially resulting in a `304 Not Modified` response which saves bandwidth by not re-downloading the file.

      
      conditional-get https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png
      
      conditional-get https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png

  The filename will be derived from the URL. You can customize the filename using the `-o` option:

      conditional-get https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png -o til.png

  By default the ETags for the retrieved URLs will be stored in a `etags.json` file in the current directory. You can use the `--etags otherfile.json` to store that file somewhere else:

      conditional-get https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png --etags my-etags.json

  Use the `-v` option to get debug output showing what is happening:

      $ conditional-get https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png -v
      Response status code: 200
      [####################################]  100%

      $ ls
      Simon_Willison__TIL.png	etags.json

      $ cat etags.json
      {
          "https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png": "\"d65b78782dfa93213c99099e0e2181d8\""
      }

      $ conditional-get https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png -v
      Existing ETag: "d65b78782dfa93213c99099e0e2181d8"
      Response status code: 304

  The key used to store the ETag in `etags.json` defaults to the URL. You can specify a custom key using the `--key` option:

      conditional-get --key til https://static.simonwillison.net/static/2020/Simon_Willison__TIL.png
      cat etags.json
      {
          "til": "\"d65b78782dfa93213c99099e0e2181d8\""
      }

  This is useful if the URL to the file changes even though the file contents stays the same - for example if you are downloading files from URLs that include an expiring signature.


pkgId: 1e1f1f576866a27d3c87bb1ec005de37db230e32e3416a583d560f517abe92a1
name: python-condor-git-config
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: dynamically configure an HTCondor node from a git repository
url: https://pypi.org/project/condor-git-config/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-condor-git-config-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Installation provides the ``condor-git-config`` executable.
  All other dependencies are installed automatically.
  Stable release version
      pip3 install condor_git_config
  Current development version
      pip3 install git+https://github.com/MatterMiners/condor-git-config.git
  We recommend to install the hook to a
  `virtual environment <https://docs.python.org/3/library/venv.html>`_.
  However, the hook is simple enough to not disturb global environments.


pkgId: 9589f1f8959e0338ca6f21e6d2bb0c82714d7a602aa29c6e9d36046cad66a61a
name: python-conductor_celery
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: This is a template repository for Python projects that use Poetry for their dependency management.
url: https://github.com/tomas_correa/conductor-celery
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conductor_celery-0.1.9-1.src.rpm
checksum_type: sha256
description:
  Repository initiated with [fpgmaas/cookiecutter-poetry](https://github.com/fpgmaas/cookiecutter-poetry).


pkgId: c85c4a39a88ecd1310a18a2c9e432726531b1d7f00d05fc56db4f5324a1453c3
name: python-conductorquantum
arch: src
version: 0.0.12
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/conductorquantum/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conductorquantum-0.0.12-1.src.rpm
checksum_type: sha256
description:
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://github.com/fern-api/fern)
  [![pypi](https://img.shields.io/pypi/v/conductorquantum)](https://pypi.python.org/pypi/conductorquantum)

  The ConductorQuantum Python library provides convenient access to the ConductorQuantum API from Python.



  ```sh
  pip install conductorquantum
  ```



  Instantiate and use the client with the following:

  ```python
  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      token="YOUR_TOKEN",
  )
  client.models.execute(
      model="coulomb-blockade-peak-detector",
  )
  ```



  The SDK also exports an `async` client so that you can make non-blocking calls to our API.

  ```python
  import asyncio

  from conductorquantum import AsyncConductorQuantum

  client = AsyncConductorQuantum(
      token="YOUR_TOKEN",
  )


  async def main() -> None:
      await client.models.execute(
          model="coulomb-blockade-peak-detector",
      )


  asyncio.run(main())
  ```



  When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
  will be thrown.

  ```python
  from conductorquantum.core.api_error import ApiError

  try:
      client.models.execute(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```





  The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
  as the request is deemed retriable and the number of retry attempts has not grown larger than the configured
  retry limit (default: 2).

  A request is deemed retriable when any of the following HTTP status codes is returned:

  - [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
  - [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
  - [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)

  Use the `max_retries` request option to configure this behavior.

  ```python
  client.models.execute(..., {
      "max_retries": 1
  })
  ```



  The SDK defaults to a 60 second timeout. You can configure this with a timeout option at the client or request level.

  ```python

  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      ...,
      timeout=20.0,
  )



  client.models.execute(..., {
      "timeout_in_seconds": 1
  })
  ```



  You can override the `httpx` client to customize it for your use-case. Some common use-cases include support for proxies
  and transports.
  ```python
  import httpx
  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      ...,
      httpx_client=httpx.Client(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Additions made directly to this library would have to be moved over to our generation code,
  otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
  a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
  an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 89c13744b8d7884f4d41913b92aa66992eda9e70a80c4af01ad4b71e0404f7c8
name: python-conductorquantum
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/conductorquantum/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conductorquantum-0.0.14-1.src.rpm
checksum_type: sha256
description:
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-Built%20with%20Fern-brightgreen)](https://buildwithfern.com?utm_source=github&utm_medium=github&utm_campaign=readme&utm_source=https%3A%2F%2Fgithub.com%2Fconductorquantum%2Fconductorquantum-python)
  [![pypi](https://img.shields.io/pypi/v/conductorquantum)](https://pypi.python.org/pypi/conductorquantum)

  The ConductorQuantum Python library provides convenient access to the ConductorQuantum API from Python.



  ```sh
  pip install conductorquantum
  ```



  Instantiate and use the client with the following:

  ```python
  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      token="YOUR_TOKEN",
  )
  client.models.execute(
      model="coulomb-blockade-peak-detector",
  )
  ```



  The SDK also exports an `async` client so that you can make non-blocking calls to our API.

  ```python
  import asyncio

  from conductorquantum import AsyncConductorQuantum

  client = AsyncConductorQuantum(
      token="YOUR_TOKEN",
  )


  async def main() -> None:
      await client.models.execute(
          model="coulomb-blockade-peak-detector",
      )


  asyncio.run(main())
  ```



  When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
  will be thrown.

  ```python
  from conductorquantum.core.api_error import ApiError

  try:
      client.models.execute(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```





  The SDK is instrumented with automatic retries with exponential backoff. A request will be retried as long
  as the request is deemed retriable and the number of retry attempts has not grown larger than the configured
  retry limit (default: 2).

  A request is deemed retriable when any of the following HTTP status codes is returned:

  - [408](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408) (Timeout)
  - [429](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429) (Too Many Requests)
  - [5XX](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500) (Internal Server Errors)

  Use the `max_retries` request option to configure this behavior.

  ```python
  client.models.execute(..., {
      "max_retries": 1
  })
  ```



  The SDK defaults to a 60 second timeout. You can configure this with a timeout option at the client or request level.

  ```python

  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      ...,
      timeout=20.0,
  )



  client.models.execute(..., {
      "timeout_in_seconds": 1
  })
  ```



  You can override the `httpx` client to customize it for your use-case. Some common use-cases include support for proxies
  and transports.
  ```python
  import httpx
  from conductorquantum import ConductorQuantum

  client = ConductorQuantum(
      ...,
      httpx_client=httpx.Client(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```



  While we value open-source contributions to this SDK, this library is generated programmatically.
  Additions made directly to this library would have to be moved over to our generation code,
  otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
  a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
  an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: a31423b938e1fabc31e54dc7c40579f748e455727aab4da3f05a9dfc241f4d2d
name: python-condynsate
arch: src
version: 0.6.10
epoch: 0
release: 1
summary: Simulates and visualizes articulated systems in real time
url: https://github.com/GrayKS3248/condynsate
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-condynsate-0.6.10-1.src.rpm
checksum_type: sha256
description:
  - [**Introduction**](#introduction)

  - [**Windows Usage**](#Windows-Usage)

    - [Windows Command Line Basics](#Windows-Command-Line-Basics)

      - [How to open an Anaconda Prompt in Windows](#How-to-open-an-Anaconda-Prompt-in-Windows)

      - [How to run a command in Windows](#How-to-run-a-command-in-Windows)

      - [How to change the working directory in Windows](#How-to-change-the-working-directory-in-Windows)

    - [Windows Installation](#Windows-Installation)

      - [1 Install Miniconda for Windows](#1-Install-Miniconda-for-Windows)

      - [2 Install condynsate in a Miniconda virtual environment in Windows](#2-Install-condynsate-in-a-Miniconda-virtual-environment-in-Windows)

    - [Running Projects in Windows](#Running-Projects-in-Windows)

      - [1 Change your working directory in Windows](#1-Change-your-working-directory-in-Windows)

      - [2 Get the latest version of the code in Windows](#2-Get-the-latest-version-of-the-code-in-Windows)

      - [3 Start a Jupyter Notebook in Windows](#3-Start-a-Jupyter-Notebook-in-Windows)

  - [**Linux Usage**](#Linux-Usage)

    - [Linux Command Line Basics](#Linux-Command-Line-Basics)

      - [How to open the Terminal in Linux](#How-to-open-the-Terminal-in-Linux)

      - [How to run a command in Linux](#How-to-run-a-command-in-Linux)

      - [How to change the working directory in Linux](#How-to-change-the-working-directory-in-Linux)

    - [Linux Installation](#Linux-Installation)

      - [1 Install Miniconda for Linux](#1-Install-Miniconda-for-Linux)

      - [2 Install condynsate in a Miniconda virtual environment in Linux](#2-Install-condynsate-in-a-Miniconda-virtual-environment-in-Linux)

    - [Running Projects in Linux](#Running-Projects-in-Linux)

      - [1 Change your working directory in Linux](#1-Change-your-working-directory-in-Linux)

      - [2 Get the latest version of the code in Linux](#2-Get-the-latest-version-of-the-code-in-Linux)

      - [3 Activate your Conda environment in Linux](#3-Activate-your-Conda-environment-in-Linux)

      - [4 Start a Jupyter Notebook in Linux](#4-Start-a-Jupyter-Notebook-in-Linux)

  - [**MacOS Usage**](#MacOS-Usage)

    - [MacOS Command Line Basics](#MacOS-Command-Line-Basics)

      - [How to open the Terminal in MacOS](#How-to-open-the-Terminal-in-MacOS)

      - [How to run a command in MacOS](#How-to-run-a-command-in-MacOS)

      - [How to change the working directory in MacOS](#How-to-change-the-working-directory-in-MacOS)

    - [MacOS Installation](#MacOS-Installation)

      - [1 Install xcode select for MacOS](#1-Install-xcode-select-for-MacOS)

      - [2 Install Miniconda for MacOS](#2-Install-Miniconda-for-MacOS)

      - [3 Grant Input Monitoring Access to Terminal in MacOS](#3-Grant-Input-Monitoring-Access-to-Terminal-in-MacOS)

      - [4 Install condynsate in a Miniconda virtual environment in MacOS](#4-Install-condynsate-in-a-Miniconda-virtual-environment-in-MacOS)

    - [Running Projects in MacOS](#Running-Projects-in-MacOS)

      - [1 Change your working directory in MacOS](#1-Change-your-working-directory-in-MacOS)

      - [2 Get the latest version of the code in MacOS](#2-Get-the-latest-version-of-the-code-in-MacOS)

      - [3 Start a Jupyter Notebook in MacOS](#3-Start-a-Jupyter-Notebook-in-MacOS)

  - [**Examples and Tutorials**](#Examples-and-Tutorials)



  [condynsate](https://github.com/GrayKS3248/condynsate) is a dynamic system simulation and visualization tool built with [PyBullet](https://pybullet.org/wordpress/) and [MeshCat](https://github.com/meshcat-dev/meshcat-python). It automatically simulates multiple objects and their interactions as described by [.urdf](http://wiki.ros.org/urdf), [.stl](https://en.wikipedia.org/wiki/STL_(file_format)), and [.obj](https://en.wikipedia.org/wiki/Wavefront_.obj_file) files and can render real time visualizations in a web browser.

  This tool was built by [Grayson Schaer](http://bretl.csl.illinois.edu/people) during the 2023 Fall semester at the University of Illinois at Urbana-Champaign under the Grainger College of Engineering 2023-24 Strategic Instructional Innovations Program: Computational Tools for Dynamics and Control [grant](https://ae3.engineering.illinois.edu/files/2023/09/UIUC-SIIP-projects-2023-24.FINAL_-1.pdf).

  Condynsate provides real-time simulation and visualization of articulated bodies with nonlinear dynamics in Python. It was optimized for education and promotes easy in-class demonstrations and lab demos without physical equipment. Further, it encourages students to activate motor neurons, and simulates play during the learning process --both of which are beneficial to the processes of [memory and learning](https://doi.org/10.3390/educsci13070747).







  When we say "open an Anaconda Prompt," what we mean is to start the **Anaconda Prompt (Miniconda3)** application. Here is one way to do that:

  - Click the Windows search bar near the bottom-left corner of your desktop.
  - Type "anaconda" into the search field.
  - Click **Anaconda Prompt (Miniconda3)**.

  Note that this application will only exist after you follow the instructions to [1 Install Miniconda for Windows](1-Install-Miniconda-for-Windows).



  When we say "run a command," what we mean is to type something into the window of an Anaconda Prompt and press enter. See [this beginners guide](https://www.makeuseof.com/tag/a-beginners-guide-to-the-windows-command-line/) to [Windows Commands](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/windows-commands).



  All the files on your computer are organized in folders, which are commonly referred to as "directories." When you are working on the command line, you are working in one of these directories. Commands you run can find files in that directory, but cannot (by default) find files in other directories.

  When we say "change the working directory," we mean exactly that --- telling an Anaconda Prompt the directory in which you want to work.

  To do this, we run the command

  ```
  cd path\to\directory
  ```

  where "`path\to\directory`" is replaced by the location of the directory in which you want to work. One easy way way to find this location (i.e., the "path" to your directory) is by dragging its folder from the File Explorer into your Anaconda Prompt window (see documentation on [Quickly Copy Files Paths to Your Command Prompt via Drag and Drop](https://lifehacker.com/quickly-copy-file-paths-to-your-command-prompt-via-drag-5382503). In particular, I would first type "`cd` " (note the single trailing space):

  ```
  C:\Users\jakek>cd
  ```

  Then, I would drag a folder into the powershell window and press enter. For instance, suppose I had created a folder called `ae353` somewhere on my computer and dragged it in, then pressed enter --- I would see something like this:

  ```
  C:\Users\jakek>cd C:\Users\jakek\OneDrive\Documents\ae353
  C:\Users\jakek\OneDrive\Documents\ae353>
  ```

  See documentation on [Find and Open Files using Windows Command Prompt](https://www.faqforge.com/windows/windows-10/find-and-open-files-using-windows-command-prompt/) for a way to search for the directory location of files on your computer.





  - **If you already have Miniconda installed, you can ignore this step.**

  - **If you have some other distribution of conda installed (Anaconda, Miniforge, etc.), we reccomend that you first uninstall that distribution then install Miniconda.**

  If you do not have Miniconda already installed, download the most recent Miniconda installer for Windows 64 from the [miniconda website](https://docs.conda.io/projects/miniconda/en/latest/) or just click [here](https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe) to download it automatically. Once the .exe is downloaded, run it. The .exe file has the format Miniconda3-latest-Windows-x86_64 and will be in your default downloads folder C:\Users\USER NAME\Downloads.

  Once the wizard is running, click **next**.

  ![conda1](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_1.png?raw=true)

  Click **I Agree**.

  ![conda2](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_2.png?raw=true)

  Ensure **Just Me (recommended)** is selected and click **Next**.

  ![conda3](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_3.png?raw=true)

  Click **Next**.

  ![conda4](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_4.png?raw=true)

  Ensure **Create start menu shortcuts (supported packages only)** is checked and **Register Miniconda3 as my default Python 3.11** is ***NOT CHECKED***.

  ![conda5](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_5.png?raw=true)

  Once installation is complete, click **next**.

  ![conda6](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_6.png?raw=true)

  You may deselected **Getting started with Conda** and **Welcome to Anaconda** then click **Finish**.

  ![conda7](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_7.png?raw=true)

  Navigate to the Windows Start Menu folder located at **C:\Users\USER NAME\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Miniconda3 (64-bit)**.

  ![conda8](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_8.png?raw=true)

  To create a desktop shortcut to Anaconda Prompt (the application that will be used interact with Miniconda), right click on **Anaconda Prompt (Miniconda3)**, navigate to **Send to**, then click **Desktop (create shortcut)**.

  ![conda9](https://github.com/w-chang/ae353-sp24/blob/main/Images/conda_9.png?raw=true)

  To verify that Miniconda is installed properly, open **Anaconda Prompt (Miniconda3)** and run the command

  ```bash
  conda --version
  ```

  If Miniconda is installed correctly, you should get a response that lists the version of Miniconda you just installed.



  To install condynsate in a Miniconda virtual environment, open **Anaconda Prompt (Miniconda3)** and run the command

  ```bash
  conda create -n ae353
  ```

  When prompted, type `y` and press enter.

  When complete, run the command

  ```bash
  conda activate ae353
  ```

  You can confirm the virtual environment you just created is activated correctly when the text `(base)` on the left hand side of the command line changes to `(ae353)`.

  Once you've ensured the virtual environment is activated, configure it by running the commands

  ```bash
  conda config --env --add channels conda-forge
  conda config --env --set channel_priority strict
  conda clean -a -y
  ```

  Now install the Conda-Forge dependencies by running the command

  ```bash
  conda install -y git matplotlib notebook numpy pybullet pynput pyside6 sympy scipy
  ```

  Once the installation is complete, install condynsate by running the commands

  ```bash
  pip cache purge
  pip install condynsate
  ```

  You can check that condynsate installed correctly by running the command

  ```bash
  python
  ```

  This starts a Python shell in your Anaconda prompt. Next run the commands

  ```python
  import condynsate
  condynsate.__version__
  ```

  If condynsate is installed correctly, the current version will be shown. You may now type

  ```python
  quit()
  ```

  to quit the Python shell.





  Open **Anaconda Prompt (Miniconda3)** and run the command

  ```
  conda activate ae353
  ```

  You should see the prefix to your prompt change from `(base)` to `(ae353)`.

  Next, change your working directory to wherever you cloned this repository.



  In your already open **Anaconda Prompt (Miniconda3)** run the commands

  ```
  git fetch
  git pull
  ```

  Do not worry, this will not overwrite any of your own work.



  In your already open **Anaconda Prompt (miniconda3)** run the command

  ```
  jupyter notebook
  ```

  A browser window should open with the Jupyter Notebook interface. You can now navigate to and open any of the notebooks (with extension `.ipynb`) used for examples, tutorials, or design projects.

  **We strongly recommend you duplicate and work with a copy of any given notebook rather than working with the original.** Feel free to ignore this suggestion if you are a `git` expert.







  When we say "open the terminal", what we mean is to start the **Terminal** application. To do this, you can use the keyboard shortcut **ctrl+alt+t**.



  When we say "run a command," what we mean is to type something into the window of the Terminal and press enter.



  All the files on your computer are organized in folders, which are commonly referred to as "directories." When you are working on the command line, you are working in one of these directories. Commands you run can find files in that directory, but cannot (by default) find files in other directories.

  When we say "change the working directory," we mean exactly that --- telling the Terminal the directory in which you want to work.

  To move in the directory tree, we run the command

  ```
  cd path\to\directory
  ```

  where "`path\to\directory`" is replaced by the location of the directory in which you want to work. If you want to move up a single directory, you can run the command

  ```
  cd ..
  ```





  - **If you already have Miniconda installed, you can ignore this step.**

  - **If you have some other distribution of conda installed (Anaconda, Miniforge, etc.), we reccomend that you first uninstall that distribution then install Miniconda.**

  If you do not have Miniconda already installed, run these four commands in the Terminal to quickly and quietly install the latest 64-bit version of the installer.

  ```bash
  mkdir -p ~/miniconda3
  wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
  bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
  rm -rf ~/miniconda3/miniconda.sh
  ```

  **Restart the Terminal.** After installing, initialize your newly-installed Miniconda by running the command

  ```bash
  ~/miniconda3/bin/conda init bash
  ```

  To verify that Miniconda is installed properly, run the command

  ```bash
  conda --version
  ```

  You should get a response that lists the version of Miniconda you just installed. If you do not, more help on installation can be found [here](https://docs.conda.io/projects/miniconda/en/latest/).



  To install condynsate in a Miniconda virtual environment, open the Terminal and run the command

  ```bash
  conda create -n ae353
  ```

  When prompted, type `y` and press enter. This creates a new virtual environment. to activate the environment, run the command

  ```bash
  conda activate ae353
  ```

  You can confirm the virtual environment you just created is activated correctly when the text `(base)` on the left hand side of the command line changes to `(ae353)`.

  Once you've ensured the virtual environment is activated, configure it by running the commands

  ```bash
  conda config --env --add channels conda-forge
  conda config --env --set channel_priority strict
  conda clean -a -y
  ```

  Now install the Conda-Forge dependencies by running the command

  ```bash
  conda install -y git matplotlib notebook numpy pybullet pynput pyside6 sympy scipy
  ```

  Once the installation is complete, install condynsate by running the commands

  ```bash
  pip cache purge
  pip install condynsate
  ```

  You can check that condynsate installed correctly by running the command

  ```bash
  python3
  ```

  This starts a Python shell in your Anaconda prompt. Next run the commands

  ```python
  import condynsate
  condynsate.__version__
  ```

  If condynsate is installed correctly, the current version will be shown. You may now type

  ```python
  quit()
  ```

  to quit the Python shell and exit out of the Terminal.





  Open the Terminal and change your working directory to wherever you cloned this repository.



  Run the commands

  ```
  git fetch
  git pull
  ```

  Do not worry, this will not overwrite any of your own work.



  Run the command

  ```
  conda activate ae353
  ```

  You should see the prefix to your prompt change from `(base)` to `(ae353)`. This means you are in the Conda environment you created for work with AE353.



  Run the command

  ```
  jupyter notebook
  ```

  A browser window should open with the Jupyter Notebook interface. You can now navigate to and open any of the notebooks (with extension `.ipynb`) used for examples, tutorials, or design projects.

  **We strongly recommend you duplicate and work with a copy of any given notebook rather than working with the original.** Feel free to ignore this suggestion if you are a `git` expert.







  When we say "open a terminal," what we mean is to start the **Terminal** application. Here are two ways to do that:

  - Click the Launchpad icon ![img](https://help.apple.com/assets/63FFD63D71728623E706DB4F/63FFD63E71728623E706DB56/en_US/a1f94c9ca0de21571b88a8bf9aef36b8.png) in the Dock, type Terminal in the search field, then click Terminal.
  - In the Finder ![img](https://help.apple.com/assets/63FFD63D71728623E706DB4F/63FFD63E71728623E706DB56/en_US/058e4af8e726290f491044219d2eee73.png), open the /Applications/Utilities folder, then double-click Terminal.

  See documentation on [Open Terminal](https://support.apple.com/guide/terminal/open-or-quit-terminal-apd5265185d-f365-44cb-8b09-71a064a42125/mac) for more information. Note that it is often helpful to have more than one terminal window open at the same time (or more than one tab in the same window).



  When we say "run a command," what we mean is to type something into the Terminal and press return. For example, suppose we said:

  > run the command `pwd` to find your current working directory

  You would type `pwd` into the terminal window and press return, with the result being something like this:

  ```bash
  timothybretl@Timothys-MacBook-Pro ~ % pwd
  /Users/timothybretl
  ```

  See documentation on [Execute commands and run tools in Terminal on Mac for more information](https://support.apple.com/guide/terminal/execute-commands-and-run-tools-apdb66b5242-0d18-49fc-9c47-a2498b7c91d5/mac). Also see the [Command Line Primer](https://developer.apple.com/library/archive/documentation/OpenSource/Conceptual/ShellScripting/CommandLInePrimer/CommandLine.html) for a list of frequently used commands.



  All the files on your computer are organized in folders, which are commonly referred to as "directories." When you are working on the command line in a terminal, you are working in one of these directories. Commands you run can find files in that directory, but cannot (by default) find files in other directories.

  When we say "change the working directory," we mean exactly that --- telling the terminal the directory in which you want to work.

  To do this, we run the command

  ```bash
  cd path/to/directory
  ```

  where "`path/to/directory`" is replaced by the location of the directory in which you want to work. One easy way way to find this location (i.e., the "path" to your directory) is by dragging its folder from the Finder into your terminal window (see documentation on [Drag items into a Terminal window on Mac](https://support.apple.com/guide/terminal/drag-items-into-a-terminal-window-trml106/mac)). In particular, I would first type "`cd` " (note the single trailing space):

  ```bash
  timothybretl@Timothys-MacBook-Pro ~ % cd
  ```

  Then, I would drag a folder into the terminal window and press return. For instance, suppose I had created a folder called `ae353` somewhere on my computer and dragged it in, then pressed return --- I would see something like this:

  ```bash
  timothybretl@Timothys-MacBook-Pro ~ % cd /Users/timothybretl/Documents/ae353
  timothybretl@Timothys-MacBook-Pro ae353 %
  ```

  See documentation on [Specify files and folders in Terminal on Mac](https://support.apple.com/guide/terminal/specify-files-and-folders-apd3cf6fe02-3ec8-48f1-951f-866e52955fc8/mac) for other ways to specify the path to a directory.





  If you do not already have Command Line Tools installed, open the Terminal and run the command

  ```Bash
  xcode-select --install
  ```

  Click the Install button on the window that opens and agree to the license agreement.



  - **Make sure your machine's operating system is updated to the most current version.**

  - **The installation steps for M1 machines vs. x86_86 machines are different.**

  - **If you have some other distribution of conda installed (Anaconda, Miniforge, etc.), we reccomend that you first uninstall that distribution then install Miniconda.**



  - Open the Terminal.

  - Run these four commands to quickly and quietly install the latest 64-bit version of the **ARM64** installer on your **M1** machine.

  ```bash
  mkdir -p ~/miniconda3
  curl https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/miniconda3/miniconda.sh
  bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
  rm -rf ~/miniconda3/miniconda.sh
  ```

  - Restart the terminal.

  - Initialize your newly-installed Miniconda by running the commands

  ```bash
  ~/miniconda3/bin/conda init bash
  ~/miniconda3/bin/conda init zsh
  ```

  - To verify that Miniconda is installed properly, run the command

  ```bash
  conda --version
  ```

  - You should get a response that lists the version of Miniconda you just installed. If you do not, more help on installation can be found [here](https://docs.conda.io/projects/miniconda/en/latest/).



  - Open the Terminal.

  - Run these four commands to quickly and quietly install the latest 64-bit version of the **x86_64** installer on your **Intel** machine.

  ```bash
  mkdir -p ~/miniconda3
  curl https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-x86_64.sh -o ~/miniconda3/miniconda.sh
  bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
  rm -rf ~/miniconda3/miniconda.sh
  ```

  - Restart the terminal.

  - Initialize your newly-installed Miniconda by running the commands

  ```bash
  ~/miniconda3/bin/conda init bash
  ~/miniconda3/bin/conda init zsh
  ```

  - To verify that Miniconda is installed properly, run the command

  ```bash
  conda --version
  ```

  - You should get a response that lists the version of Miniconda you just installed. If you do not, more help on installation can be found [here](https://docs.conda.io/projects/miniconda/en/latest/).



  To use keyboard interactivity in the projects, you must first grant the Terminal security access to monitor inputs (keyboards and mice). To do this

  - Choose Apple menu  > System Settings

  - Click Privacy & Security ![](https://help.apple.com/assets/6529D8627783ACA29F083601/6529D866CFDD5FD5B90BAB1B/en_US/f9979df145e31ea9fb18995403d2b2f6.png) (or Security & Privacy on older systems).

  - In the ribbon on the side, click the Input Monitoring tab. If the terminal is not in the list you will need to add it:

    - Click the lock icon to unlock the list. Input your password to unlock.

    - Click the **+** button.

    - Navigate to *Applications/Utilities*.

    - Locate the Terminal app and select **Open** to add it to the Input Monitoring list

  - Check the box next to the Terminal app in the Input Monitoring list to enable it.

  - Now, in the ribbon in the side, click the Accessibility tab. If the Terminal is not in the list, follow the steps above to add it.

  - Check the box next to the Terminal app in the Accessibility list to enable it.



  To create a new Miniconda virtual environment, in your already open Terminal run the command

  ```bash
  conda create -n ae353
  ```

  When prompted, type `y` and press enter. This creates a new virtual environment. To activate the environment, run the command

  ```bash
  conda activate ae353
  ```

  You can confirm the virtual environment you just created is activated correctly when the text `(base)` on the left hand side of the command line changes to `(ae353)`.

  Once you've ensured the virtual environment is activated, configure it by running the commands

  ```bash
  conda config --env --add channels conda-forge
  conda config --env --set channel_priority strict
  conda clean -a -y
  ```

  Now install pip from Conda-Forge by running the command

  ```bash
  conda install pip
  ```

  Once the installation is complete, install condynsate and other dependencies via pip by running the commands

  ```bash
  pip cache purge
  pip install wheel condynsate pyside6
  ```

  You can check that condynsate installed correctly by running the command

  ```bash
  python3
  ```

  This starts a Python shell in your Terminal. Next run the commands

  ```python
  import condynsate
  condynsate.__version__
  ```

  If condynsate is installed correctly, the current version will be shown. You may now type

  ```python
  quit()
  ```

  to quit the Python shell.





  Open the Terminal and run the command

  ```
  conda activate ae353
  ```

  You should see the prefix to your prompt change from `(base)` to `(ae353)`.

  Next, change your working directory to wherever you cloned this repository.



  In your already open Terminal run the commands

  ```
  git fetch
  git pull
  ```

  Do not worry, this will not overwrite any of your own work.



  In your already open Terminal run the command

  ```
  jupyter notebook
  ```

  A browser window should open with the Jupyter Notebook interface. You can now navigate to and open any of the notebooks (with extension `.ipynb`) used for examples, tutorials, or design projects.

  **We strongly recommend you duplicate and work with a copy of any given notebook rather than working with the original.** Feel free to ignore this suggestion if you are a `git` expert.



  For examples of usage, see [examples](https://github.com/GrayKS3248/condynsate/tree/main/examples). For tutorials on using condynsate to design a project, see [tutorials](https://github.com/GrayKS3248/condynsate/tree/main/tutorials).

rpm_license:
  MIT License  Copyright (c) 2023 Grayson Schaer  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: 21929605d37f8e72d7abb0571f6635ea05bbc4b7ae52494f7c7fdd5c19fac7b6
name: python-conectividadeapp
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Plugin de conectividade para o Netbox
url: https://github.com/ufrn-netbox/conectividadeapp
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conectividadeapp-1.1.2-1.src.rpm
checksum_type: sha256
description:
  <details open="open">
    <summary>Table of Contents</summary>
    <ol>
      <li>
        <a href="#sobre-o-projeto">Sobre o Projeto</a>
        <ul>
          <li><a href="#construído-com">Construído com</a></li>
        </ul>
      </li>
      <li>
        <a href="#primeiros-passos">Primeiros Passos</a>
        <ul>
          <li><a href="#memo-pré-requisitos">Pré-requisitos</a></li>
          <li><a href="#wrench-instalação">Instalação</a></li>
        </ul>
      </li>
      <li><a href="#como-usar">Como Usar</a></li>
      <li><a href="#licençe">Licença</a></li>
      <li><a href="#contato">Contato</a></li>
      <li><a href="#conhecimento">Conhecimento</a></li>
      <li>
          <a href="#outros-itens">Outros Itens</a>
          <ul>
              <li><a href="#página-de-administração-do-django">Página de Administração do Django</a></li>
              <li><a href="#diagrama-entidade-relacionamento">Diagrama Entidade Relacionamento</a></li>
              <li><a href="#bpmn">BPMN</a></li>
          </ul>
      </li>
    </ol>
  </details>



  ![Initial Page](docs/img/new_initial_plugin_page.png)

  Um plugin de Conectividade para o Netbox que permite manter o histórico de movimentação de ativos de TI (atividades de instalação e remoção).



  * [Python](https://www.python.org/)
  * [Django](https://www.djangoproject.com/)
  * [Bootstrap](https://getbootstrap.com)




  - Netbox v2.10.0+


  - pip install conectividadeapp==1.1.1





  Distribuído sob a licença Apache 2.0. Veja [LICENSE](LICENSE) para mais informações.










  ![Initial Page](docs/img/new_admin_plugin_page.png)



  ![Diagrama](docs/img/db_new_model.png)



  ![BPMN](docs/img/bpmn.png)


pkgId: e61c1e8bda5ee22a2a29e69775ce64643142ba50f1365baf824cd1db7f051157
name: python-coneref
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/dance858/coneref
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-coneref-0.2.2-1.src.rpm
checksum_type: sha256
description:
  `coneref` is a Python package for iteratively refining an approximate solution to a conic linear program. It has an interface to [`cvxpy`](https://www.cvxpy.org) and is easy to use.


  `coneref` is available on PyPI. Install it with

  ```bash
  pip install coneref
  ```
  `coneref` uses [`Eigen`](https://eigen.tuxfamily.org/index.php?title=Main_Page) for linear algebra. Eigen has a built-in support for vectorization. To enable vectorization, install `coneref` from the source distribution using the command (on Linux)
  ```bash
  MARCH_NATIVE=1 pip install coneref --no-binary=coneref
  ```
  Enabling vectorization typically decreases the refinement time by a factor of 2 for problems with matrix variables and by 10% for problems with vector variables.

  Building `coneref` from the source distribution requires a compiler that supports C++11.


  The basic idea of the refinement procedure is to reduce the problem of solving a conic linear program to the problem of finding a zero of a nonlinear map. A Newton-based method is then applied to solve the root-finding problem. For more details, see the paper [Solution Refinement at Regular Points of Conic Problems](https://web.stanford.edu/~boyd/papers/cone_prog_refine.html). Also see the note [refinement_theory_note.pdf](https://github.com/dance858/coneref/blob/main/refinement_theory_note.pdf).



  `coneref` can be used in combination with [`cvxpy`](https://www.cvxpy.org). The following optimization problem arises in the context of sparse inverse covariance estimation:

  $$\begin{equation*} \begin{array}{ll} \text{minimize} & \text{log det}  (S) + \text{Tr} (S Q) + \alpha \left\lVert S\right\rVert_1 \end{array}  \end{equation*},$$

  where the optimization variable is $S \in \bf{S}^n$. The following code snippet generates a problem instance, solves it using [`SCS`](https://github.com/cvxgrp/scs), takes two refinement steps and then two additional refinement steps.

  ```python
  import numpy as np
  import scipy
  from sklearn.datasets import make_sparse_spd_matrix
  import cvxpy as cp
  import coneref


  q = 40
  p = (7 + np.random.randint(0, 6))*q
  ratio = 0.9
  S_true = make_sparse_spd_matrix(q, alpha = ratio)
  Sigma = np.linalg.inv(S_true)
  z_sample = scipy.linalg.sqrtm(Sigma).dot(np.random.randn(q,p))
  Q = np.cov(z_sample)
  mask = np.ones(Q.shape, dtype=bool)
  np.fill_diagonal(mask, 0)
  alpha_max = np.max(np.abs(Q)[mask])
  alpha = 0.005*alpha_max


  S = cp.Variable((q, q), PSD = True)
  obj = -cp.log_det(S) + cp.trace(S @ Q) + alpha*cp.sum(cp.abs(S))
  problem = cp.Problem(objective = cp.Minimize(obj))


  print("Solve problem with SCS and take two refinement steps.")
  coneref.cvxpy_solve(problem, verbose_scs=False)


  print("Take two additional refinement steps.")
  coneref.cvxpy_solve(problem)


  estimated_covariance_matrix = S.value
  ```
  Running this code snippet produces the following output.


  ```
  Solve problem with SCS and take two refinement steps.
  After SCS (total time = 8.74e+02s):
  Primal residual/dual residual/duality_gap: 4.7324e-05   1.7722e-02   -7.7714e-04

  After refinement (ref time = 5.68e+00s):
  Primal residual/dual residual/duality_gap: 1.6998e-05   6.8185e-07   1.4947e-07

  Take two additional refinement steps.
  After refinement (ref time = 5.16e+00s):
  Primal residual/dual residual/duality_gap: 6.5164e-06   3.5763e-07   -3.4035e-08
  ```


  The package exposes the function
  ```python
  cvxpy_solve(prob, ref_iter=2, lsqr_iter=300, verbose_scs=True, scs_opts={}, warmstart=False, verbose_ref1=True, verbose_ref2=True).
  ```
  Here the arguments are defined as follows.
  * `prob` - The problem you want to solve in CVXPY-format.
  * `ref-iter` - number of refinement steps.
  * `lsqr_iter` - each refinement step requires solving a sparse linear system approximately. This parameter determines the maximum number of LSQR                     iterations.
  * `verbose_scs` - verbose parameter sent to SCS. If true, SCS outputs its progress.
  * `warm_start` - Whether to warm-start SCS or not.
  * `verbose_ref1` - If true the refinement algorithm outputs the norm of the KKT-residuals/infeasibility certificates.
  * `verbose_ref2` - If true the refinement algorithm outputs the norm of the normalized residual map. This option is mainly for developers.

  The function modifies the object `prob` in the following way: `TODO`



  The refinement algorithm can often produce a more accurate solution with just a small additional cost, see Section 4 of [refinement_theory_note.pdf](https://github.com/dance858/coneref/blob/main/refinement_theory_note.pdf) for empirical results.


  `TODO` Some code has been modified from ...
  Also add tests.


  If you find this package useful, consider citing the following works.

  ```
  @misc{cpr,
      author       = {Cederberg, D. and Boyd, S.},
      title        = {{coneref}: conic LP refinement, version 0.1},
      howpublished = {\url{https://github.com/dance858/coneref}},
      year         = 2022
  }

  @article{cpr2019,
      author       = {Busseti, E. and Moursi, W. and Boyd, S.},
      title        = {Solution refinement at regular points of conic problems},
      journal      = {Computational Optimization and Applications},
      year         = {2019},
      volume       = {74},
      number       = {3},
      pages        = {627--643},
  }
  ```


pkgId: 481d6aad21647bab4120b4e3e93309929dd7a2f9c4d0f6f98d03517cf3be595c
name: python-conesearch-alchemy
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: SQLAlchemy extension for indexed cone searches in astronomical catalogs
url: https://github.com/skyportal/conesearch-alchemy
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conesearch-alchemy-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Status](https://img.shields.io/pypi/v/conesearch-alchemy)](https://pypi.org/project/conesearch-alchemy/)
  [![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/skyportal/conesearch-alchemy/build-and-test.yml?branch=main)](https://github.com/skyportal/conesearch-alchemy/actions)
  [![codecov](https://codecov.io/gh/skyportal/conesearch-alchemy/branch/main/graph/badge.svg?token=XQ7BS7I216)](https://codecov.io/gh/skyportal/conesearch-alchemy)



  The `conesearch_alchemy` Python package enhances [SQLAlchemy] to provide fast,
  indexed cone searches on astronomical catalogs using a PostgreSQL database. It
  does not rely on any database extensions.



  You can install `conesearch_alchemy` the Python Package Index:

      $ pip install conesearch-alchemy



  ```python
  from conesearch_alchemy.point import Point
  from sqlalchemy.ext.declarative import declarative_base

  Base = declarative_base()




  class Catalog1(Point, Base):
      __tablename__ = 'catalog1'
      id = Column(Integer, primary_key=True)


  class Catalog2(Point, Base):
      __tablename__ = 'catalog2'
      id = Column(Integer, primary_key=True)


  ...


  session.add(Catalog1(id=0, ra=320.5, dec=-23.5))
  ...
  session.add(Catalog2(id=0, ra=18.1, dec=18.3))
  ...
  session.commit()



  separation = 1  # separation in degrees
  query = session.query(
      Catalog1.id, Catalog2.id
  ).join(
      Catalog2,
      Catalog1.within(point, separation)
  ).order_by(
      Catalog1.id, Catalog2.id
  )
  for row in query:
      ...  # do something with the query results



  separation = 1  # separation in degrees
  point = Point(ra=212.5, dec=-33.2)
  query = session.query(
      Catalog1.id
  ).filter(
      Catalog1.within(point, separation)
  ).order_by(
      Catalog1.id
  )
  for row in query:
      ...  # do something with the query results
  ```

  [SQLAlchemy]: https://www.sqlalchemy.org


pkgId: 3d5fdc7e2b71d6633d7359ced17c97e5f29d3bcb28482fc934a3e26d106d8a6b
name: python-conexionbddian
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Paquete conexión SOLEM para subdirección Riesgo - DIAN
url: https://pypi.org/project/conexionbddian/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conexionbddian-0.0.7-1.src.rpm
checksum_type: sha256
description:
  Este módulo de Python proporciona un conjunto de utilidades para interactuar con la base de datos Oracle SOLEM utilizando `cx_Oracle` y `SQLAlchemy`. Las utilidades incluyen funciones para conectarse a la base de datos, ejecutar consultas SQL y devolver resultados como DataFrames de Pandas.



  - **Conexión a la Base de Datos:** Establece una conexión con la base de datos Oracle SOLEM utilizando credenciales almacenadas en un archivo de entorno.
  - **Ejecución de Consultas:** Ejecuta consultas SQL utilizando `cx_Oracle` o `SQLAlchemy`.
  - **Recuperación de Datos:** Recupera los resultados de las consultas como DataFrames de Pandas para una fácil manipulación y análisis.
  - **Creación de Engine:** Crea un motor de SQLAlchemy para operaciones avanzadas con la base de datos.



  Antes de usar este módulo, asegúrate de que los siguientes paquetes estén instalados:

  - `pandas`
  - `python-decouple`
  - `cx_Oracle`
  - `SQLAlchemy`

  Puedes instalarlos usando `pip`:

  ```bash
  pip install pandas python-decouple cx_Oracle SQLAlchemy
  ```



  Debes crear un archivo .env y colocarlo en $HOMEPATH. El archivo debe tener la siguiente información:

  -USER=tu_usuario
  -PASSWORD=tu_contraseña
  -SERVER=tu_servidor
  -PORT=tu_puerto
  -SERVICE_NAME=tu_nombre_de_servicio

  De igual forma asegúrate de tener instalado el oracle instant client.


pkgId: f577eea5381a72212d7e68a4724b6c4a286d00d8a2411c9e3c17551126f7e771
name: python-conf
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Facilitates a convenient use of configuration files
url: https://github.com/ramonhagenaars/conf
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conf-0.4.1-1.src.rpm
checksum_type: sha256
description:
  A *very* simple and *lightweight* configuration loader and parser for Python.
  Supports:
  -  ini files (``*.ini``)
  -  json files (``*.json``)
  -  yaml files (``*.yml``, ``*.yaml``)
  Installation
  ''''''''''''
  Bare installation:
      pip install conf
  Installation with support for YAML:
      pip install "conf[yaml]"
  Usage
  '''''
  Starting your app
  """""""""""""""""
  Start your app with your configuration file:
      python your_app.py --config your_config.yml
  Or:
      python your_app.py --config config_env_var
  The ``--config`` argument can be:
  - a relative path to a file;
  - an absolute path to a file;
  - the name of an environment variable which value holds one of the above.
  You are allowed to provide multiple configuration names (separated by a single space), in which case any setting of a former
  configuration file can be overwritten by a setting of a later configuration file (if the name of that setting is identical).
  Once you have supplied your application with some configuration, you can fetch the settings of that configuration. There are
  three options of how to do that.
  Fetching your setting (option 1)
  """"""""""""""""""""""""""""""""
  Simply get your setting from the ``conf`` module:
      import conf
      your_setting = conf.your_setting
  Fetching your setting (option 2)
  """"""""""""""""""""""""""""""""
  Import your setting directly:
      from conf import your_setting
  Fetching your setting (option 3)
  """"""""""""""""""""""""""""""""
  You can provide a default value if you are not sure the setting will be present:
      import conf
      your_setting = conf.get('your_setting', 'your default value')
  Note: If you use an ArgumentParser in your own application for other purposes, you must use the ``parse_known_args()`` method of the parser.
  Fetching your setting (option 4)
  """"""""""""""""""""""""""""""""
  You can get the configuration as a dictionary and get your setting as you would get any value from a ``dict``:
      import conf
      conf_dict = conf.asdict()
      your_setting = conf_dict.get('your_setting', 'your default value')
  Meta
  ''''
  This lib was designed and written in 2018 by `finetuned89 <https://github.com/finetuned89>`_ and `ramonhagenaars <https://github.com/ramonhagenaars>`_.


pkgId: af194c0ec5ebe27be7426ed55d0a1fd0ec0c4eb18cabcfd9f075d2b124fc30d0
name: python-conf-finder
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Configuration file finder.
url: https://pypi.org/project/conf-finder/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conf-finder-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/rcmdnk/conf-finder/actions/workflows/test.yml/badge.svg)](https://github.com/rcmdnk/conf-finder/actions/workflows/test.yml)
  [![test coverage](https://img.shields.io/badge/coverage-check%20here-blue.svg)](https://github.com/rcmdnk/conf-finder/tree/coverage)

  Configuration file finder.

  The configuration file/directory is searched for in the following locations by default:

  - The current directory
  - Git root repository (if the current directory is within a repository)
  - XDG config home (`$XDG_CONFIG_HOME`; if not set, **~/.config** is used)
  - Home directory

  To locate the configuration directory, the tool searches for a dot-prefixed
  name (e.g., .**mytool**) in all locations except for the XDG config home.
  Within the XDG config home, a name without the dot prefix (e.g., **mytool**)
  is searched for.

  If no directory is found, the path under the XDG config home is returned.

  To locate the configuration file, the tool first searches for a dot-prefixed
  file (e.g., **.myconf.txt**) in all locations except for the XDG config home.
  Within the XDG config home, a file name without the dot prefix
  (e.g., **myconf.txt**) is searched for. Following this, an attempt is made
  to find the file within the located configuration directories.

  If no file is found, the path under the configuration directory within
  the XDG config home is returned.



  - Python 3.9, 3.10, 3.11



  ```bash
  $ pip install conf-finder
  ```



  ```python
  from conf_finder import ConfFinder


  cf = ConfFinder("mytool")
  print(cf.directory())
  ```

  This script searches for:

  - **./.mytool**
  - **<Git root directory>/.mytool** if here is under the git repository.
  - **$XDG_CONFIG_HOME/mytool** (If `XDG_CONFIG_HOME` is not set, use `~/.config`.)
  - **~/.mytool**

  If no directory is found, return `$XDG_CONFIG_HOME/mytool` (or `~/.config/mytool`).

  ```python
  from conf_finder import ConfFinder


  cf = ConfFinder("mytool")
  print(cf.conf(exe="toml"))
  ```

  This script searches for:

  - **./.mytool.toml**
  - **<Git root directory>/.mytool.toml** if here is under the git repository.
  - **$XDG_CONFIG_HOME/mytool.toml** (If `XDG_CONFIG_HOME` is not set, use `~/.config`.)
  - **~/.mytool.toml**
  - **./.mytool/conf.toml**
  - **<Git root directory>/.mytool/conf.toml**
  - **$XDG_CONFIG_HOME/mytool/conf.toml**
  - **~/.mytool/conf.toml**

  ```python
  from conf_finder import ConfFinder


  cf = ConfFinder("mytool")
  print(cf.conf("mytool", "toml", "myconf"))
  ```

  This script searches for:

  - **./.myconf.toml**
  - **<Git root directory>/.myconf.toml**
  - **$XDG_CONFIG_HOME/myconf.toml**
  - **~/.myconf.toml**
  - **./.mytool/myconf.toml**
  - **<Git root directory>/.mytool/myconf.toml**
  - **$XDG_CONFIG_HOME/mytool/myconf.toml**
  - **~/.mytool/myconf.toml**

  If you wish to search for only files directly placed under the search directories,
  `conf_type` to `'file'`:

  ```python
  from conf_finder import ConfFinder


  cf = ConfFinder("mytool", conf_type="file")
  print(cf.conf("mytool", "toml", "myconf"))
  ```

  This script searches for:

  - **./.myconf.toml**
  - **<Git root directory>/.myconf.toml**
  - **$XDG_CONFIG_HOME/myconf.toml**
  - **~/.myconf.toml**

  If no file is found, **$XDG_CONFIG_HOME/myconf.toml** is returned.

  To search for only directories, `conf_type` to `'dir'` instead.


pkgId: 47f8d68fa53dd6f1b422655af308b6a573267028e0261475e68de3784d249d36
name: python-conf-tree
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Parsing, filtering and diff calculation for network device configurations
url: https://pypi.org/project/conf-tree/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conf-tree-0.1.1-1.src.rpm
checksum_type: sha256
description:
  service tcp-keepalives-in
  !
  service timestamps debug datetime msec localtime show-timezone
  !
  enable secret 5 2Fe034RYzgb7xbt2pYxcpA==
  !
  aaa group server tacacs+ TacacsGroup
   server 192.168.0.100
   server 192.168.0.101
  !
  interface Tunnel1
   ip address 10.0.0.2 255.255.255.0
   no ip redirects
  !
  interface Tunnel2
   ip address 10.1.0.2 255.255.255.0
   no ip redirects
  !
  interface FastEthernet0
   switchport access vlan 100
   no ip address
  !
  router bgp 64512
   neighbor 192.168.255.1 remote-as 64512
   neighbor 192.168.255.1 update-source Loopback0
   address-family ipv4
    network 192.168.100.0 mask 255.255.255.0
    neighbor 192.168.255.1 activate
  !


pkgId: bf3fdb3193f8934a6a0bd6090c04be1a229cbe8070bc6f1d326fffd887726098
name: python-confattr
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: Config Attributes
url: https://pypi.org/project/confattr/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confattr-1.6.2-1.src.rpm
checksum_type: sha256
description:
  Config Attributes

  A python library to read and write config files
  with a syntax inspired by vimrc and ranger config.

  Documentation: https://erzo.gitlab.io/confattr/latest


pkgId: ccaedfa6282db7ac008d60064b718133b31aeb9108dc04db74384bb922de182e
name: python-confection
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: The sweetest config system for Python
url: https://github.com/explosion/confection
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confection-0.1.5-1.src.rpm
checksum_type: sha256
description:
  <a href="https://explosion.ai"><img src="https://explosion.ai/assets/img/logo.svg" width="125" height="125" align="right" /></a>



  `confection` :candy: is a lightweight library that offers a **configuration
  system** letting you conveniently describe arbitrary trees of objects.

  Configuration is a huge challenge for machine-learning code because you may want
  to expose almost any detail of any function as a hyperparameter. The setting you
  want to expose might be arbitrarily far down in your call stack, so it might
  need to pass all the way through the CLI or REST API, through any number of
  intermediate functions, affecting the interface of everything along the way. And
  then once those settings are added, they become hard to remove later. Default
  values also become hard to change without breaking backwards compatibility.

  To solve this problem, `confection` offers a config system that lets you easily
  describe arbitrary trees of objects. The objects can be created via function
  calls you register using a simple decorator syntax. You can even version the
  functions you create, allowing you to make improvements without breaking
  backwards compatibility. The most similar config system we’re aware of is
  [Gin](https://github.com/google/gin-config), which uses a similar syntax, and
  also allows you to link the configuration system to functions in your code using
  a decorator. `confection`'s config system is simpler and emphasizes a different
  workflow via a subset of Gin’s functionality.

  [![tests](https://github.com/explosion/confection/actions/workflows/tests.yml/badge.svg)](https://github.com/explosion/confection/actions/workflows/tests.yml)
  [![Current Release Version](https://img.shields.io/github/v/release/explosion/confection.svg?style=flat-square&include_prereleases&logo=github)](https://github.com/explosion/confection/releases)
  [![pypi Version](https://img.shields.io/pypi/v/confection.svg?style=flat-square&logo=pypi&logoColor=white)](https://pypi.org/project/confection/)
  [![conda Version](https://img.shields.io/conda/vn/conda-forge/confection.svg?style=flat-square&logo=conda-forge&logoColor=white)](https://anaconda.org/conda-forge/confection)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/ambv/black)



  ```bash
  pip install confection
  ```

  ```bash
  conda install -c conda-forge confection
  ```



  The configuration system parses a `.cfg` file like

  ```ini
  [training]
  patience = 10
  dropout = 0.2
  use_vectors = false

  [training.logging]
  level = "INFO"

  [nlp]

  use_vectors = ${training.use_vectors}
  lang = "en"
  ```

  and resolves it to a `Dict`:

  ```json
  {
    "training": {
      "patience": 10,
      "dropout": 0.2,
      "use_vectors": false,
      "logging": {
        "level": "INFO"
      }
    },
    "nlp": {
      "use_vectors": false,
      "lang": "en"
    }
  }
  ```

  The config is divided into sections, with the section name in square brackets –
  for example, `[training]`. Within the sections, config values can be assigned to
  keys using `=`. Values can also be referenced from other sections using the dot
  notation and placeholders indicated by the dollar sign and curly braces. For
  example, `${training.use_vectors}` will receive the value of use_vectors in the
  training block. This is useful for settings that are shared across components.

  The config format has three main differences from Python’s built-in
  `configparser`:

  1. JSON-formatted values. `confection` passes all values through `json.loads` to
     interpret them. You can use atomic values like strings, floats, integers or
     booleans, or you can use complex objects such as lists or maps.
  2. Structured sections. `confection` uses a dot notation to build nested
     sections. If you have a section named `[section.subsection]`, `confection`
     will parse that into a nested structure, placing subsection within section.
  3. References to registry functions. If a key starts with `@`, `confection` will
     interpret its value as the name of a function registry, load the function
     registered for that name and pass in the rest of the block as arguments. If
     type hints are available on the function, the argument values (and return
     value of the function) will be validated against them. This lets you express
     complex configurations, like a training pipeline where `batch_size` is
     populated by a function that yields floats.

  There’s no pre-defined scheme you have to follow; how you set up the top-level
  sections is up to you. At the end of it, you’ll receive a dictionary with the
  values that you can use in your script – whether it’s complete initialized
  functions, or just basic settings.

  For instance, let’s say you want to define a new optimizer. You'd define its
  arguments in `config.cfg` like so:

  ```ini
  [optimizer]
  @optimizers = "my_cool_optimizer.v1"
  learn_rate = 0.001
  gamma = 1e-8
  ```

  To load and parse this configuration using a `catalogue` registry (install
  [`catalogue`](https://github.com/explosion/catalogue) separately):

  ```python
  import dataclasses
  from typing import Union, Iterable
  import catalogue
  from confection import registry, Config


  registry.optimizers = catalogue.create("confection", "optimizers", entry_points=False)



  @dataclasses.dataclass
  class MyCoolOptimizer:
      learn_rate: float
      gamma: float


  @registry.optimizers.register("my_cool_optimizer.v1")
  def make_my_optimizer(learn_rate: Union[float, Iterable[float]], gamma: float):
      return MyCoolOptimizer(learn_rate, gamma)



  config = Config().from_disk("./config.cfg")
  resolved = registry.resolve(config)
  optimizer = resolved["optimizer"]  # MyCoolOptimizer(learn_rate=0.001, gamma=1e-08)
  ```

  > ⚠️ Caution: Type-checkers such as `mypy` will mark adding new attributes to `registry` this way - i. e.
  > `registry.new_attr = ...` - as errors. This is because a new attribute is added to the class after initialization. If
  > you are using typecheckers, you can either ignore this (e. g. with `# type: ignore` for `mypy`) or use a typesafe
  > alternative: instead of `registry.new_attr = ...`, use `setattr(registry, "new_attr", ...)`.

  Under the hood, `confection` will look up the `"my_cool_optimizer.v1"` function
  in the "optimizers" registry and then call it with the arguments `learn_rate`
  and `gamma`. If the function has type annotations, it will also validate the
  input. For instance, if `learn_rate` is annotated as a float and the config
  defines a string, `confection` will raise an error.

  The Thinc documentation offers further information on the configuration system:

  - [recursive blocks](https://thinc.ai/docs/usage-config#registry-recursive)
  - [defining variable positional arguments](https://thinc.ai/docs/usage-config#registries-args)
  - [using interpolation](https://thinc.ai/docs/usage-config#config-interpolation)
  - [using custom registries](https://thinc.ai/docs/usage-config#registries-custom)
  - [advanced type annotations with Pydantic](https://thinc.ai/docs/usage-config#advanced-types)
  - [using base schemas](https://thinc.ai/docs/usage-config#advanced-types-base-schema)
  - [filling a configuration with defaults](https://thinc.ai/docs/usage-config#advanced-types-fill-defaults)





  This class holds the model and training
  [configuration](https://thinc.ai/docs/usage-config) and can load and save the
  INI-style configuration format from/to a string, file or bytes. The `Config`
  class is a subclass of `dict` and uses Python’s `ConfigParser` under the hood.



  Initialize a new `Config` object with optional data.

  ```python
  from confection import Config
  config = Config({"training": {"patience": 10, "dropout": 0.2}})
  ```

  | Argument          | Type                                      | Description                                                                                                                                                 |
  | ----------------- | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `data`            | `Optional[Union[Dict[str, Any], Config]]` | Optional data to initialize the config with.                                                                                                                |
  | `section_order`   | `Optional[List[str]]`                     | Top-level section names, in order, used to sort the saved and loaded config. All other sections will be sorted alphabetically.                              |
  | `is_interpolated` | `Optional[bool]`                          | Whether the config is interpolated or whether it contains variables. Read from the `data` if it’s an instance of `Config` and otherwise defaults to `True`. |



  Load the config from a string.

  ```python
  from confection import Config

  config_str = """
  [training]
  patience = 10
  dropout = 0.2
  """
  config = Config().from_str(config_str)
  print(config["training"])  # {'patience': 10, 'dropout': 0.2}}
  ```

  | Argument      | Type             | Description                                                                                                          |
  | ------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------- |
  | `text`        | `str`            | The string config to load.                                                                                           |
  | `interpolate` | `bool`           | Whether to interpolate variables like `${section.key}`. Defaults to `True`.                                          |
  | `overrides`   | `Dict[str, Any]` | Overrides for values and sections. Keys are provided in dot notation, e.g. `"training.dropout"` mapped to the value. |
  | **RETURNS**   | `Config`         | The loaded config.                                                                                                   |



  Load the config from a string.

  ```python
  from confection import Config

  config = Config({"training": {"patience": 10, "dropout": 0.2}})
  print(config.to_str()) # '[training]\npatience = 10\n\ndropout = 0.2'
  ```

  | Argument      | Type   | Description                                                                 |
  | ------------- | ------ | --------------------------------------------------------------------------- |
  | `interpolate` | `bool` | Whether to interpolate variables like `${section.key}`. Defaults to `True`. |
  | **RETURNS**   | `str`  | The string config.                                                          |



  Serialize the config to a byte string.

  ```python
  from confection import Config

  config = Config({"training": {"patience": 10, "dropout": 0.2}})
  config_bytes = config.to_bytes()
  print(config_bytes)  # b'[training]\npatience = 10\n\ndropout = 0.2'
  ```

  | Argument      | Type             | Description                                                                                                          |
  | ------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------- |
  | `interpolate` | `bool`           | Whether to interpolate variables like `${section.key}`. Defaults to `True`.                                          |
  | `overrides`   | `Dict[str, Any]` | Overrides for values and sections. Keys are provided in dot notation, e.g. `"training.dropout"` mapped to the value. |
  | **RETURNS**   | `str`            | The serialized config.                                                                                               |



  Load the config from a byte string.

  ```python
  from confection import Config

  config = Config({"training": {"patience": 10, "dropout": 0.2}})
  config_bytes = config.to_bytes()
  new_config = Config().from_bytes(config_bytes)
  ```

  | Argument      | Type     | Description                                                                 |
  | ------------- | -------- | --------------------------------------------------------------------------- |
  | `bytes_data`  | `bool`   | The data to load.                                                           |
  | `interpolate` | `bool`   | Whether to interpolate variables like `${section.key}`. Defaults to `True`. |
  | **RETURNS**   | `Config` | The loaded config.                                                          |



  Serialize the config to a file.

  ```python
  from confection import Config

  config = Config({"training": {"patience": 10, "dropout": 0.2}})
  config.to_disk("./config.cfg")
  ```

  | Argument      | Type               | Description                                                                 |
  | ------------- | ------------------ | --------------------------------------------------------------------------- |
  | `path`        | `Union[Path, str]` | The file path.                                                              |
  | `interpolate` | `bool`             | Whether to interpolate variables like `${section.key}`. Defaults to `True`. |



  Load the config from a file.

  ```python
  from confection import Config

  config = Config({"training": {"patience": 10, "dropout": 0.2}})
  config.to_disk("./config.cfg")
  new_config = Config().from_disk("./config.cfg")
  ```

  | Argument      | Type               | Description                                                                                                          |
  | ------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------- |
  | `path`        | `Union[Path, str]` | The file path.                                                                                                       |
  | `interpolate` | `bool`             | Whether to interpolate variables like `${section.key}`. Defaults to `True`.                                          |
  | `overrides`   | `Dict[str, Any]`   | Overrides for values and sections. Keys are provided in dot notation, e.g. `"training.dropout"` mapped to the value. |
  | **RETURNS**   | `Config`           | The loaded config.                                                                                                   |



  Deep-copy the config.

  | Argument    | Type     | Description        |
  | ----------- | -------- | ------------------ |
  | **RETURNS** | `Config` | The copied config. |



  Interpolate variables like `${section.value}` or `${section.subsection}` and
  return a copy of the config with interpolated values. Can be used if a config is
  loaded with `interpolate=False`, e.g. via `Config.from_str`.

  ```python
  from confection import Config

  config_str = """
  [hyper_params]
  dropout = 0.2

  [training]
  dropout = ${hyper_params.dropout}
  """
  config = Config().from_str(config_str, interpolate=False)
  print(config["training"])  # {'dropout': '${hyper_params.dropout}'}}
  config = config.interpolate()
  print(config["training"])  # {'dropout': 0.2}}
  ```

  | Argument    | Type     | Description                                    |
  | ----------- | -------- | ---------------------------------------------- |
  | **RETURNS** | `Config` | A copy of the config with interpolated values. |



  Deep-merge two config objects, using the current config as the default. Only
  merges sections and dictionaries and not other values like lists. Values that
  are provided in the updates are overwritten in the base config, and any new
  values or sections are added. If a config value is a variable like
  `${section.key}` (e.g. if the config was loaded with `interpolate=False)`, **the
  variable is preferred**, even if the updates provide a different value. This
  ensures that variable references aren’t destroyed by a merge.

  > :warning: Note that blocks that refer to registered functions using the `@`
  > syntax are only merged if they are referring to the same functions. Otherwise,
  > merging could easily produce invalid configs, since different functions can
  > take different arguments. If a block refers to a different function, it’s
  > overwritten.

  ```python
  from confection import Config

  base_config_str = """
  [training]
  patience = 10
  dropout = 0.2
  """
  update_config_str = """
  [training]
  dropout = 0.1
  max_epochs = 2000
  """

  base_config = Config().from_str(base_config_str)
  update_config = Config().from_str(update_config_str)
  merged = Config(base_config).merge(update_config)
  print(merged["training"])  # {'patience': 10, 'dropout': 0.1, 'max_epochs': 2000}
  ```

  | Argument    | Type                            | Description                                         |
  | ----------- | ------------------------------- | --------------------------------------------------- |
  | `overrides` | `Union[Dict[str, Any], Config]` | The updates to merge into the config.               |
  | **RETURNS** | `Config`                        | A new config instance containing the merged config. |



  | Argument          | Type   | Description                                                                                                                                                              |
  | ----------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
  | `is_interpolated` | `bool` | Whether the config values have been interpolated. Defaults to `True` and is set to `False` if a config is loaded with `interpolate=False`, e.g. using `Config.from_str`. |


pkgId: d3dd0e7ae1ee6d13eb2bb23a71741fc6b2358fa2216439d9a1079367f22cec1c
name: python-confettii
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/confettii/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confettii-0.0.2-1.src.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install confettii
  ```

  `confettii` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.


pkgId: beb96e23df371ee4dde46da00fc820184c83488cf82fc3cfa4aa55aff15ae42a
name: python-conffu
arch: src
version: 2.2.23
epoch: 0
release: 1
summary: A simple, but powerful JSON, XML and command line configuration package
url: https://gitlab.com/Jaap.vanderVelde/conffu
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conffu-2.2.23-1.src.rpm
checksum_type: sha256
description:
  A configuration package that allows you to configure your Python scripts, through a combination of JSON configuration files and command line options, with a minimum of code.



  Install the package:
  ```
  pip install conffu
  ```
  Note: on Linux, you may need to install `libffi-dev` and re-install Python if installation causes a 'No module named `_ctypes` error'. This is not specific to `conffu`, but any package requiring `_ctypes` in one of its dependencies.

  If you want to be able to read/write XML configurations as well, there is a dependency on `lxml`, install using:
  ```
  pip install conffu[xml]
  ```



  With the package installed, try running this script:
  ```
  from conffu import Config

  cfg = Config({
      '_globals': {
          'temp': 'C:/Temp'
      },
      'temp_file': '{temp}/text.txt',
      'number': 3
  })

  print(f'The number is {cfg.number}')

  cfg.save('example_config.json')
  ```

  After running that, this also works:
  ```
  from conffu import Config

  cfg = Config.from_file('example_config.json')
  print(f'The number is {cfg.number}')
  ```

  Make a change and save this script as `example.py`:
  ```
  from conffu import Config

  cfg = Config.from_file('example_config.json').update_from_arguments()
  print(f'The number is {cfg.number}')
  ```

  Then try running it like this:
  ```
  python example.py -number 7
  ```

  There's many more options, check the documentation for more examples.



  Note that `Config` allows you to do this:
  ```python
  from conffu import Config

  cfg = Config()
  cfg['test'] = 1
  print(cfg.test)  # prints 1
  cfg.test = 2
  print(cfg.test)  # prints 2
  ```
  That is, you're allowed to access configuration keys as if they were attributes on the configuration. However, if you try to access a key that happens to also be an attribute on the object, you get the attribute. This has the advantage that the feature doesn't break how objects work in Python, but the disadvantage that you'll need to access keys that have the same name as object attributes using the dictionary syntax. For example:
  ```python
  from conffu import Config

  cfg = Config()

  cfg['a'] = 1

  cfg.a = 2

  cfg.b = 3

  cfg.['b'] = 4
  print(cfg.a, cfg.b)  # prints 2 3
  print(cfg['a'], cfg['b'])  # prints 2 4
  ```
  If you don't like this behaviour, consider using the `DictConfig` class instead of `Config` - they are identical, except that the `DictConfig` does not have this behaviour and you must always access keys like `cfg['test']`, or `cfg['key.subkey']`.

  If you do like the ability to access configuration values like attributes, you should take care that your code only assigns to existing values (initialise them as 'null' when creating the config from json for example), or that you use the dictionary syntax when assigning values and you only use the attribute syntax for reading values.



  This project is licensed under the MIT license. See [LICENSE.txt](https://gitlab.com/Jaap.vanderVelde/conffu/-/blob/master/LICENSE.txt).



  See [CHANGELOG.md](https://gitlab.com/Jaap.vanderVelde/conffu/-/blob/master/CHANGELOG.md).


pkgId: 62ebdb58c3a78c3319c82edbbd4b7d0aa5cd457ca1ac2e9f3cc214f583095e2d
name: python-confget
arch: src
version: 5.1.2
epoch: 0
release: 1
summary: Parse configuration files and extract values from them
url: https://devel.ringlet.net/textproc/confget/
rpm_license: BSD-2-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confget-5.1.2-1.src.rpm
checksum_type: sha256
description:
  The `confget` library parses configuration files (currently INI-style
  files only) and allows a program to use the values defined in them.
  It provides various options for selecting the variable names and
  values to return and the configuration file sections to fetch them from.
  The `confget` library may also be used as a command-line tool with
  the same interface as the C implementation.
  The `confget` library is fully typed.


pkgId: 6251f4cb1ecd8f57a44747759ef770107b4b9d238c3d1b8a5fc6f6b31dd5dc99
name: python-confhub
arch: src
version: 0.1.0.7a0
epoch: 0
release: 1
summary: Configuration add-on to Dynaconf
url: https://pypi.org/project/confhub/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confhub-0.1.0.7a0-1.src.rpm
checksum_type: sha256
description:
  ![logo_confhub](https://github.com/morington/ConfHub/blob/main/logo.png?raw=true)

  <p align="center">
      <img alt="PyPI - Status" src="https://img.shields.io/pypi/status/confhub">
      <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/confhub">
      <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/confhub">
      <img alt="PyPI - License" src="https://img.shields.io/pypi/l/confhub">
  </p>

  *********

  <b>Сonfhub</b> is a library that relieves developers of the tedious task of creating and managing configuration files. Instead of wasting valuable time writing configurations, developers can focus on building the site's functionality.


  Based on our own experience and the experience of our colleagues, we realized that the process of working with configurations had become a real burden. We wanted something simple and effective. After several weeks of testing our MVP, we identified the strengths and weaknesses and presented the first alpha version of confhub to the world. Despite its shortcomings, it showed prospects for development.


  We currently offer a significantly improved version of confhub, which has extensive functionality. You can now dynamically generate configurations from model classes, greatly simplifying the process. In addition, the library supports developer mode, which speeds up the process of replacing configurations several times.

  *********




  *********
  **Installation and initialization**

  To get started with confhub, you need to create a project and install the Python virtual environment. Then install the confhub library into the virtual environment.

  ```bash
  pip install confhub
  ```

  After installing the library, initialize it in your project with the following command:

  ```bash
  confhub init <folder>
  ```

  Where `<folder>` is the name of the folder where the entire configuration structure will be placed. For example:

  ```bash
  confhub init configurations
  ```

  This command will create the following structure in the root of your project:

  - `.service.yml`: Contains basic settings such as paths to configs and models. The file is automatically added to `.gitignore`.
  - `configurations/`: A folder created at your request.
    - `config/`: A folder to store the generated configuration files.
    - `models.py`: A file for describing models. Initially contains an example PostgreSQL model.

  *********
  **Creating Models**

  In `models.py` you can describe your models. For example:

  ```python
  from confhub import BlockCore, field

  class PostgreSQL(BlockCore):
      __block__ = 'postgresql'

      scheme = field(str)
      host = field(str, development_mode=True)
      port = field(int, secret=True)
      user = field(str, secret=True)
      password = field(str, secret=True)
      path = field(str, secret=True)

  class ItemBlock(BlockCore):
      __block__ = 'item_block'

      item_name = field(str)

  class TestBlock(BlockCore):
      __block__ = 'test_block'

      item_block = ItemBlock()
      illuminati = field(str, filename='illuminati')
      admins = field(str)
  ```

  *********
  **Generation of configuration files**

  After creating models, you can generate configuration files using the command:

  ```bash
  confhub generate_models
  ```

  This command converts your models into configuration files with a `.yml` extension.

  Confhub generates two main files: `settings` and `.secrets`. The secrets are automatically added to `.gitignore`. You can also specify `filename` in models to create additional files in the `config` folder.

  __Do not use `secrets` and `filename` at the same time. There may be unexpected consequences at this point!__

  This documentation will help you get started with confhub and use its features to simplify the process of working with configurations in your project.

  *********
  **Filling configurations**

  Fill in the configurations, e.g:

  ```yaml
  postgresql:
    password: str; qwer
    path: str; db_confhub
    port: int; 5432
    user: str; morington
  ```

  The data type is specified before the value. Available types: `str`, `int`, `bool`, `float`. YML also supports lists, in models we prescribe a type for the value of each element in a list, and with YML we make a list:

  ```yaml
  admins:
    - str; Adam
    - str; John
    - str; Saly
  ```

  *********
  **Read configurations**

  To read configurations, use the following code:

  ```python
  import structlog
  from confhub import Confhub
  from confhub.setup_logger import LoggerReg

  logger = structlog.get_logger(__name__)

  if __name__ == '__main__':
      config = Confhub(developer_mode=True, logger_regs=[
          LoggerReg(name="", level=LoggerReg.Level.DEBUG,)
      ]).data

      logger.info("PostgreSQL", host=config.postgresql.host)
      logger.info("Admins", host=config.test.admins)
  ```

  *********
  **Logging Configuration**

  Sonfhub uses `structlog` for logging. You can configure loggers using ``LoggerReg``:

  ```python
  LoggerReg(name="", level=LoggerReg.Level.DEBUG)
  ```

  *********
  **developer_mode**

  The `developer_mode` argument is available both in the `Confhub` class and in the `.service.yml` file. The class argument takes precedence over the file.

  *********




  *********

  [Сonfhub](https://github.com/morington/confhub) is distributed under the [MIT license](https://github.com/morington/confhub/blob/main/LICENSE). This means that you are free to use, modify and distribute the library for any purpose, including commercial use.


pkgId: f650ce16e25e7e779652b458a67d2bc019b05d68a2c90523ae2c2ff944014594
name: python-confidence
arch: src
version: 0.15
epoch: 0
release: 1
summary: Simple module to load and use configuration in a clean, 'pythonic' way.
url: https://github.com/NetherlandsForensicInstitute/confidence/
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confidence-0.15-1.src.rpm
checksum_type: sha256
description:
  Confidence makes it easy to load one or multiple sources of
  configuration values and exposes them as a simple to use Python object.
  Given the following YAML file:
  ~~~~ yaml
  foo:
    bar: 42
  foo.baz: '21 is only half the answer'
  foobar: the answer is ${foo.bar}…
  ~~~~
  Use it with confidence:
  ~~~~ python

  configuration = confidence.loadf('path/to/configuration.yaml')

  value = configuration.get('foo.bar')
  value = configuration.get('foo.bar', default=42)


  function(**configuration.foo)

  value = configuration.foo.bar

  value = configuration.foo.whoopsie
  if value is NotConfigured:
      value = 42

  value = configuration.foo.whoopsie or 42

  value = configuration.foobar  # 'the answer is 42…'
  ~~~~
  Often, combining multiple sources of configuration can be useful when
  defining defaults or reading from multiple files:
  ~~~~ python
  configuration = confidence.loadf('/etc/system-wide-defaults.yaml',
                                   './local-overrides.yaml')














  configuration = confidence.load_name('app')



  configuration = confidence.load_name('app', load_order=confidence.loaders(
      
      confidence.Locality.USER, confidence.Locality.SYSTEM
  ))
  ~~~~
  While powerful, no set of convenience functions will ever satisfy
  everyone's use case. To be able to serve as wide an audience as
  possible, confidence doesn't hide away its flexible internal API.
  ~~~~ python

  app_defaults = {'foo': {'bar': 42},
                  'foo.baz': '21 is only half the answer'}

  def read_from_source(name):
      return read_values



  configuration = confidence.Configuration(app_defaults,
                                           
                                           
                                           confidence.loadf('path/to/app.yaml'),
                                           read_from_source('app'))

  run_app(configuration)
  ~~~~


pkgId: 924cde48ef84daaab4a2cdf3aa6ab33d8c8d535f9c028c3f2250a916dc7350da
name: python-confidential-ml-utils
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: Utilities for confidential machine learning
url: https://github.com/Azure/confidential-ml-utils
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confidential-ml-utils-0.9.1-1.src.rpm
checksum_type: sha256
description:
  [![python](https://github.com/Azure/confidential-ml-utils/workflows/python/badge.svg)](https://github.com/Azure/confidential-ml-utils/actions?query=workflow%3Apython)
  [![codecov](https://codecov.io/gh/Azure/confidential-ml-utils/branch/main/graph/badge.svg?token=TEWT51C5FK)](https://codecov.io/gh/Azure/confidential-ml-utils)
  [![CodeQL](https://github.com/Azure/confidential-ml-utils/workflows/CodeQL/badge.svg)](https://github.com/Azure/confidential-ml-utils/actions?query=workflow%3ACodeQL)
  [![Component Governance](https://dev.azure.com/msdata/Vienna/_apis/build/status/aml-ds/Azure.confidential-ml-utils%20Component%20Governance?branchName=main)](https://dev.azure.com/msdata/Vienna/_build/latest?definitionId=13909&branchName=main)
  [![PyPI version](https://badge.fury.io/py/confidential-ml-utils.svg)](https://badge.fury.io/py/confidential-ml-utils)
  [![Python versions](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/confidential-ml-utils)](https://pypi.org/project/confidential-ml-utils/)
  [![code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![license: MIT](https://img.shields.io/badge/License-MIT-purple.svg)](LICENSE)

  Confidential ML is the practice of training machine learning models without
  seeing the training data. It is needed in many enterprises to satisfy the
  strict compliance and privacy guarantees they provide to their customers. This
  repository contains a set of utilities for confidential ML, with a special
  emphasis on using PyTorch in
  [Azure Machine Learning pipelines](https://github.com/Azure/azureml-examples).


  **This package has been deprecated as of May 2021.** Please install `pip install shrike` and use `shrike.compliant_logging` instead. More details: https://github.com/Azure/shrike



  For more detailed examples and API reference, see the
  [docs page](https://azure.github.io/confidential-ml-utils/logging/).

  Minimal use case:

  ```python
  from confidential_ml_utils import DataCategory, enable_confidential_logging, prefix_stack_trace
  import logging


  @prefix_stack_trace(allow_list=["FileNotFoundError", "SystemExit", "TypeError"])
  def main():
      enable_confidential_logging()

      log = logging.getLogger(__name__)
      log.info("Hi there", category=DataCategory.PUBLIC)

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



  This project welcomes contributions and suggestions. Most contributions require
  you to agree to a Contributor License Agreement (CLA) declaring that you have
  the right to, and actually do, grant us the rights to use your contribution.
  For details, visit https://cla.opensource.microsoft.com.

  When you submit a pull request, a CLA bot will automatically determine whether
  you need to provide a CLA and decorate the PR appropriately (e.g., status check,
  comment). Simply follow the instructions provided by the bot. You will only need
  to do this once across all repos using our CLA.

  This project has adopted the
  [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
  For more information see the
  [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or
  contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any
  additional questions or comments.


pkgId: 866fba79c4366c9655a4915b5177e05627440c5523ceb6a2c5090919b586f23e
name: python-config
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A hierarchical, easy-to-use, powerful configuration module for Python
url: http://docs.red-dove.com/cfg/python.html
rpm_license: Copyright (C) 2004-2020 by Vinay Sajip. All Rights Reserved. See LICENSE for license.
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-0.5.1-1.src.rpm
checksum_type: sha256
description:
  This module allows a hierarchical configuration scheme with support for mappings and sequences, cross-references between one part of the configuration and another, the ability to flexibly access real Python objects without full-blown eval(), an include facility, simple expression evaluation and the ability to change, save, cascade and merge configurations. Interfaces easily with environment variables and command-line options.


pkgId: feaf71f6743991c34841ea234f06899c8bc51f8926c2e48e7c7205737cffff82
name: python-config-argument-parser
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A package to help automatically create command-line interface from configuration or code.
url: https://github.com/yuanx749/config-argument-parser
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-argument-parser-1.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/config-argument-parser.svg)](https://badge.fury.io/py/config-argument-parser)
  [![Downloads](https://static.pepy.tech/badge/config-argument-parser/month)](https://pepy.tech/project/config-argument-parser)
  [![Codacy Badge](https://app.codacy.com/project/badge/Grade/b15383188a354af684ba9d49b09cc253)](https://app.codacy.com/gh/yuanx749/config-argument-parser/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
  [![Maintainability](https://api.codeclimate.com/v1/badges/288bbabbf406afe66e37/maintainability)](https://codeclimate.com/github/yuanx749/config-argument-parser/maintainability)
  [![codecov](https://codecov.io/gh/yuanx749/config-argument-parser/branch/dev/graph/badge.svg?token=W34MFRGVMY)](https://codecov.io/gh/yuanx749/config-argument-parser)
  [![Documentation Status](https://readthedocs.org/projects/config-argument-parser/badge/?version=latest)](https://config-argument-parser.readthedocs.io/en/latest/?badge=latest)

  A package to help automatically create command-line interface from configuration or code.

  It contains three modules CAP🧢(`ConfigArgumentParser`), TAP🚰(`TypeArgumentParser`), and GAP🕳️(`GlobalArgumentParser`).

  Read the documentation [here](http://config-argument-parser.readthedocs.io/).



  Configuration files are highly readable and useful for specifying options, but sometimes they are not convenient as command-line interface. However, it requires writing a lot of code to produce a CLI. This package automates the building process, by utilizing the Python standard libraries `configparser` and `argparse`.

  The design is to minimize the changes to your original scripts, so as to facilitate maintenance.



  - Only few extra lines are needed to build a CLI from an existing script.
  - The comments are parsed as help messages. (Most libraries do not preserve the comments.)
  - Consistent format between configuration and script provides ease of use.





  If you use class to store arguments, such as the script `example.py` below.

  ```Python
  import configargparser

  class Args:
      
      a_string = "abc"
      a_float = 1.23  # inline comments are omitted
      
      
      a_boolean = False
      an_integer = 0

  args = Args()

  parser = configargparser.ConfigArgumentParser()
  parser.parse_obj(args, shorts="sfb")

  print(args.a_string)
  print(args.a_float)
  print(args.a_boolean)
  print(args.an_integer)
  ```

  In fact, only the snippet below is added to the original script. Moreover, removing this minimal modification does not affect the original script. `shorts` is optional. If provided, add short options for the first few arguments in order.

  ```Python
  import configargparser
  parser = configargparser.ConfigArgumentParser()
  parser.parse_obj(args)
  ```

  Default arguments are defined as class attributes, and parsed arguments are stored as instance attributes. The good is that auto-completion can be triggered in editors.

  Show help, `python example.py -h`:

  ```console
  $ python example.py -h
  usage: example.py [-h] [-s A_STRING] [-f A_FLOAT] [-b] [--an-integer AN_INTEGER]

  options:
    -h, --help            show this help message and exit
    -s A_STRING, --a-string A_STRING
                          Help message of the first argument. Help is optional. (default: abc)
    -f A_FLOAT, --a-float A_FLOAT
                          a_float (default: 1.23)
    -b, --a-boolean       Help can span multiple lines. This is another line. (default: False)
    --an-integer AN_INTEGER
                          an_integer (default: 0)
  ```

  Run with options, for example, `python example.py -b -f 1`:

  ```console
  $ python example.py -b -f 1
  abc
  1.0
  True
  0
  ```

  Note that the values are changed.

  For the best practice, see [Case 4](#case-4-create-cli-from-a-dataclass-object-preferred).



  If you use configuration file, create an example script `example.py`:

  ```Python
  import configargparser

  parser = configargparser.ConfigArgumentParser()
  parser.read("config.ini")
  parser.parse_args(shorts="sfb")

  print("Configs:", parser.defaults)
  print("Args:   ", parser.args)
  ```

  Create a configuration file `config.ini` in the same directory:

  ```ini
  [DEFAULT]

  a_string = 'abc'
  a_float = 1.23  # inline comments are omitted


  a_boolean = False
  an_integer = 0
  ```

  Regular run, `python example.py`:

  ```console
  $ python example.py
  Configs: {'a_string': 'abc', 'a_float': 1.23, 'a_boolean': False, 'an_integer': 0}
  Args:    {'a_string': 'abc', 'a_float': 1.23, 'a_boolean': False, 'an_integer': 0}
  ```

  Run with options, such as `python example.py -b -f 1`:

  ```console
  $ python example.py -b -f 1
  Configs: {'a_string': 'abc', 'a_float': 1.23, 'a_boolean': False, 'an_integer': 0}
  Args:    {'a_string': 'abc', 'a_float': 1.0, 'a_boolean': True, 'an_integer': 0}
  ```



  If you use global variables, define the variables at top of file as the script `example.py` below:

  ```Python


  a_string = "abc"
  a_float = 1.23  # inline comments are omitted


  a_boolean = False
  an_integer = 0


  import configargparser

  parser = configargparser.ConfigArgumentParser()
  parser.read_py("example.py")
  parser.parse_args(shorts="sfb")


  globals().update(parser.args)
  print(a_string)
  print(a_float)
  print(a_boolean)
  print(an_integer)
  ```

  Use it as in case 1. For example, `python example.py -b -f 1`:

  ```console
  $ python example.py -b -f 1
  abc
  1.0
  True
  0
  ```



  Suppose you have a script `example.py` below, which uses a `dataclass` object to store arguments:

  ```Python
  from dataclasses import dataclass

  @dataclass
  class Args:
      
      a_string: str = "abc"
      a_float: float = 1.23  # inline comments are omitted
      
      
      a_boolean: bool = False
      an_integer: int = 0

  args = Args()
  ```

  Add these lines to the script to create CLI:

  ```Python
  import configargparser
  parser = configargparser.TypeArgumentParser()
  parser.parse_obj(args, shorts="sfb")

  print(args)
  ```

  Use it as in case 1. For example, `python example.py -b -f 1` to change the values:

  ```console
  $ python example.py -b -f 1
  Args(a_string='abc', a_float=1.0, a_boolean=True, an_integer=0)
  ```



  This requires less code than case 3, but the comments are not parsed, as the script `example.py` below:

  ```Python
  a_string = "abc"
  a_float = 1.23
  a_boolean = False
  an_integer = 0

  import configargparser

  parser = configargparser.GlobalArgumentParser()
  parser.parse_globals(shorts="sfb")

  print(a_string)
  print(a_float)
  print(a_boolean)
  print(an_integer)
  ```

  Use it as in case 1. For example, `python example.py -b -f 1`:

  ```console
  $ python example.py -b -f 1
  abc
  1.0
  True
  0
  ```



  Install from PyPI:

  ```bash
  python -m pip install --upgrade pip
  pip install config-argument-parser
  ```

  Alternatively, install from source:

  ```bash
  git clone https://github.com/yuanx749/config-argument-parser.git
  cd config-argument-parser
  ```

  then install in development mode:

  ```bash
  git checkout main
  python -m pip install --upgrade pip
  pip install -e .
  ```

  or:

  ```bash
  git checkout dev
  python -m pip install --upgrade pip
  pip install -e .[dev]
  pre-commit install
  ```

  Uninstall:

  ```bash
  pip uninstall config-argument-parser
  ```



  This package uses [Semantic Versioning](https://semver.org/).


pkgId: 78d71e463330ef625a8877140ff729ccc93a69a4d6b42c8345955584b3d60add
name: python-config-binder
arch: src
version: 0.4.1
epoch: 0
release: 1
url: https://pypi.org/project/config-binder/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-binder-0.4.1-1.src.rpm
checksum_type: sha256
summary:
  Easily parse configurations across various formats (YAML, JSON, etc.) with recursive class binding, environment variables resolution and type safety.

description:
  [![downloads](https://static.pepy.tech/badge/config-binder/month)](https://pepy.tech/project/config-binder)
  [![PyPI version](https://badge.fury.io/py/config-binder.svg)](https://badge.fury.io/py/config-binder)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  [![versions](https://img.shields.io/pypi/pyversions/config-binder.svg)](https://github.com/pydantic/pydantic)

  Simple configuration parsing with recursive class binding, environment variables resolution and types safety.




  ```bash
  pip install config-binder
  ```



  ```yaml
  host: ${MYAPP_HOST:localhost}
  port: 5432
  username: admin
  password: ${MYAPP_PASSWORD}
  ```

  ```shell
  export MYAPP_PASSWORD=123
  ```

  ```python
  class MySettings:
      host: str
      port: int
      username: str
      password: str
      source_urls: List[str]


  config = ConfigBinder.load('input.yaml')
  print(f"type: {type(config).__name__}, config: host:{config.host} port:{config.port} source_urls:{config.source_urls}")



  ```

  in this case data will be returned in dict with just all the environment variables resolved
  ```python
  config = ConfigBinder.load('input.yaml')
  print(f"type: {type(config).__name__}, config: {config}")



  ```



  ```yaml
  name: MyApplication
  logging_level: INFO
  redis_config:
    host: ${MYAPP_REDIS_HOST:127.0.0.1}
    post: ${MYAPP_REDIS_PORT:6379}
    password: ${MYAPP_REDIS_PASS}
    encryption_Key: ${MYAPP_REDIS_ENCRYPTION_KEY}
  sources_configs:
    orders:
      url: some-url.com/orders
      token: ${MYAPP_ORDERS_SOURCE_TOKEN}
      retry_policy:
        max_attempts: 5
        backoff_seconds: 10
    products:
      url: another-url.com/products
      token: ${MYAPP_ORDERS_products_TOKEN}
      retry_policy:
        max_attempts: 3
        backoff_seconds: 5
  ```

  ```shell
  export MYAPP_REDIS_PASS=redis_pass
  export MYAPP_REDIS_ENCRYPTION_KEY=very_strong_key
  export MYAPP_ORDERS_SOURCE_TOKEN=orders_token
  export MYAPP_ORDERS_PRODUCTS_TOKEN=products_token
  ```

  ```python
  class RedisConfig:
      host: str
      port: int
      password: str
      encryption_key: str

  class RetryPolicy:
      max_attempts: int
      backoff_seconds: int

  class SourceConfig:
      url: str
      token: str
      retry_policy: RetryPolicy

  class AppConfig:
      name: str
      logging_level: Literal['DEBUG', 'INFO', 'ERROR']
      redis_config: RedisConfig
      sources_configs: Dict[str, SourceConfig]
  ```

  ```python
  config = ConfigBinder.load('input.yaml', AppConfig)
  ```

  input_yaml is variable with the same yaml specified above
  ```python
  config = ConfigBinder.read(ConfigType.yaml, input_yaml, AppConfig)
  ```

  input yaml is now bound to AppConfig class with env variables resolution and types validation
  ```python
  print(config.name)
  print(config.logging_level)
  print(f"type: {type(config.redis_config).__name__}, config: {str(vars(config.redis_config))}")
  print(f"type: {type(config.sources_configs['orders']).__name__}, config: {str(vars(config.sources_configs['orders']))}")
  print(f"type: {type(config.sources_configs['products']).__name__}, config: {str(vars(config.sources_configs['products']))}")






  ```


pkgId: 31157a86d911d015055a2ea7e6c737af4a50a199ff3546c96cd639f52ffc95f2
name: python-config-client
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: config client for Spring Cloud Config Server and Cloud Foundry
url: https://github.com/amenezes/config-client
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-client-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![ci](https://github.com/amenezes/config-client/actions/workflows/ci.yml/badge.svg)](https://github.com/amenezes/config-client/actions/workflows/ci.yml)
  [![codecov](https://codecov.io/gh/amenezes/config-client/branch/master/graph/badge.svg)](https://codecov.io/gh/amenezes/config-client)
  [![PyPI version](https://badge.fury.io/py/config-client.svg)](https://badge.fury.io/py/config-client)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/config-client)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  config-client for [spring cloud config server](https://spring.io/projects/spring-cloud-config) and [cloud foundry](https://www.cloudfoundry.org).



  Install and update using pip:

  ````bash
  pip install config-client
  ````



  - License: [Apache License](https://choosealicense.com/licenses/apache-2.0/)
  - Code: [https://github.com/amenezes/config-client](https://github.com/amenezes/config-client)
  - Issue tracker: [https://github.com/amenezes/config-client/issues](https://github.com/amenezes/config-client/issues)
  - Docs: [https://config-client.amenezes.net](https://config-client.amenezes.net)


pkgId: 519a6d0f726e61dd0fcf5a26164d0403ecff470e579dea19adc92e02b146c0a9
name: python-config-dir
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Configuration directory utilities
url: https://github.com/jan-g/{name}
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-dir-0.0.6-1.src.rpm
checksum_type: sha256
description:
  This supplies some very basic helper functions that manage configuration directories under the
  user's home directory.


pkgId: b4afafce6ccd54dc255462f4de0bff9accbd64349449fb1b20aeb8fc8bc6f682
name: python-config-encryptor
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: A Python package for encrypting and decrypting config files using Fernet encryption.
url: https://github.com/shabir/configencrypt
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-encryptor-1.1.0-1.src.rpm
checksum_type: sha256
description:
  `encryption` is a Python package designed to encrypt and decrypt JSON configuration files, specifically `config.json`, to enhance security for sensitive data such as API keys and database credentials.


  Most developers store their sensitive information in a JSON file which often leads to security threats. This package encrypt the configuration file and decrypt it before using it using a secret key. The secret key is stored in environment variable making it inaccessible to hackers.


  - Generate an encryption key.
  - Encrypt the entire `config.json` file.
  - Decrypt the encrypted file for runtime use.



  ```bash
  pip install config_encryptor


pkgId: 101c939773fb109b5c669cb8b7d76db68399786fe91c89108d5fd824647bce8a
name: python-config-formatter
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: An automatic formatter for .ini and .cfg configuration files
url: https://github.com/Delgan/config-formatter
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-formatter-1.2.0-1.src.rpm
checksum_type: sha256
description:
  [![Pypi version](https://img.shields.io/pypi/v/config-formatter.svg)](https://pypi.python.org/pypi/config-formatter) [![Python version](https://img.shields.io/badge/python-3.6%2B-blue.svg)](https://pypi.python.org/pypi/config-formatter) [![Build status](https://img.shields.io/github/actions/workflow/status/Delgan/config-formatter/tests.yml?branch=main)](https://github.com/Delgan/config-formatter/actions/workflows/tests.yml?query=branch:main) [![License](https://img.shields.io/github/license/delgan/config-formatter.svg)](https://github.com/Delgan/config-formatter/blob/main/LICENSE)

  An automatic formatter for .ini and .cfg configuration files.




  ```shell
  pip install config-formatter
  ```



  ```python
  from config_formatter import ConfigFormatter

  with open("config.ini", "r") as file:
      formatter = ConfigFormatter()
      formatted = formatter.prettify(file.read())
      print(formatted)
  ```



  Before:

  ```ini
  [main]        # Comments are preserved.

      
      [section1]
      key1: value1
      key2=value2  # Value assignment is normalized.


  [section2]
  lists =
   are
   indented

   comments

  multiline =    text that spans
   on several lines
        is properly aligned.
  ```

  After:

  ```ini
  [main]  # Comments are preserved.


  [section1]
  key1 = value1
  key2 = value2  # Value assignment is normalized.

  [section2]
  lists =
      are
      indented
      
      comments

  multiline = text that spans
              on several lines
              is properly aligned.
  ```


pkgId: 18a4f0bb4b37ff5f37c962f335d254c2833aadb286a48df5aa1b6ba965fa620a
name: python-config-kit
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: A convenient utility for managing configurations.
url: https://github.com/suqingdong/config_kit
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-kit-1.0.0-1.src.rpm
checksum_type: sha256
description:
  ```bash
  python3 -m pip install config-kit
  ```





  ```python
  from config_kit.core import ConfigKit


  config = ConfigKit(config_file='config.ini', section='common')


  config.username = 'admin'
  config.password = '123456'


  del config.username


  config.save()


  print(config.username)
  print(config.password)



  with ConfigKit(config_file='config.ini') as config:
      config.host = 'localhost'
      config.port = 8080
  ```



  ```bash
  config-kit --help

  config-kit -c config.ini -s common sub-command [arguments]


  config-kit set username admin
  config-kit set password 123456


  config-kit remove username


  config-kit get username
  config-kit get password
  ```



  The configuration file is in the INI format, with sections and key-value pairs. For example:

  ```ini
  [common]
  username = admin
  password = 123456

  [database]
  host = localhost
  port = 3306
  ```


pkgId: 3b0ea6c8a17c64bf0bf2f0e4669994c2c5c6631e730216c137da02787aa08876
name: python-config-library
arch: src
version: 0.18.1
epoch: 0
release: 1
summary: utility library to find and load configuration files
url: https://github.com/utility-libraries/configlib-py/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-library-0.18.1-1.src.rpm
checksum_type: sha256
description:
  utility library to find and load configuration files

  > see the [documentation](https://utility-libraries.github.io/configlib-py/) for more information

  <img style="height: 100px" src="https://github.com/utility-libraries/configlib-py/raw/main/README.assets/configlib.svg" alt="">

  <!-- TOC -->
  * [config-library](#config-library)
    * [Installation](#installation)
    * [Install Variations](#install-variations)
    * [Supported Config-Types](#supported-config-types)
    * [Usage Example](#usage-example)
      * [Basic usage](#basic-usage)
      * [Config distribution](#config-distribution)
      * [Loading specific file](#loading-specific-file)
      * [Loading from environment variables](#loading-from-environment-variables)
      * [Specify/Customise search locations](#specifycustomise-search-locations)
      * [Accessing configuration](#accessing-configuration)
    * [More in detail](#more-in-detail)
      * [Searching](#searching)
      * [Loading](#loading)
  <!-- TOC -->



  [![PyPI - Version](https://img.shields.io/pypi/v/config-library)
  ](https://pypi.org/project/config-library/)

  - `pip install config-library`
  - `pip install config-library[all]`
  - `pip install config-library[validation]`
  - `pip install config-library[dotenv]`
  - `pip install config-library[json5]`
  - `pip install config-library[toml]`
  - `pip install config-library[yaml]`



  | variation                    | information                                                                                                     |
  |------------------------------|-----------------------------------------------------------------------------------------------------------------|
  | `config-library[all]`        | adds all dependencies from the variations below                                                                 |
  | `config-library[validation]` | adds support to validate the loaded configuration against a [pydantic](https://docs.pydantic.dev/latest/) model |
  | `config-library[dotenv]`     | adds support to load `.env` files                                                                               |
  | `config-library[json5]`      | adds support to load `.json5` files                                                                             |
  | `config-library[toml]`       | adds support to load `.toml` files                                                                              |
  | `config-library[yaml]`       | adds support to load `.yaml` files                                                                              |



  | extension                | requires                              | link (for more information)                                                           |
  |--------------------------|---------------------------------------|---------------------------------------------------------------------------------------|
  | `.ini`/`.conf`/`.config` | -                                     | <https://en.wikipedia.org/wiki/INI_file>                                              |
  | `.env`                   | `config-library[dotenv]`              | <https://pypi.org/project/python-dotenv/>                                             |
  | `.json`                  | -                                     | <https://en.wikipedia.org/wiki/JSON>                                                  |
  | `.jsonc`                 | -                                     | <https://changelog.com/news/jsonc-is-a-superset-of-json-which-supports-comments-6LwR> |
  | `.json5`                 | `config-library[json5]`               | <https://json5.org/>                                                                  |
  | `.toml`                  | `config-library[toml]` or python3.11+ | <https://toml.io/>                                                                    |
  | `.yaml`/`.yml`           | `config-library[yaml]`                | <https://en.wikipedia.org/wiki/YAML>                                                  |
  | `.xml`                   | -                                     | <https://en.wikipedia.org/wiki/XML>                                                   |





  ```python
  from configlib import find_and_load

  config = find_and_load("app.conf")





  address = config.get('database', 'address')

  port = config.getint('database', 'port', fallback=5000)
  ```



  ```python
  from configlib import find_and_load, validation

  class ConfigModel(validation.BaseModel):
      database: 'DatabaseModel'

  class DatabaseModel(validation.BaseModel):
      address: validation.IPvAnyAddress
      port: validation.PositiveInt
      

  config = find_and_load("config.ext")
  config.validate(ConfigModel)
  ```



  configlib offers a global configuration instance.
  This can help you avoid the hassle of passing the configuration instance to different functions.

  `main.py`
  ```python
  from configlib import config, find_and_load
  from sub import function

  config.update(find_and_load("config.ext"))

  function()
  ```

  `sub.py`
  ```python
  import logging
  from configlib import config

  def function():
      if config.getbool("debug"):
          logging.debug("Some information")
      ...
  ```



  ```python
  import configlib

  config = configlib.load("./app.conf")
  ```



  ```python
  import configlib


  config = configlib.load_environ("APP")
  ```



  ```python
  from configlib.finder import find, places

  config_file = find(
      "project-name.conf",  # variant of the config-file to search for is 'app.conf'
      "project-name/settings.conf",  # alternate variant name to search for
      "{project-name,variant-name}/settings.conf",  # write variants
      places=[places.local, places.user_conf],  # search in main.py folder and ~/.config/
  )
  ```



  In the end you get an instance of the `ConfigInterface` with useful get-methods

  ```python
  from configlib import ConfigInterface
  config: ConfigInterface
  config.get("database", "address", fallback="localhost")  # gets the value raw as parsed
  config.getstr("database", "address", fallback="localhost")  # gets as string
  config.getint("database", "port", fallback=5432)  # gets as integer
  config.getfloat("database", "timeout", fallback=10.0)  # gets as floating point number
  config.getbool("database", "delayed-connect", fallback=False)  # gets as boolean
  config.getlist("database", "tables", fallback=[], cast=str)  # gets as list
  config.gettuple("database", "tables", fallback=[], cast=str)  # gets as tuple
  config.getsplit("database", "tables")  # clean split by `,` or `;`
  config.getpath("database", "client-paths", fallback="./")  # returns as pathlib.Path
  config.getpaths("database", "client-paths", fallback=[], as_path=True)  # split by os.path.altsep (commonly `:`)
  config.getshlex("database", "additional-params", fallback=[])  # split like the command-line
  config.getinterface("database")  # gets a new ConfigInterface for sub-option
  config.gettype("database", "timeout")  # gets the type/class (e.g. int | float)
  ```



  For the more detailed description we will use this code example.

  ```python
  import configlib
  config = configlib.find_and_load('project.conf', 'project/app.conf')
  ```



  The `configlib.finder` subpackage has a few predefined paths it attempts to search in.
  In each of these places it attempts to find one of the passed variants (`project.conf`, `project/app.conf`).
  If it can't find one it goes to the next place and repeats this process.

  system file-structure
  ```
  /
  ├─ etc/
  ├─ home/user/
  │  ├─ path/to/repo/
  │  │  ├─ src/code/
  │  │  │  ├─ main.py
  │  ├─ .config/
  ```
  places where `config-library` searches for the config-file
  - `/home/user/path/to/repo/src/code/project.conf` (next to the started script)
  - `/home/user/path/to/repo/src/code/project/app.conf`
  - `/home/user/path/to/repo/project.conf`  (next to .git/)
  - `/home/user/path/to/repo/project/app.conf`
  - `/home/user/.config/project.conf`  (~/.config/)
  - `/home/user/.config/project/app.conf`
  - `/home/user/project.conf`  (~/)
  - `/home/user/project/app.conf`
  - `/etc/project.conf`  (/etc/)
  - `/etc/project/app.conf`



  After the search returns a filepath it is passed to the `load()` function.
  This function analyzes the file-extension and loads it with the correct loader.

  > The loader can be extended via the `configlib.loader.register_loader` decorator.
  > Important is that it should return native types to be compatible with the `ConfigInterface`
  > ```python
  > from configlib.loader import register_loader
  >
  > @register_loader("env", "environ")  # support for *.env or *.environ files
  > def custom_loader(fp) -> dict:
  >     ...
  > ```


pkgId: 52204552fab1fae3e8255cfd722327541c1e5c485d46ae607c7ba9399d089c5a
name: python-config-mgmt-server
arch: src
version: 1.0.18
epoch: 0
release: 1
summary: Suncoast Systems Core Router Config Mgmt Server
url: https://github.com/pypa/sampleproject
rpm_license: This project is only for Dotcom Row services, no other use is allowed or even possible!
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-mgmt-server-1.0.18-1.src.rpm
checksum_type: sha256
description:
  Template for my python (version 3) projects with vscode



  * Init space (with bash) : `source _initial_setup.sh`
  * Create virtualenv virtualenv : `virtualenv -p python3 .venv`
  * Load/Source virtuelenv : `source .venv/bin/activate`
  * Install requirements : `pip install -r requirements.txt`
  * Install test requirements : `pip install -r tests/requirements.txt`
  * Launch unitary tests : `python3 -m pytest tests -v`
  * Launch coverage tests : `python3 -m pytest --cov-report xml:cov.xml --cov my_module tests -v`



  * Format python code with **autopep8**. Others here : <https://code.visualstudio.com/docs/python/editing#_formatting>
  * Static analysis with **pylint**. Others here : <https://code.visualstudio.com/docs/python/linting>
  * Unitary tests with **pytest**. Others here : <https://code.visualstudio.com/docs/python/unit-testing>

  * Available options for python with vscode available here : <<https://code.visualstudio.com/docs/python/settings-referenc>e>



  Usefull extensions :

  * Python (<https://marketplace.visualstudio.com/items?itemName=ms-python.python)>
  * Coverage Gutters (<https://marketplace.visualstudio.com/items?itemName=ryanluker.vscode-coverage-gutters)>
  * Better Comments (<https://marketplace.visualstudio.com/items?itemName=aaron-bond.better-comments)>
  * indent-rainbow (<https://marketplace.visualstudio.com/items?itemName=oderwat.indent-rainbow)>
  * Trailing Spaces (<https://marketplace.visualstudio.com/items?itemName=shardulm94.trailing-spaces)>
  * Rainbow Brackets (<https://marketplace.visualstudio.com/items?itemName=2gua.rainbow-brackets)>
  * Git Lens (<https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens)>
  * EditorConfig (<https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig>)
  * Git Project Manager (<https://marketplace.visualstudio.com/items?itemName=felipecaputo.git-project-manager>)



  * Unitary tests with code coverage



  * Clone this repo as a new vscode workspace
  * Create virtualenv and install requirements (see [Commands](Commands))
  * Rename folder *my_module* with your module name
  * In *.vscode/tasks.json*, replace *my_module* by your module name
  * Fix module import in *main.py* and *./tests/test_my_module.yy* if needed
  * Try everything by:
    * Launching unitary tests
    * Launching task
    * Launching configurations
    * Debugging with a breakpoint



  * <https://github.com/dwd-umd/python-project-template>


pkgId: 7eaa45975ae5cc9aaec8958c1644345326b9177c8394fbf700a2d1cfa5f8d191
name: python-config-parser
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Configuration library wrappers
url: https://github.com/mattpaletta/configs
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-parser-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Simplified runtime configs for Python

  [![Build Status](https://travis-ci.com/mattpaletta/configparser.svg?branch=master)](https://travis-ci.com/mattpaletta/configparser)


  Examples can be seen in `examples/`

  To use configparser:
  `pip install git+git://github.com/mattpaletta/configparser.git`


  You can call it in your program using:
  ```
  p = Parser(argparse_file = "argparse.yml").get()
  ```

  The paramters are:
  - argparse_file: your argparse definitions, layed out in JSON or yaml files.
  - config_file_key: a string to the optional config file key in the argparse file to use to allow the user to run custom runtime config files.
  - environ_key_mapping: a dictionary containing the config file key to the environment key (bash environment)

  The arguments will be applied on top of each other in the following order:

  1. defaults
  2. config files (in the order defined)
  3. environment variables
  4. runtime

  This order cannot be modified at this time.


pkgId: e6a83ac3f19e302758452b007eed0224c227c212bae96108c259f3ce8f0192d5
name: python-config-path
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: config_path is a library to work with paths to config folders and files in an OS independent way
url: https://github.com/barry-scott/config-path
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-path-1.0.5-1.src.rpm
checksum_type: sha256
description:
  Python library to work out which path to use for configuration folders
  and files in an operating system independent way.

  Each operating system has particular conventions for where an application is expected
  to stores it configuration. The information provided to ConfigPath is used
  to figure out an appropiate file path or folder path for the application's
  configuration data.

  Supports Windows, macOS and most unix systems using the 'XDG Base Directory Specification'.

  ~~~~
  ConfigPath( appname, vendor, filetype )
  ~~~~

  The `vendor` should be the domain name of the application provider.
  The `appname` is the name the application is know by.
  The `filetype` is the use as the suffix for a config file.
  Typical filetypes are .json, .ini, .xml, etc.

  For example the widget application from example.com that uses a JSON
  configuration file:

  ~~~~
  from config_path import ConfigPath
  conf_path = ConfigPath( 'widget', 'example.com', '.json' )
  ~~~~



  ~~~~
  path = conf_path.saveFilePath( mkdir=False )
  ~~~~

  `saveFilePath` returns the path where the configuation file should be written to.

  When `mkdir` is True the parent directory of the path will be created if it does not exist.

  Note: the path returned from `saveFilePath()` can be different from the
  path returned by `readFilePath()`.

  ~~~~
  path = conf_path.readFilePath()
  if path is not None:
      
  ~~~~

  `readFilePath` returns the path to an existing configuration file, otherwise None
  is returned. Typcially an application will use its default configuration if there
  is no existing configuration file.

  Note: the path returned from `readFilePath()` can be different from the
  path returned by `saveFilePath()`.

  For example readFilePath may return a system wide default config until the appliaction
  saves a users specific configuration file.



  ~~~~
  path = conf_path.saveFolderPath( mkdir=False )
  ~~~~

  `saveFolderPath` returns the path to the folder that the application should
  save its configuration files into. The naming of the file is left to the application logic.

  The path is a `pathlib.Path()` object for python 3 and a string for python 2

  When `mkdir` is True the parent directory of the path will be created
  if it does not exist.

  Note: the path returned from `saveFolderPath()` can be different from the
  path returned by `readFolderPath()`.

  ~~~~
  path = conf_path.readFolderPath( mkdir=False )
  ~~~~

  `readFolderPath` returns the path to the folder that the application should use
  to read its configuration files.

  The path is a `pathlib.Path()` object for python 3 and a string for python 2

  When `mkdir` is True the parent directory of the path will be created
  if it does not exist.

  Note: the path returned from `readFolderPath()` can be different from the
  path returned by `saveFolderPath()`.



  On macOS configuration files are called preferences. They are expected to be stored in the
  ~/Library/Preferences folder using a file name that uses a reversed domain name.

  For a file that will be `{reversed-vendor}.{appname}{filetype}` using the above example:
  `com.example.widget.json`.

  When a folder is required the folder will be  `{reversed-vendor}.{appname}`.
  For example: `com.example.widget`.



  On Windows configuration files are stored in a folder that is return from a WIN32 API call.
  Exactly which folder is used has changed over time between Windows versions and maybe
  language dependent.

  config_path uses the convention of combining the `appname` and `vendor` to create a
  path that is expected to be unique.

  For a file that will be `{reversed-vendor}.{appname}{filetype}` using the above example:
  `com.example.widget.json`.

  When a folder is required the folder will be  `{reversed-vendor}.{appname}`.
  For example: `com.example.widget`.



  For all systems that are not macOS or Windows config-path follows
  the 'XDG Base Directory Specification' for configuration data.

  XDG allows for system configuration and user configuration files.
  The default user configuration folder is `~/.config`.
  The default system configuration folder is `/etc/xdg`.

  For a file that will be `{reversed-vendor}.{appname}{filetype}` using the above example:
  `com.example.widget.json`.

  When a folder is required the folder will be  `{reversed-vendor}.{appname}`.
  For example: `com.example.widget`.


pkgId: f635a970c0c9fc5b36d695b3154d8404eba2fb8183aeade48f99df5de1455ebc
name: python-config-resolver
arch: src
version: 5.1.0
epoch: 0
release: 1
summary: A small package to automatically find a configuration file.
url: https://github.com/exhuma/config_resolver
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-resolver-5.1.0-1.src.rpm
checksum_type: sha256
description:
  Full Documentation
      https://config-resolver.readthedocs.org/en/latest/
  Repository
      https://github.com/exhuma/config_resolver
  PyPI
      https://pypi.python.org/pypi/config_resolver
  ``config_resolver`` provides a simple, yet flexible way to provide
  configuration to your applications. It follows the `XDG Base Dir Spec
  <https://standards.freedesktop.org/basedir-spec/0.8/>`_ (This instance is
  based on 0.8 of this spec) for config file locations, and adds additional ways
  to override config locations. The aims of this package are:
  * Provide a simple API
  * Follow well-known standards for config-file locations
  * Be as close to pure-Python as possible
  * Be framework agnostic
  * Allow custom configutaion types (``.ini`` and ``.json`` support is shipped by
    default)
  * Allow to provide system-wide defaults but allow overriding of values for more
    specific environments. These are (in increasing order of specificity):
    1. System-wide configuration (potentially requiring root-access to modify)
    2. User-level configuration (for all instances running as that user)
    3. Current Working Directory configuration (for a running instance)
    4. Per-Instance configuration


pkgId: c20480d1c0d761cbf18472e51da2db3d06e88d284762a09e5778480529ff3652
name: python-config-segregate
arch: src
version: 0.1.0
epoch: 0
release: 1
url: https://github.com/ross-tsenov/config-segregate
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config-segregate-0.1.0-1.src.rpm
checksum_type: sha256
summary:
  Config-Segregate simplifies Config management by enabling efficient, customizable configurations through classifier-based loading.

description:
  [![Build Status](https://github.com/ross-tsenov/config-segregate/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/ross-tsenov/config-segregate/actions/workflows/ci.yml)
  [![PyPI Version](https://badge.fury.io/py/config-segregate.svg)](https://pypi.python.org/pypi/config-segregate)


pkgId: 42ad1c8dfebd1676dd9b18a78e0bfd41fa12d3a77e89716ad03791f5452f77a2
name: python-config2class
arch: src
version: 0.2.3
epoch: 0
release: 1
url: https://pypi.org/project/config2class/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config2class-0.2.3-1.src.rpm
checksum_type: sha256
summary:
  Config2Code simplifies configuration management by automatically generating Python dataclasses from YAML or JSON files. This tool enhances code readability, maintainability, and type safety, saving you time and effort.

description:
  ![PyPI - Version](https://img.shields.io/pypi/v/config2class) ![PyPI - License](https://img.shields.io/pypi/l/config2class) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/config2class) [![Coverage Status](https://coveralls.io/repos/github/RobinU434/Config2Class/badge.svg)](https://coveralls.io/github/RobinU434/Config2Class) ![PyPI - Downloads](https://img.shields.io/pypi/dm/config2class)




  Config2Code is a Python tool designed to streamline the process of converting configuration files (YAML or JSON or TOML) into Python dataclasses. By automating the generation of dataclasses, you can improve code readability, maintainability, and type safety.



  You can install Config2Code using pip:

  ```bash
  pip install config2code
  ```





  1. **Prepare your configuration file:**
     Create a YAML or JSON file containing your configuration data. Here's an example YAML file:

     ```yaml
     DatabaseConfig:
       host: localhost
       port: 5432
       user: myuser
       password: mypassword
       secret: {{database.password}}
     ```

  2. **Run the tool:**
     Use the `config2code` command-line interface to convert the configuration file:

     ```bash
     config2code to-code --input input.yaml --output output.py
     ```

     This will generate a Python file `output.py` containing a dataclass representing the configuration:

     ```python
     from dataclasses import dataclass

     @dataclass
     class DatabaseConfig:
         host: str
         port: int
         user: str
         password: str
         secret: str
     ```



  Sometimes you put redundant data in your config file because it is more convenient to only move parts of the config further down the road. Examples could be a machine learning pipeline where you have parameters for your dataset and model which can have redundant values. To counter the problem of always changing multiple values at once in your config we introduce **placeholder**.  A placeholder is a path packed into a token `{{<path-in-config>}}` which points to a value you want to insert automatically into your loaded config file. This path starts always at the yaml root and ends at the value to insert.

  ```yaml
     pipeline:
        dataset:
           x_dim: 42
           y_dim: 5
           batch_size: 128
           shuffle: True
        model:
           input_dim: {{pipeline.dataset.x_dim}}
           output_dim: {{pipeline.dataset.y_dim}}
           activation_func: ReLU
           learning_rate: 0.0001
  ```

  In the case of not having a yaml root you can still use the placeholder with a leading `.` inside the token.


  ```yaml
     dataset:
        x_dim: 42
        y_dim: 5
        batch_size: 128
        shuffle: True
     model:
        input_dim: {{.dataset.x_dim}}
        output_dim: {{.dataset.y_dim}}
        activation_func: ReLU
        learning_rate: 0.0001
  ```




  This service monitors the requested configuration file. If the services detects changes in the file it will automatically write those changes into the specified `output.py`.
  You can start the service for example with:

  ```bash
  config2code service-start --input input.yaml --output output.py
  ```

  To stop it you can stop all with

  ```bash
  config2code stop-all
  ```



  After you created your python config you can easily use as follows:
  ```python
  from output import DatabaseConfig

  config = DatabaseConfig.from_file("input.yaml")

  config.host
  ```



  * **Supports YAML, JSON and TOML:** Easily convert both formats.
  * **Automatic dataclass generation:** Generates well-structured dataclasses.
  * **Nested configuration support:** Handles nested structures in your configuration files.
  * **Type inference:** Infers types for fields based on their values.
  * **Placeholder:** Choose which values in your config file are dependent on others



  * **Complex data structures:** For more complex data structures, consider using custom type hints or additional configuration options.
  * **Error handling:** The tool includes basic error handling for file loading and parsing.
  * **Future enhancements:** We plan to add support for additional file formats, advanced type inference, and more customization options.



  * [ ] add VS Code extension (create new file on config file save)
  * [ ] add renaming feature from config to code (renaming a field in the config file should resolve in renaming a field in the code
  * [ ] add token in config yaml to overwrite field automatically with a dependency on another field (something like `<c2c/2*:dep.config.a/c2c>`) or costum functions `<c2c/module.submodule:func(some_value)/c2c>`



  We welcome contributions to improve Config2Code. Feel free to fork the repository, make changes, and submit a pull request.

  **License**

  This project is licensed under the MIT License.


pkgId: 8b915ddf9a6aa251e3762d515125c9ca434a4995340052fbb5e5432a32b167d6
name: python-config2py
arch: src
version: 0.1.36
epoch: 0
release: 1
summary: Simplified reading and writing configurations from various sources and formats
url: https://github.com/i2mint/config2py
rpm_license: apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config2py-0.1.36-1.src.rpm
checksum_type: sha256
description:
  Simplified reading and writing configurations from various sources and formats.

  To install:	```pip install config2py```

  [Documentation](https://i2mint.github.io/config2py/)





  ```python
  from config2py import config_getter
  ```

  Let's start with an extremely convenient, no questions asked, object.
  Later, we'll look under the hood to show the many tools that support it, and can be shaped to fit many desired behaviors.

  What `config2py.config_getter(key)` will do is:
  * search for `key` in your environment variables, and if not found...
  * ... search for it in a default local directory (more on that later), and if not found...
  * ... ask the user to enter the value that key should have, and then put it in the local directory mentioned above.

  <img width="341" alt="image" src="https://github.com/i2mint/config2py/assets/1906276/09f287a8-05f9-4590-8664-10feda9ad617">

  _Note: The "... ask the user to enter the value..." will be activated only when in an interactive environment (python console, jupyter notebook, etc.), as decided by the `config2py.is_repl()` function_

  ```python
  config_getter('HOME')  # if you are using Linux/MacOS

  ```

      '/Users/thorwhalen'


  Now, normally all systems come with a `HOME` environment variable (or a `USERPROFILE` on windows), so the above should always work fine.
  But see what happens if you ask for a key that is not an environment variable:


  ```python
  my_config_val = config_getter('_TEST_NON_EXISTING_KEY_')  # triggers a user input dialog

  ```


  ```python
  my_config_val
  ```

      'my config value'



  But if I do that again (even on a different day, somewhere else (on my same computer), in a different session), it will get me the value I entered in the user input dialog.


  ```python
  my_config_val = config_getter('_TEST_NON_EXISTING_KEY_')  # does not trigger input dialog
  my_config_val
  ```

      'my config value'



  And of course, we give you a means to delete that value, since `config_getter` has a `local_configs` mapping (think `dict`) to the local files where it has been stored.
  You can do all the usual stuff you do with a `dict` (except the effects will be on local files),
  like list the keys (with `list(.)`), get values for a key (with `.[key]`), ask for the number of keys (`len(.)`), and, well, delete stuff:


  ```python
  if '_TEST_NON_EXISTING_KEY_' in config_getter.configs:
      del config_getter.configs['_TEST_NON_EXISTING_KEY_']
  ```

  This tool allows you to:
  * not have to set up any special configs stuff (unless you want/need to)
  * enables you to share your notebooks (CLIs etc.) with others without having to polute the code with configs-setup gunk...
  * ... including when you put local file/folder paths (or worse, secrets) in your notebook or code, which others then have to edit (instead, here, just enter a probably-unique name for the needed resource, then enter your filepath in the user input dialog instead)

  This is very convenient situation where user input (via things like `__builtins__.input` or `getpass.getpass` etc) is available. But **you should not use this to manage configurations/resources anywhere were there's not a user to see and respond to the builtin user input dialog**

  Don't fret though, this `config_getter` is just our no-BS entry point to much more.
  Let's have a slight look under its hood to see what else we can do with it.

  And of course, if you're that type, you can already have a look at [the documentation](https://i2mint.github.io/config2py/)




  If you look up for the definition of the `config_getter` function you imported above, you'll find this: `config_getter = simple_config_getter()`.
  That is, it was created by `simple_config_getter` with its default arguments.
  Let's have a look at what these are.

  In fact, `simple_config_getter` is a function to make configuration getters that ressemble the one we've seen above:

  <img width="341" alt="image" src="https://github.com/i2mint/config2py/assets/1906276/09f287a8-05f9-4590-8664-10feda9ad617">

  But where you can control what the central store (by default "Local App Data Files" store) is, and whether to first search in environment variables or not, and whether to ask the user for the value, if not found before, or not.

  ```python
  from config2py import simple_config_getter, get_configs_local_store
  from i2 import Sig

  print(*str(Sig(simple_config_getter)).split(','), sep='\n')
  ```

      (configs_src: str = '.../.config/config2py/configs'
      *
      first_look_in_env_vars: bool = True
      ask_user_if_key_not_found: bool = None
      config_store_factory: Callable = <function get_configs_local_store at 0x10a457370>)

  `first_look_in_env_vars` specifies whether to look into environment variables first, or not.

  `ask_user_if_key_not_found` specifies whether to ask the user if a configuration key is not found. The default is `None`, which will result in checking if you're running in an interactive environment or not.
  When you use `config2py` in production though, you should definitely specify `ask_user_if_key_not_found=False` to make that choice explicit.

  The `configs_src` default is automatically set to be the `config2py/configs` folder of your systems's "App Data" folder (also configurable via a `CONFIG2PY_APP_DATA_FOLDER` environment variable).

  Your central store will be `config_store_factory(configs_src)`, and since you can also specify `config_store_factory`, you have total control over the store.

  The default `config_store_factory` is `get_configs_local_store` which will give you a locally persisted store where if `configs_src`:
  * is a directory, it's assumed to be a folder of text files.
  * is a file, it's assumed to be an ini or cfg file.
  * is a string, it's assumed to be an app name, from which to create a config folder for with the default method




  If you check out the code for `simple_config_getter`, you'll find that all it it is simply setting the `sources` argument for the `get_config` function.
  Something more or less like:

  ```python
  configs = config_store_factory(configs_src)
  source = [
      os.environ,  # search in environment variables first
      configs,  # then search in configs
      user_gettable(configs)  # if not found, ask the user and store in
  ]
  config_getter = get_config(sources=source)
  ```

  So you see that you can easily define your own sources for configs, and in what order they should be searched. If you don't want that "ask the user for the value" thing, you can just remove the `user_gettable(local_configs)` part. If you wanted instead to add a place to look before the environment variables -- say, you want to look in to local variables of the scope the config getter is **defined** (not called), you can stick `locals()` in front of the `os.environ`.

  So you see that you can easily define your own sources for configs, and in what order they should be searched. If you don't want that "ask the user for the value" thing, you can just remove the `user_gettable(local_configs)` part. If you wanted instead to add a place to look before the environment variables -- say, you want to look in to local variables of the scope the config getter is **defined** (not called), you can stick `locals()` in front of the `os.environ`.

  Let's work through a custom-made `config_getter`.

  ```python
  from config2py import get_config, user_gettable
  from dol import TextFiles
  import os

  my_configs = TextFiles('~/.my_configs/')  # Note, to run this, you'd need to have such a directory!

  config_getter = get_config(sources=[locals(), os.environ, my_configs, user_gettable(my_configs)])
  ```

  Now let's see what happens when we do:

  ```python
  config_getter('SOME_CONFIG_KEY')
  ```

  Well, it will first look in `locals()`, which is a dictionary containing local variables
  where the `config_getter` was **defined** (careful -- not called!!).
  This is desirable sometimes when you define your `config_getter` in a module that has other python variables you'd like to use.

  Assuming it doesn't find such a key in `locals()` it goes on to try to find it in
  `os.environ`, which is a dict containing system environment variables.

  Assuming it doesn't find it there either (that is, doesn't find a file with that name in
  the directory `~/.my_configs/`), it will prompt the user to enter the value of that key.
  The function finally returns with the value that the user entered.

  But there's more!

  Now look at what's in `my_configs`!
  If you've used `TextFiles`, look in the folder to see that there's a new file.
  Either way, if you do:

  ```python
  my_configs['SOME_CONFIG_KEY']
  ```

  You'll now see the value the user entered.

  This means what? This means that the next time you try to get the config:

  ```python
  config_getter('SOME_CONFIG_KEY')
  ```

  It will return the value that the user entered last time, without prompting the
  user again.




  * `get_config`: Get a config value from a list of sources. See more below.
  * `user_gettable`: Create a ``GettableContainer`` that asks the user for a value, optionally saving it.
  * `ask_user_for_input`: Ask the user for input, optionally masking, validating and transforming the input.
  * `get_app_data_folder`: Returns the full path of a directory suitable for storing application-specific data for a given app name.
  * `get_configs_local_store`: Get a local store (mapping interface of local files) of configs for a given app or package name
  * `configs`: A default store instance for configs, defaulting to a local store under a default configuration local directory.



  Get a config value from a list of sources.

  This function acts as a mini-framework to construct config accessors including defining
  multiple sources of where to find these configs,

  A source can be a function or a ``GettableContainer``.
  (A ``GettableContainer`` is anything that can be indexed with brackets: ``obj[k]``,
  like ``dict``, ``list``, ``str``, etc..).

  Let's take two sources: a ``dict`` and a ``Callable``.

      >>> def func(k):
      ...     if k == 'foo':
      ...         return 'quux'
      ...     elif k == 'green':
      ...         return 'eggs'
      ...     else:
      ...         raise RuntimeError(f"I don't handle that: {k}")
      >>> dict_ = {'foo': 'bar', 'baz': 'qux'}
      >>> sources = [func, dict_]


  See that ``get_config`` go through the sources in the order they were listed,
  and returns the first value it finds (or manages to compute) for the key:

  ``get_config`` finds ``'foo'`` in the very first source (``func``):

      >>> get_config('foo', sources)
      'quux'

  But ``baz`` makes ``func`` raise an error, so it goes to the next source: ``dict_``.
  There, it finds ``'baz'`` and returns its value:

      >>> get_config('baz', sources)
      'qux'

  On the other hand, no one manages to find a config value for ``'no_a_key'``, so
  ``get_config`` raises an error:

      >>> get_config('no_a_key', sources)
      Traceback (most recent call last):
      ...
      config2py.errors.ConfigNotFound: Could not find config for key: no_a_key

  But if you provide a default value, it will return that instead:

      >>> get_config('no_a_key', sources, default='default')
      'default'

  You can also provide a function that will be called on the value before it is
  returned. This is useful if you want to do some post-processing on the value,
  or if you want to make sure that the value is of a certain type:

  This "search the next source if the previous one fails" behavior may not be what
  you want in some situations, since you'd be hiding some errors that you might
  want to be aware of. This is why allow you to specify what exceptions should
  actually be considered as "config not found" exceptions, through the
  ``config_not_found_exceptions`` argument, which defaults to ``Exception``.

  Further, your sources may return a value, but not one that you consider valid:
  For example, a sentinel like ``None``. In this case you may want the search to
  continue. This is what the ``val_is_valid`` argument is for. It is a function
  that takes a value and returns a boolean. If it returns ``False``, the search
  will continue. If it returns ``True``, the search will stop and the value will
  be returned.

  Finally, we have ``egress : Callable[[KT, TT], VT]``.
  This is a function that takes a key and a value, and
  returns a value. It is called after the value has been found, and its return
  value is the one that is returned by ``get_config``. This is useful if you want
  to do some post-processing on the value, or before you return the value, or if you
  want to do some caching.

      >>> config_store = dict()
      >>> def store_before_returning(k, v):
      ...    config_store[k] = v
      ...    return v
      >>> get_config('foo', sources, egress=store_before_returning)
      'quux'
      >>> config_store
      {'foo': 'quux'}

      Note that a source can be a callable or a ``GettableContainer`` (most of the
      time, a ``Mapping`` (e.g. ``dict``)).
      Here, you should be compelled to use the resources of ``dol``
      (https://pypi.org/project/dol/) which will allow you to make ``Mapping``s for all
      sorts of data sources.

  For more info, see: https://github.com/i2mint/config2py/issues/4






  So, what's that `user_gettable`?

  It's a way for you to specify that the system should ask the user for a key, and optionally save it somewhere, plus many other parameters (like what to ask the user, etc.)


  ```python
  from config2py.base import user_gettable

  s = user_gettable()
  s['SOME_KEY']





  d = dict(some='store')
  s = user_gettable(save_to=d)
  s['SOME_KEY']
  ```

  More on that another day...


  ```python

  ```


pkgId: d3ca640bc118c01c243557abef3694d15016b191fb2019aa01a55dda9fee54b3
name: python-config42
arch: src
version: 0.4.4
epoch: 0
release: 1
url: https://github.com/yurilaaziz/config42
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config42-0.4.4-1.src.rpm
checksum_type: sha256
summary:
  Configuration manager for cloud native application, support configuration  stored in memory, in files, in databases

description:
  [![Latest version on](https://badge.fury.io/py/config42.svg)](https://badge.fury.io/py/config42)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/config42.svg)](https://pypi.org/project/config42/)
  [![Travis Pipelines build status](https://img.shields.io/travis/com/yurilaaziz/config42.svg)](https://travis-ci.com/yurilaaziz/config42/)
  [![codecov](https://codecov.io/gh/yurilaaziz/config42/branch/master/graph/badge.svg)](https://codecov.io/gh/yurilaaziz/config42)


  Config42  is a complete configuration reader and manager. It aims to read the configuration from different sources: a memory Dict object, an external file ( YAML, JSON, INI, PYTHON Object ), an SQL database (Postgres, MySQL, Oracle)
  alternatively, Key-value data store ( Etcd )

  It is designed to be extensible. Different handlers could support another data store.
  All PR are welcome.



  * [Easy configuration management with config42 for Python applications](https://medium.com/@asker_amine/easy-configuration-management-with-config42-for-python-applications-8e90bf4c6450)



  **From sources:**  (Bleeding edge)

  `pip install git+https://github.com/yurilaaziz/config42`

  **From PyPi:** (Stable)

  `pip install config42`


  Config42 abstract loading configuration complexity. Let config42 manage your configuration for you.


  Most of the containerised applications change behaviour from environment variables to change their behaviour. config42 handle it easily.

  Here a working sample [examples/docker](examples/docker)

  ```python
  from config42 import ConfigManager
  env_config = ConfigManager(prefix="MYAPP")

  print("username : {}".format(env_config.get('username')))
  print("nested key  : {}".format(env_config.get('secret.one')))
  ```

  Export variables to system environment
  ```bash
  export MYAPP_USERNAME=yuri
  export MYAPP_SECRET_ONE=password
  python app.py
  ```

  Export variables to process environment

  ```bash
  MYAPP_USERNAME=yuri2 python app.py
  ```

  Once you build you docker image, you may run the application by export variables into the container environment
  ```bash
  docker run  -e MYAPP_USERNAME=yuri -e MYAPP_SECRET_ONE=secret testconfig42:latest
  ```



  To load configuration from Etcd data store, you need to specify the *keyspace* where the configuration is located, Etcd host(s) and port(s).

  ```python
  from config42 import ConfigManager
  from config42.handlers import Etcd

  config = ConfigManager(handler=Etcd, keyspace='/config')




  ```
  Note : Etcd handler use [python-etcd](https://github.com/jplana/python-etcd) client
  All args after keyspace are passed to Etcd.Client class.



  ```python
  from pprint import pprint
  from config42 import ConfigManager
  from config42.handlers import FileHandler


  config = ConfigManager(handler=FileHandler, path='files/config1.yml')








  CONFIG = config.as_dict()

  print("Configuration has been loaded")
  pprint(CONFIG)


  print("application_name : {}".format(config.get('application_name')))
  print("nested key : {}".format(config.get('nested.nestedkey.key2')))


  print("user : {}".format(config.as_dict()['user']))


  print("application_name : {}".format(CONFIG['application_name']))
  print("nested key : {}".format(CONFIG['nested']['nestedkey']['key2']))
  ````



  ```python
  from config42 import ConfigManager
  from config42.handlers.argparse import Argparse

  schema = [
      dict(key="user", description="username"),
      dict(key="verbosity", description="verbosity level", choices=["debug", "info"]),

  ]
  config = ConfigManager(handler=Argparse, schema=schema)
  ```
  Please take a look to the [example using Argparse's handler](examples/cmdline.py)


  Below is a real use from Instabot-Py project that uses this library as a configuration manager.

  config42 handles 4 sources of configuration data in order of priority:

  * Default configuration from Dict Object
  * Environment variables prefixed by INSTABOT
  * Local file where value located in config.file (INSTABOT_CONFIG_FILE)
  * Etcd data-store

  ref : [https://github.com/instabot-py/instabot.py](https://github.com/instabot-py/instabot.py)

  ```python
  import logging.config
  import os

  from config42 import ConfigManager

  from instabot_py.default_config import DEFAULT_CONFIG

  env_config = ConfigManager(prefix="INSTABOT")
  logging.basicConfig(level=logging.DEBUG if env_config.get("debug") else logging.INFO)
  LOGGER = logging.getLogger(__name__)
  config = ConfigManager()
  config.set_many(DEFAULT_CONFIG)

  config.set_many(env_config.as_dict())
  config_file = config.get("config.file")
  config_etcd = config.get("config.etcd")

  if config_file:
      if config_file.startswith("/"):
          config_path = config_file
      else:
          cwd = os.getcwd()
          config_path = cwd + "/" + config_file
      config.set_many(ConfigManager(path=config_path.replace('//', '/')).as_dict())
      LOGGER.info("Setting configuration from {} : OK".format(config_file))

  if config_etcd:
      if not config_etcd.get("keyspace"):
          raise Exception("etcd Keyspace is mandatory")
      try:
          config.set_many(ConfigManager(**config_etcd).as_dict())
          LOGGER.info(
              "Setting external configuration from {} : OK".format(config_file))
      except Exception as exc:
          LOGGER.error(
              "Setting external configuration from ({}) : NOT OK".format(
                  ",".join({key + "=" + value for key, value in config_etcd.items() or {}})
              ))

          LOGGER.exception(exc)
          raise exc

  logging.config.dictConfig(config.get("logging"))

  ```





  ```bash
  pip install Pyaml
  ```


  ```bash
  pip install python-etcd
  ```


  The following packages are needed to run tests and coverage

  ```bash
  pip install tox pytest-cov pytest flake8
  ```

  or

  ```bash
  pip install -r requirements/ci.txt
  pip install -r requirements/tests.txt
  ```




  * [from-etcd.py](examples/from-etcd.py)
  * [from-yaml.py](examples/from-yaml.py)



  * readthedoc with sphinx




  * Add set default variables feature

  * Add Environment Handler



  * Add Etcd Handler
  * Add Ini Yaml, Json Handlers


pkgId: dc7fc0c86871655af4489a49b730303b428c007cbeda06c575479de163b8a577
name: python-config_wrangler
arch: src
version: 1.2.3
epoch: 0
release: 1
url: https://github.com/arcann/config_wrangler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-config_wrangler-1.2.3-1.src.rpm
checksum_type: sha256
summary:
  pydantic based configuration wrangler. Handles reading multiple ini or toml files with inheritance rules and variable expansions.

description:
  [![pypi](https://img.shields.io/pypi/v/config-wrangler.svg)](https://pypi.org/project/config-wrangler/)
  [![license](https://img.shields.io/github/license/arcann/config_wrangler.svg)](https://github.com/arcann/config_wrangler/blob/master/LICENSE)
  [![Python package](https://github.com/arcann/config_wrangler/actions/workflows/unit_test.yml/badge.svg)](https://github.com/arcann/config_wrangler/actions/workflows/unit_test.yml)

  pydantic based configuration wrangler. Handles reading multiple ini or toml files with inheritance rules and variable expansions.



  Install using your package manager of choice:
    - `poetry add config-wrangler`
    - `pip install -U config-wrangler`
    - `conda install config-wrangler -c conda-forge`.



  config.ini
  ```ini
  [S3_Source]
  bucket_name=my.exmple-bucket
  key_prefixes=processed/
  user_id=AK123456789ABC


  password_source=CONFIG_FILE
  raw_password=My secret password

  [target_database]
  dialect=sqlite
  database_name=${test_section:my_environment:source_data_dir}/example_db

  [test_section]
  my_int=123
  my_float=123.45
  my_bool=Yes
  my_str=ABC☕
  my_bytes=ABCⓁⓄⓋ☕
  my_list_auto_c=a,b,c
  my_list_auto_nl=
      a
      b
      c
  my_list_auto_pipe=a|b|c
  my_list_c=a,b,c
  my_list_python=['x','y','z']
  my_list_json=["J","S","O","N"]
  my_list_nl=
      a
      b
      c
  my_list_int_c=1,2,3
  my_tuple_c=a,b,c
  my_tuple_nl=
      a
      b
      c
  my_tuple_int_c=1,2,3
  my_dict={1: "One", 2: "Two"}
  my_dict_str_int={"one": 1, "two": 2}
  my_set={'A','B','C'}
  my_set_int=1,2,3
  my_frozenset=A,B,C
  my_date=2021-05-31
  my_time=11:55:23
  my_datetime=2021-05-31 11:23:53
  my_url=https://localhost:6553/

  [test_section.my_environment]
  name=dev

  temp_data_dir=.\temp_data\${test_section:my_environment:name}
  source_data_dir=.
  ```

  python code

  ```py
  import typing
  from datetime import date, time, datetime

  from pydantic import BaseModel, DirectoryPath, Field, AnyHttpUrl

  from config_wrangler.config_data_loaders.base_config_data_loader import BaseConfigDataLoader
  from config_wrangler.config_from_ini_env import ConfigFromIniEnv
  from config_wrangler.config_from_loaders import ConfigFromLoaders
  from config_wrangler.config_templates.config_hierarchy import ConfigHierarchy
  from config_wrangler.config_templates.aws.s3_bucket import S3_Bucket
  from config_wrangler.config_templates.sqlalchemy_database import SQLAlchemyDatabase
  from config_wrangler.config_types.path_types import AutoCreateDirectoryPath
  from config_wrangler.config_types.delimited_field import DelimitedListField


  class S3_Bucket_KeyPrefixes(S3_Bucket):
      key_prefixes: typing.List[str]


  class Environment(ConfigHierarchy):
      name: str = Field(..., env='env_name')
      temp_data_dir: AutoCreateDirectoryPath
      source_data_dir: DirectoryPath


  class TestSection(BaseModel):
      my_int: int
      my_float: float
      my_bool: bool
      my_str: str
      my_bytes: bytes
      my_list_auto_c: list
      my_list_auto_nl: list
      my_list_auto_pipe: list
      my_list_python: list
      my_list_json: list
      my_list_c: list = DelimitedListField(delimiter=',')
      my_list_nl: list = DelimitedListField(delimiter='\n')
      my_list_int_c: typing.List[int] = DelimitedListField(delimiter=',')
      my_tuple_c: tuple = DelimitedListField(delimiter=',')
      my_tuple_nl: tuple = DelimitedListField(delimiter='\n')
      my_tuple_int_c: typing.Tuple[int, int, int] = DelimitedListField(delimiter=',')
      my_dict: dict
      my_dict_str_int: typing.Dict[str, int]
      my_set: set
      my_set_int: typing.Set[int]
      my_frozenset: frozenset
      my_date: date
      my_time: time
      my_datetime: datetime
      my_url: AnyHttpUrl
      my_environment: Environment


  class ETLConfig(ConfigFromIniEnv):
      class Config:
          validate_default = True
          validate_assignment = True

      target_database: SQLAlchemyDatabase

      s3_source: S3_Bucket_KeyPrefixes

      test_section: TestSection


  class ETLConfigAnyLoaders(ETLConfig):
      def __init__(
              self,
              _config_data_loaders: typing.List[BaseConfigDataLoader],
              **kwargs: typing.Dict[str, typing.Any]
      ) -> None:
          
          ConfigFromLoaders.__init__(
              self,
              _config_data_loaders=_config_data_loaders,
              **kwargs
          )


  def main():
      config = ETLConfig(file_name='simple_example.ini')

      print(f"Temp data dir = {config.test_section.my_environment.temp_data_dir}")
      

      print(f"Source data dir = {config.test_section.my_environment.source_data_dir}")
      

      print(f"my_int = {config.test_section.my_int}")
      

      print(f"my_float = {config.test_section.my_float}")
      

      print(f"my_str = {config.test_section.my_str}")
      

      print(f"my_list_auto_c = {config.test_section.my_list_auto_c}")
      

      print(f"my_list_auto_nl = {config.test_section.my_list_auto_nl}")
      

      print(f"my_dict = {config.test_section.my_dict}")
      

      print(f"my_set = {config.test_section.my_set}")
      

      print(f"my_time = {config.test_section.my_time}")
      

      print(f"my_datetime = {config.test_section.my_datetime}")
      

      print(f"my_url = {config.test_section.my_url}")
      

      
      engine = config.target_database.get_engine()
      print(f"target_database.engine = {engine}")
      

      print("Getting S3 Data")
      bucket = config.s3_source.get_bucket()
      print(f"S3 bucket definition = {bucket}")
      for prefix in config.s3_source.key_prefixes:
          print(f"  bucket search prefix = {prefix}")
      
      
      
      


  if __name__ == '__main__':
      main()

  ```


pkgId: d35cdb25ca09d9a39656f76bbe31e6efce0655620cf9a467bda7a25724716f62
name: python-configcat-client
arch: src
version: 9.0.4
epoch: 0
release: 1
summary: ConfigCat SDK for Python. https://configcat.com
url: https://github.com/configcat/python-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configcat-client-9.0.4-1.src.rpm
checksum_type: sha256
description:
  Feature Flags created by developers for developers with <3. ConfigCat lets you manage feature flags across frontend, backend, mobile, and desktop apps without (re)deploying code. % rollouts, user targeting, segmentation. Feature toggle SDKs for all main languages. Alternative to LaunchDarkly. Host yourself, or use the hosted management app at https://configcat.com.


pkgId: 4c8838f7111929007fb6a5091fb2796ba29f5af68b7cfd8c4fc7c34a77dee4ca
name: python-configdict
arch: src
version: 2.10.2
epoch: 0
release: 1
summary: A supercharged dict used as configuration
url: https://github.com/gesellkammer/configdict
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configdict-2.10.2-1.src.rpm
checksum_type: sha256
rpm_license:
  Copyright (c) 2011-2017 GitHub Inc.  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: 94eb70826db18668e1641c4afe273b8dffaad7d11b56f2b06390293f1b9640e0
name: python-configer
arch: src
version: 1.3.1
epoch: 0
release: 1
summary: Easy configuration of arguments in a python code!
url: https://github.com/nimagbani/configer
rpm_license: GNU Affero General Public License, version 3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configer-1.3.1-1.src.rpm
checksum_type: sha256
description:
  This is the repository for the package **CONFIGER** helps with easy configuration of arguments in a python code.


pkgId: 794d74d9a91417f48e558062edc079fbf02dd766992062e6d6005c6c6a93d48b
name: python-configerus
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Plugin-Based configuration manager
url: https://github.com/james-nesbitt/configerus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configerus-3.0.1-1.src.rpm
checksum_type: sha256
description:
  Dynamic and abstract configuration management

  An extendable plugin based configuration system, which allows abstract config
  primitives to be loaded from various prioritized sources.  Config from higher
  priority source plugins takes precedence over lower priority, with some simple
  deep merging.

  Configerus makes config easy by:

  1. having a simple construction method
  2. allowing config to be pulled from a variatey of sources, such as json/yml in
     file paths, or custom dicts
  3. using priorities, configerus allows config override, where some sources can
     override others.
  4. deep configuration retrieval is easy using "dot" (one.two.three) notation to
     search in config trees

  Configerus offers a few tricks for complex use-cases

  1. you can apply simple validation (such as jsonschema) on retrieved config
  2. you can use a templating syntax to embed config from one source into another
     at the time of retrieval
  3. you can use a templating syntax to direct configeraus to replace a string
     file path with the contents of that file. Some files will be unmarshalled
     for the replacement.

  Configerus makes advanced config management possible by:

  1. allowing you to define your own sources, formatters and validators and inject
     them at run time
  2. allowing you to extend using setuptools entrypoints for advanced functionality
     bootstrapping.



  Configerus has a bit of steep learning curve in its approach and construction
  but it easy to use if it is set up correctly.

  A cheap and dirty example:

  If you have a folder `./config` that has to config files in it:
  - settings.yaml
  - values.json
  ```
  import configerus
  from configerus.contrib.dict import PLUGIN_ID_SOURCE_DICT
  from configerus.contrib.files import PLUGIN_ID_SOURCE_PATH

  config = configerus.new_config()

  config.add_source(PLUGIN_ID_SOURCE_PATH).set_path('./config')

  config.add_source(PLUGIN_ID_SOURCE_DICT, priority=90).set_data({
      'values': {
          'one': 'overriden from dict'
      }
  })


  settings = config.load('settings')
  user_id = settings.get('user.id') # expects that settings had {user: {id: 'some value'}}


  values = config.load('values')  # loads the value file, but overrides from the dict
  assert values.get('one') == 'overriden from dict'
  ```


pkgId: 980307fcf23925ac634642e024e5771010716e935eba868c7c164a5ccfd26e76
name: python-configextractor-py
arch: src
version: 1.1.9
epoch: 0
release: 1
summary: A library for extracting malware configurations across multiple frameworks
url: https://pypi.org/project/configextractor-py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configextractor-py-1.1.9-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pypi.org/project/configextractor-py/#history"><img src="https://img.shields.io/pypi/v/configextractor-py.svg" alt="Latest Stable Release"></a>

  Maintainer: @cccs-rs

  Python Library for performing configuration extraction across multiple extraction frameworks (ie. Maco, MWCP, etc.). This tool is actively used in the [Assemblyline](https://cybercentrecanada.github.io/assemblyline4_docs/) project as a [service](https://github.com/CybercentreCanada/assemblyline-service-configextractor).

  The code found in this repository contains a command line interface that acts as
  a wrapper for popular malware configuration data decoders from:

  - [Maco](https://github.com/CybercentreCanada/Maco) [MIT license]
  - [MWCP](https://github.com/Defense-Cyber-Crime-Center/DC3-MWCP) [MIT license]
  - [CAPE Sandbox](https://github.com/kevoreilly/CAPEv2/) via Maco wrappers [GPL license]
    - many thanks to [@kevoreilly](https://github.com/kevoreilly) for releasing so many open source parsers.
  - ~~MWCFG : https://github.com/c3rb3ru5d3d53c/mwcfg [BSD 3-Clause License]~~
    - [Pending support from malduck with structured output](https://github.com/CERT-Polska/malduck/pull/101)





  ```bash
  sudo apt-get update && sudo apt-get install -y git libssl-dev libmagic-dev automake libtool make gcc wget libjansson-dev pkg-config
  export YARA_VERSION=4.1.3
  wget -O /tmp/yara.tar.gz https://github.com/VirusTotal/yara/archive/v${YARA_VERSION}.tar.gz
  tar -zxf /tmp/yara.tar.gz -C /tmp
  cd /tmp/yara-${YARA_VERSION}
  ./bootstrap.sh
  ./configure --enable-magic --enable-dotnet --with-crypto --prefix /tmp/yara_install
  make
  make install
  pip install  --global-option="build" --global-option="--enable-dotnet" --global-option="--enable-magic" yara-python==$YARA_VERSION
  ```



  ```bash
  docker container run \
    -v /path/to/parsers:/mnt/parsers \
    -v /path/to/samples:/mnt/samples \
    cccs/assemblyline-service-configextractor \
    "cx -p /mnt/parsers -s /mnt/samples"
  ```





  You can use `configextractor` or `cx` to make use of the CLI:

  ```
  Usage: cx [OPTIONS] PARSERS_PATH SAMPLE_PATH

  Options:
    --block_list TEXT  Comma-delimited list of parsers to ignore
    --help             Show this message and exit.
  ```



  ```python
  from configextractor.main import ConfigExtractor
  import logging


  logger = logging.getLogger()
  logger.handlers = [logging.StreamHandler()]
  logger.setLevel('DEBUG')



  cx = ConfigExtractor(["/path/to/extractors/"], logger=logger)




  print([cx.get_details(p)['name'] for p in cx.parsers.values()])


  results = cx.run_parsers('/path/to/sample')


  print(results)
  ```



  1. Inherit from the base `Framework` class and implement class accordingly
  2. Add new framework to the ConfigExtractor class' `FRAMEWORK_LIBRARY_MAPPING`


pkgId: 90b1eafa8a89bbfda56ff9411b65283eb043cb7415ddb34813eaefeb19055d6d
name: python-configilm
arch: src
version: 0.7.0
epoch: 0
release: 1
url: https://github.com/lhackel-tub/ConfigILM
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configilm-0.7.0-1.src.rpm
checksum_type: sha256
summary:
  A state-of-the-art tool for Python developers seeking to rapidly and iteratively develop vision and language models within the [`pytorch`](https://pytorch.org/) framework

description:
  ![ConfigILM Banner](https://raw.githubusercontent.com/wiki/lhackel-tub/ConfigILM/static/imgs/ConfigILM_v1.png)

  <a href="https://bifold.berlin/"><img src="https://raw.githubusercontent.com/wiki/lhackel-tub/ConfigILM/static/imgs/BIFOLD_Logo_farbig.png" style="font-size: 1rem; height: 2em; width: auto; margin-right: 1em" alt="BIFOLD Logo"/>
  <img height="2em" hspace="10em"/>
  <a href="https://www.tu.berlin/"><img src="https://raw.githubusercontent.com/wiki/lhackel-tub/ConfigILM/static/imgs/tu-berlin-logo-long-red.svg" style="font-size: 1rem; height: 2em; width: auto" alt="TU Berlin Logo"/>
  <img height="2em" hspace="17em"/>
  <a href="https://rsim.berlin/"><img src="https://raw.githubusercontent.com/wiki/lhackel-tub/ConfigILM/static/imgs/RSiM_Logo_1.png" style="font-size: 1rem; height: 2em; width: auto" alt="RSiM Logo"/>
  <img height="2em" hspace="17em"/>
  <a href="https://eo-lab.org/de/projects/?id=12443968-ab8d-439b-8794-57d25b260406"><img src="https://raw.githubusercontent.com/wiki/lhackel-tub/ConfigILM/static/imgs/ai-cube-logo.png" style="font-size: 1rem; height: 2em; width: auto" alt="AI-Cube Logo"/>


  [![Publication](https://img.shields.io/badge/Publication%20freely%20available%20on-Elsevier/SoftwareX-red.svg)](https://doi.org/10.1016/j.softx.2024.101731)


  [![Release Notes](https://img.shields.io/github/release/lhackel-tub/ConfigILM)](https://github.com/lhackel-tub/ConfigILM/releases)
  [![PyPI - Version](https://img.shields.io/pypi/v/configilm)](https://pypi.org/project/configilm/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/configilm)](https://pypi.org/project/configilm/)
  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/mit-0)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.13269357.svg)](https://zenodo.org/records/13269357)
  [![CI Pipeline](https://github.com/lhackel-tub/ConfigILM/actions/workflows/run_tests.yml/badge.svg)](https://github.com/lhackel-tub/ConfigILM/actions/workflows/run_tests.yml)
  [![CI Pipeline](https://github.com/lhackel-tub/ConfigILM/actions/workflows/build_docu.yml/badge.svg)](https://github.com/lhackel-tub/ConfigILM/actions/workflows/build_docu.yml)
  [![Code Coverage](https://img.shields.io/badge/coverage%20-98%25-4c1)](./coverage.report)
  [![GitHub Star Chart](https://img.shields.io/github/stars/lhackel-tub/ConfigILM?style=social)](https://img.shields.io/github/stars/lhackel-tub/ConfigILM?style=social)
  [![Open Issues](https://img.shields.io/github/issues-raw/lhackel-tub/ConfigILM)](https://github.com/lhackel-tub/ConfigILM/issues)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/configilm)](https://pypi.org/project/configilm/)


  <!-- introduction-start -->
  The library `ConfigILM` is a state-of-the-art tool for Python developers seeking to rapidly and
  iteratively develop image and language models within the [`pytorch`](https://pytorch.org/) framework.
  This **open-source** library provides a convenient implementation for seamlessly combining models
  from two of the most popular [`pytorch`](https://pytorch.org/) libraries,
  the highly regarded [`timm`](https://github.com/rwightman/pytorch-image-models) and [`huggingface`🤗](https://huggingface.co/).
  With an extensive collection of nearly **1000 image** and **over 100 language models**,
  with an **additional 120,000** community-uploaded models in the [`huggingface`🤗 model collection](https://huggingface.co/models),
  `ConfigILM` offers a diverse range of model combinations that require minimal implementation effort.
  Its vast array of models makes it an unparalleled resource for developers seeking to create
  innovative and sophisticated **image-language models** with ease.

  Furthermore, `ConfigILM` boasts a user-friendly interface that streamlines the exchange of model components,
  thus providing endless possibilities for the creation of novel models.
  Additionally, the package offers **pre-built and throughput-optimized**
  [`pytorch dataloaders`](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html) and
  [`lightning datamodules`](https://lightning.ai/docs/pytorch/latest/data/datamodule.html),
  which enable developers to seamlessly test their models in diverse application areas, such as *Remote Sensing (RS)*.
  Moreover, the comprehensive documentation of `ConfigILM` includes installation instructions,
  tutorial examples, and a detailed overview of the framework's interface, ensuring a smooth and hassle-free development experience.

  <!-- introduction-end -->

  ![Concept of ConfigILM](https://raw.githubusercontent.com/wiki/lhackel-tub/ConfigILM/static/imgs/ConfigILM-ILMType.VQA_CLASSIFICATION.png)

  For detailed information please see its [publication](https://doi.org/10.1016/j.softx.2024.101731)
  and the [documentation](https://lhackel-tub.github.io/ConfigILM).

  `ConfigILM` is released under the [MIT Software License](https://opensource.org/licenses/mit-0)



  As an open-source project in a developing field, we are open to contributions.
  They can be in the form of a new or improved feature or better documentation.

  For detailed information on how to contribute, see [here](.github/CONTRIBUTING.md).




  <!-- citation-start -->
  If you use this work, please cite

  ```bibtex
  @article{hackel2024configilm,
    title={ConfigILM: A general purpose configurable library for combining image and language models for visual question answering},
    author={Hackel, Leonard and Clasen, Kai Norman and Demir, Beg{\"u}m},
    journal={SoftwareX},
    volume={26},
    pages={101731},
    year={2024},
    publisher={Elsevier}
  }
  ```
  and the used version of the software, e.g., the current version with
  ```bibtex
  @software{lhackel_tub_2024_13269357,
    author       = {lhackel-tub and
                    Kai Norman Clasen},
    title        = {lhackel-tub/ConfigILM: v0.6.9},
    month        = aug,
    year         = 2024,
    publisher    = {Zenodo},
    version      = {v0.6.9},
    doi          = {10.5281/zenodo.13269357},
    url          = {https://doi.org/10.5281/zenodo.13269357}
  }
  ```
  <!-- citation-end -->


  This work is supported by the European Research Council (ERC) through the ERC-2017-STG
  BigEarth Project under Grant 759764 and by the European Space Agency through the DA4DTE
  (Demonstrator precursor Digital Assistant interface for Digital Twin Earth) project and
  by the German Ministry for Economic Affairs and Climate Action through the AI-Cube
  Project under Grant 50EE2012B. Furthermore, we gratefully acknowledge funding from the
  German Federal Ministry of Education and Research under the grant BIFOLD24B.
  We also thank [EO-Lab](https://eo-lab.org/en/) for giving us access to their GPUs.


pkgId: a476aeb407c302a22beb08fff3466723605e46cb5cad84718decf2c29af9e40b
name: python-configman
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Flexible reading and writing of namespaced configuration options
url: https://github.com/mozilla/configman
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configman-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Travis](https://travis-ci.org/mozilla/configman.png?branch=master)](https://travis-ci.org/mozilla/configman)
  Copyright Mozilla, 2013 - 2015
  General tool for setting up configuration options per namespaces.
  Supports reading and writing configs generally from and into config
  files.


pkgId: d12b26c0b6e90e57cb072029d06a87f3e3d172761a68f9404871dc5889383e4b
name: python-configmanager
arch: src
version: 1.35.1
epoch: 0
release: 1
summary: Forget about configparser, YAML, or JSON parsers. Focus on configuration.
url: https://github.com/jbasko/configmanager
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configmanager-1.35.1-1.src.rpm
checksum_type: sha256
description:
  **Update on 2019-05-13**: Version 1.35 and above require Python 3.6+.
  **Update on 2018-10-20**: I no longer use this library. It tries to do too many things. It was written in
  Python 2.7 and made work with Python 3. With type hints, dataclasses, and many other cool features in Python 3.6+


pkgId: e90feb4fcdca436dc39a4dd82ea09c3086b2f211902a234cbe785c8e68866922
name: python-configmypy
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Fast and easy configuration of Python projects.
url: https://github.com/JeanKossaifi/configmypy
rpm_license: Modified BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configmypy-0.2.0-1.src.rpm
checksum_type: sha256
description:
   (1) YamlConfig with config_file=./config.yaml, config_name=default
   (2) ArgparseConfig with additional config={'config_file': None, 'config_name': None}


pkgId: c4fcea79d0a1a8740cff4f38e83463db8cf1d4873a699a7b8eeff5221a09985d
name: python-configobj
arch: src
version: 5.0.9
epoch: 0
release: 1
summary: Config file reading, writing and validation.
url: https://github.com/DiffSK/configobj
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configobj-5.0.9-1.src.rpm
checksum_type: sha256
description:
  * Nested sections (subsections), to any level
  * List values
  * Multiple line values
  * Full Unicode support
  * String interpolation (substitution)
  * Integrated with a powerful validation system
      - including automatic type checking/conversion
      - and allowing default values
      - repeated sections
  * All comments in the file are preserved
  * The order of keys/sections is preserved
  * Powerful ``unrepr`` mode for storing/retrieving Python data-types


pkgId: 29159d8c468860ddcde3194f85a229aaee891ba00b4e6b7241801d9f46cbc030
name: python-configomatic
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Package providing a configurable object for use in Python applications.
url: https://github.com/azimuth-cloud/configomatic
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configomatic-0.4.0-1.src.rpm
checksum_type: sha256
description:
  This package provides an object that extends the [Pydantic](https://pydantic-docs.helpmanual.io/)
  `BaseModel` to add support for loading variables from file with overrides from the environment.


pkgId: 08c3b55f7fe54fc3a597b2f9258d857657cda997d5c4766fb7e61e0821a17da9
name: python-configops
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A devops config tool
url: https://github.com/dumasd/config-ops
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configops-0.2.1-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)[![Build Status](https://github.com/apache/superset/workflows/Python/badge.svg)](https://github.com/apache/superset/actions)

  一款 DevOps 配置工具：

  - Nacos Yaml、Properties格式的配置文件变更。
  - 使用 Liquibase 执行数据库版本脚本。

  结合 [dumasd/jenkins-config-ops-plugin (github.com)](https://github.com/dumasd/jenkins-config-ops-plugin) 插件实现与Jenkins的集成。





  Liquibase安装文档: https://docs.liquibase.com/start/install/home.html





  下载 [Config-Ops Release](https://github.com/dumasd/config-ops/releases/latest/download/config-ops-linux.tar.gz)  文件解压，release 文件中包含 `config-ops` 可执行文件和配置文件样例 `config.yaml.sample`

  ```shell

  cp config.yaml.sample config.yaml


  vim config.yaml


  ./startup.sh

  ```



  config-ops镜像库： [wukaireign/config-ops general | Docker Hub](https://hub.docker.com/repository/docker/wukaireign/config-ops/general)

  ```shell
  git clone https://github.com/dumasd/config-ops.git

  cd config-ops


  vim docker-compose.yaml


  docker-compose -f docker-compose.yaml up -d
  ```





  - Python：3.9及以上版本



  ```shell

  git clone https://github.com/dumasd/config-ops.git
  cd config-ops


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


  pip3 install -r requirements.txt


  python3 -m pytest ./tests


  pyinstaller app.spec


  pip3 install --upgrade setuptools wheel twine
  python3 setup.py sdist bdist_wheel
  python3 -m twine upload dist/*


  ```


pkgId: f55f1b77d1015a6830243db6b7144a3549595a8fad3fe1f8482c5761dd99357f
name: python-configparse
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Drop-in substitute for argparse that reads config files
url: https://github.com/jyn514/configparse/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configparse-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/jyn514/py-autoconfig.svg?branch=master)](https://travis-ci.org/jyn514/py-autoconfig)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)



  configparse is a drop-in-place replacement for python's `argparse` module
  which reads configuration files in addition to command line arguments.



  If the configuration directory exists, all of files in `<config_directory>/<prog>/` are read.
  All files matching `~/.<prog>*` are read.

  Files are treated according to their extension: `config.json` will be parsed as JSON,
  `myconf.yml` will be parsed as YAML.

  If a file does not have an extension, it will be parsed according to the default
  file format. This is preset to JSON, but can be changed by applications.




  On Windows, the configuration directory looked up in `%AppData%`.
  On any other OS, it is looked up from `$XDG_CONFIG_HOME`.
  If the variable is not present (on any OS), files are read from `~/.config`.



  The following file formats are currently supported:

  - JSON (.json)
  - YAML (.yml)
  - INI  (.ini)
  - TOML (.toml)

  Feel free to submit a pull request adding more formats.
  See CONTRIBUTING.md for an overview,
  if you already have a parser it should be very simple.





  If you are an application developer who wants to use the library,
  there is one entry point: the `ConfigParser` class,
  which is also aliased to `Parser` for convenience.
  You can treat a `ConfigParser` instance exactly as you would an `ArgumentParser`
  instance (as long as you pass `prog` to the constructor).

  Note that this means that `parse_args` will parse `sys.argv`
  in addition to parsing configuration files. If you don't want this behavior,
  pass an empty list to `parse_args` like this: `args = parser.parse_args([])`.

  If you want to change the default file format (e.g. for files named `~/.myprog`
  without an extension), use  `parser.set_default_ext(ext)`, where 'ext' is the
  file extension for your format.



  The only API differences are as follows:

  - the name of the parser is `ConfigParser`, not `ArgumentParser`
  - the `prog` keyword is required for initializing `ConfigParser` (so that it knows where to look for configuration files)

  That's it. Everything else is done automatically.



  ```python
  from configparse import Parser

  parser = Parser(prog='myprogram')
  parser.add_argument('--short', '-s', help='use short format')
  args = parser.parse_args()
  ```



  You can put a configuration file in any of the following locations:

  - `~/.config/<prog>/`
  - `~/.<prog>*`

  See `Features` for a full overview.



  Assume that the program `basic` takes the arguments '--short' and '--long'.

  ```sh
  $ cat ~/.config/basic/config.yml
  short: true
  $ basic
  You chose the 'short' option.
  $ rm ~/.config/basic/config.yml
  $ echo 'long: true' > ~/.basic.yml
  $ basic
  You chose the 'long' option.
  ```



  - Only long options will be applied. If a short option is present in a config file,
  it will be treated as if it were a long option, i.e. not looked up.
  For example, assuming some backend returns the dictionary `{'s': 'some value'}`:

  ```
  from configparse import Parser

  p = Parser(prog='myprog')
  p.add_argument('-s', '--short')
  args = p.parse_args()
  assert args.short is None
  assert args.s == 'some value'
  ```


pkgId: 1698798f83748f046698d1ee294449df205acaef99d4a448742ec9efda01be46
name: python-configparser
arch: src
version: 7.1.0
epoch: 0
release: 1
summary: Updated configparser from stdlib for earlier Pythons.
url: https://pypi.org/project/configparser/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configparser-7.1.0-1.src.rpm
checksum_type: sha256
description:
  This project uses `semver <https://semver.org/spec/v2.0.0.html>`_ to
  communicate the impact of various releases while periodically syncing
  with the upstream implementation in CPython.
  The `history <https://configparser.readthedocs.io/en/latest/history.html>`_
  serves as a reference indicating which versions incorporate
  which upstream functionality.
  Prior to the ``4.0.0`` release, `another scheme
  <https://github.com/jaraco/configparser/blob/3.8.1/README.rst#versioning>`_
  was used to associate the CPython and backports releases.


pkgId: e870ccc3735d6f0afed7be387f99b66b45394a3c662e1990b7f278f4352243a9
name: python-configparser-crypt
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Drop-in replacement for ConfigParser with encryption support
url: https://github.com/netinvent/configparser_crypt
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configparser-crypt-1.1.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Percentage of issues still open](http://isitmaintained.com/badge/open/netinvent/ofunctions.svg)](http://isitmaintained.com/project/netinvent/configparser_crypt "Percentage of issues still open")
  [![Maintainability](https://api.codeclimate.com/v1/badges/683f2fd6af8fc1c8de73/maintainability)](https://codeclimate.com/github/netinvent/configparser_crypt/maintainability)
  [![codecov](https://codecov.io/gh/netinvent/configparser_crypt/branch/master/graph/badge.svg?token=J7GMZYPYGQ)](https://codecov.io/gh/netinvent/configparser_crypt)
  [![linux-tests](https://github.com/netinvent/configparser_crypt/actions/workflows/linux.yaml/badge.svg)](https://github.com/netinvent/configparser_crypt/actions/workflows/linux.yaml)
  [![windows-tests](https://github.com/netinvent/configparser_crypt/actions/workflows/windows.yaml/badge.svg)](https://github.com/netinvent/configparser_crypt/actions/workflows/windows.yaml)
  [![GitHub Release](https://img.shields.io/github/release/netinvent/configparser_crypt.svg?label=Latest)](https://github.com/netinvent/configparser_crypt/releases/latest)

  configparser_crypt is a drop-in replacement for configparser, that allows to read / write encrypted configuration files.

  It is compatible with Python 3.5+/PyPy and is tested on both Linux and Windows.



  ```
  pip install configparser_crypt

  ```



  Just like configparser, except that we read/write binary files and have a AES key.
  AES key generation is done using `generate_key()` which by default generates a 256-bit encryption key.
  You may also generate a 128 or 192 bit key by giving the byte length as parameter (16, 24 or 32 bytes).


  How to write en encrypted config file
  ```python
  from configparser_crypt import ConfigParserCrypt

  file = 'config.encrypted'
  conf_file = ConfigParsercrypt()


  conf_file.generate_key()

  aes_key = conf_file.aes_key


  conf_file.add_section('TEST')
  conf_file['TEST']['foo'] = 'bar'


  with open(file, 'wb') as file_handle:
      conf_file.write_encrypted(file_handle)
  ```

  How to read an encrypted config file
  ```python
  from configparser_crypt import ConfigParserCrypt

  file = 'config.encrypted'
  conf_file = ConfigParsercrypt()


  conf_file.aes_key = my_previously_backed_up_aes_key


  conf_file.read_encrypted(file)
  print(conf_file['TEST']['foo'])
  ```

  The following is an example of drop-in-replacement for ConfigParser

  ```diff
  -from configparser import ConfigParser
  +from configparser_crypt import ConfigParserCrypt

  file = 'config.ini'
  -conf_file = ConfigParser()
  +conf_file = ConfigParserCrypt()
  +key = conf_file.generate_key()


  conf_file.add_section('TEST')
  conf_file['TEST']['spam'] = 'eggs'


  -with open(file, 'w') as file_handle:
  -    conf_file.write(file_handle)
  +with open(file, 'wb') as file_handle:
  +    conf_file.write_encrypted(file_handle)


  -conf_file = ConfigParser()
  -conf_file.read(file)
  +conf_file = ConfigParserCrypt()
  +conf_file.aes_key = secure_key
  +conf_file.read_encrypted(file)


  assert conf_file['TEST']['spam'] == 'eggs'
  ```



  In order to open earlier written encrypted configuration files, you need to store the aes key generated with `aes_key = conf_file.generate_key()`.
  You can than later use it by loading it into the class:
  ```python
  file = 'my_encrypted.conf'
  conf_file = ConfigParserCrypt()
  conf_file.aes_key = 'PUT YOUR PREVIOUSLY GENERATED AES KEY HERE'
  conf_file.read_encrypted(file)
  ```



  It's pretty simple to encrypt an existing .ini file.
  You just need to read it as standard ini file, then write it as encrypted file.

  ```python
  original_file = 'config.ini'
  target_encrypted_file = 'config.encrypted'

  conf_file = ConfigParsercrypt()


  conf_file.generate_key()

  aes_key = conf_file.aes_key


  config_file.read(original_file)

  with open(target_encrypted_file, 'wb') as file_handle:
      conf_file.write_encrypted(file_handle)
  ```

  Just keep in mind that secure deletion of the original file is out of scope of ConfigParserCrypt.
  Of course, you can also read an encrypted file and save it as non encrypted.



  Just like ConfigParser, ConfigParserCrypt provides a ConfigParser object.
  It's sometimes useful to switch between those objects and a dictionary.

  ConfigParserCrypt has configparser to dict and dict to configparser object functions included.
  Since ConfigParser stores all variables (int, float, bool) as strings, the converter functions try to recast the original type of the variable when rendering a dictionary.

  The only drawback is that your dictionaries must not exceed more than two level depth, eg:
  ```python
  my_dict = {
      'section_name':
          {
              'some_name': 'some_var'
          },
      'another_section':
          {
              'another_var': 'something',
              'an int': 1,
              'a bool': False
          }
  }
  ```

  Note that these convert functions also work with vanilla ConfigPaser
  Example:
  ```python

  import ConfigParserCrypt
  from configparser_crypt.dict_convert import configparser_to_dict, dict_to_configparser

  my_dict = configparser_to_dict(configparser_object)
  type(my_dict['some_int']) == True

  my_config_parser_object = dict_to_configparser(some_dict)
  ```


pkgId: 225474a5f88ab6561e1157f458f907a0dbe696db3a47534e6856f3963c66b215
name: python-configparser-list
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Extends ConfigParser to support lists
url: https://github.com/ahmad88me/configparser-list
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configparser-list-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://ahmad88me.semaphoreci.com/badges/configparser-list/branches/main.svg?key=1b31676d-8fc4-438c-9232-e0c63babe633)](https://ahmad88me.semaphoreci.com/projects/configparser-list)
  [![codecov](https://codecov.io/gh/ahmad88me/configparser-list/branch/main/graph/badge.svg?token=OK2EPNG23U)](https://codecov.io/gh/ahmad88me/configparser-list)



  Extends ConfigParser to support lists (`getlist`)


  `pip install configparser-list`


  To run the tests:

  ```
  python -m unittest
  ```



  ```
  from ConfigParserList import ConfigParser


  def list_from_dict():
      """
      This example sets the configuration from a dict and then fetchs a list
      :return:
      """
      str_list = ['A', "B", "C"]
      int_list = [1, 2, 3]
      d = {'SEC': {
          'int': 10,
          'float': 1.0,
          'liststr': str_list,
          'listint': int_list}
      }
      conf = ConfigParser()
      conf.read_dict(d)
      alpha = conf.getlist('SEC', 'liststr')
      ints = conf.getlistint('SEC', 'listint')
      print("list from config (dict): ")
      print(f"Alpha {alpha} is of type {type(alpha)}")
      print(f"Ints {ints} is of type {type(ints)}")
  ```


  ```
  from ConfigParserList import ConfigParser

  def list_from_string():
      """
      This example sets the configuration from a string and then fetchs a list
      :return:
      """
      conf_str = """
      [SEC]
      int=10,
      float=1.0,
      liststr=A, B, C
      listint=1, 2, 3
      """
      conf = ConfigParser()
      conf.read_string(conf_str)
      alpha = conf.getlist('SEC', 'liststr')
      ints = conf.getlistint('SEC', 'listint')
      print("list from config (string): ")
      print(f"Alpha {alpha} is of type {type(alpha)}")
      print(f"Ints {ints} is of type {type(ints)}")
  ```

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


pkgId: 4d6277cdef597e9692f497b987a9a3deb3ced9c092abc74c38d2f3e0093f5e1c
name: python-configreader
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: An easy-to-use, powerful configuration module for Python
url: https://github.com/mortbauer/configreader
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configreader-0.0.6-1.src.rpm
checksum_type: sha256
description:
  A simple but still powerfull Configuration Parser


  .. image:: https://secure.travis-ci.org/mortbauer/configreader.png?branch=master
          :target: https://secure.travis-ci.org/mortbauer/configreader

  There are quite many Configuration Parsers for Python out there, but well, they
  all kind of suck in there own way. Let me point out what I dislike:

  * `configparser`_: which is the de facto standard, has it's ini like language, in
    my opionion quite awful, difficult and limited

  * Configuration through yaml: is beautiful, but how about intergration of
    simple environment variables or interpolation of already defined values

  * How about just execution a python module, very unsafe (but who cares), but it
    also pollutes the namespace with all sort of builtins and whatsoever

  So I was looking once again and found `python-config`_, which looked really
  exactly what I wanted, but well, I had my problems with it, since I wanted to
  have acces to stuff like `os.getenv('HOME')` and similar, which was not really
  possible since it was forbidden to call a function, though you could still
  evaluate stuff and so on. I looke into the source and thought well how can I
  allow also calling functions? But I realized they are defining there own
  parsing grammar, which seemed kind of reinventing the wheel since I already
  knew the `ast`_ module.

  Finally I wrote a very simple Configuration Parser which lets `ast`_ and
  `operator`_ do most of the work. It has of course its own problems, and is hack
  of half an hour so don't expect much. For me it is still usefull, and maybe we
  can improve it.

  Usage
  *******
  As a simple example of what is possible and how to use the module, see the
  following config file which is by the way completely valid python::

      home = os.getenv('HOME')
      aster_root = home+"/data/opt/aster"
      project = "bikeframe-test"
      version = "testing"
      
      srcdir = "."
      
      outdir = "results"
      
      meshfile = "mesh.med"
      logfile = "asterclient.log"
      workdir = "/data/tmp"
      
      calculations = [
          {"name":"main",
            "commandfile": "main.comm",
            "resultfiles":{
                  "bikeframe.rmed":80,
                  "bikeframe.msh": 81,
                  "buckling.rmed": 82,
                  "bikeframe.table": 39,
                  "bikeframe.resu": 38,
                  "buckling.resu": 37,
                  },
            "inputfiles":["parameters.py"],
            },
          {"name": "post",
            "commandfile":"post.comm",
            "poursuite": "main",
            "resultfiles":{
              "vmises.table": 40,
              "protocol": "protocol*.rst",
              }
            }]

  Suppose we have this saved as `profile.conf` we could read it like::

      import os
      from configreader import Config

      c = Config(open('profile.conf','r'),namespace={'os.getenv':os.getenv})

  which would give as all the values specified and evaluated as a python `dict`.
  If we wouldn't have provided the namespace with `os.getenv` the parsing would
  have failed since it only allows functions mapped in the namespace, so you have
  completele fine grained possibility on what to allow.
  As input the `Config` class expects any file like object which is an object
  with a read method.

  Testing
  *******
  There are a few simple test cases in `tests` use best `py.test`_ to run them.

  .. _python-config: https://github.com/Inkvi/python-config
  .. _ast: http://docs.python.org/3.3/library/ast.html
  .. _operator: http://docs.python.org/3.3/library/operator.html
  .. _configparser: http://docs.python.org/3.3/library/configparser.html
  .. _py.test: https://pypi.python.org/pypi/pytest


pkgId: efaafd07e2c4a1844e342149f8ab5c1c28cece1a87e2f4968060a8bb76aeab9c
name: python-configs
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: Configuration for humans
url: https://bitbucket.org/moigagoo/configs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configs-3.0.3-1.src.rpm
checksum_type: sha256
description:
  *   Root-level params support
  *   Numeric and boolean values are converted automatically
  *   Sections with only key-value items are parsed as dicts
  *   Sections with only flag items (keys with no value) are parsed as lists
  *   Mixed content sections are parsed as tuples of a dict and a list, which can be accessed individually
  *   Sections are iterable (even the mixed ones; list first, dict second)
  *   Comments support


pkgId: bdb6d2f1bc9c91505bb9a0015dd4d998c9a96c01afc104c0573ecb1c7e4ca3f9
name: python-configu
arch: src
version: 0.6.3
epoch: 0
release: 1
summary: Configu Python SDK
url: https://configu.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configu-0.6.3-1.src.rpm
checksum_type: sha256
description:
  Configu SDK for Python published to [PyPI](https://pypi.org/project/configu/).



  ```bash
  pip install configu
  ```



  ```py
  import os

  import configu

  config_store = configu.InMemoryConfigStore()
  test_set = configu.ConfigSet("test")
  schema = configu.ConfigSchema("get-started.cfgu.json")

  configu.UpsertCommand(
    store=config_store,
    set=test_set,
    schema=schema,
    configs={
      "GREETING": "hello",
      "SUBJECT": "configu python sdk",
    },
  ).run()

  data = configu.EvalCommand(
    store=config_store, set=test_set, schema=schema
  ).run()

  configuration_data = configu.ExportCommand(data=data).run()

  print(os.environ["MESSAGE"])

  print(configuration_data)

  ```



  [oss.configu.com/py](https://oss.configu.com/py/configu.html)





  - Follow the [Development](https://github.com/configu/configu/blob/main/CONTRIBUTING.md#development) section from the `CONTRIBUTING.md`.
  - Install [pyenv](https://github.com/pyenv/pyenv) | [Homebrew](https://formulae.brew.sh/formula/pyenv)
  - Install [poetry](https://python-poetry.org/) | [Homebrew](https://formulae.brew.sh/formula/poetry)



  Run these commands in order:

  ```bash
  cd py
  ```

  ```bash
  pyenv install
  ```

  ```bash
  pyenv local 3.9.16
  ```

  ```bash
  poetry env use $(pyenv which python)
  ```

  ```bash
  poetry install
  ```



  Follow the [Sending a Pull Request](https://github.com/configu/configu/blob/main/CONTRIBUTING.md#sending-a-pull-request) section from the `CONTRIBUTING.md`.


pkgId: 6d9091ab6590f0bfdf8fd916caf9610552289d16b8d2d929a6a60c6e1a2fdc9d
name: python-configue
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: Helpers to load your application configuration from YAML files
url: https://github.com/illuin-tech/configue
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configue-5.0.0-1.src.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/illuin-tech/configue/workflows/CI/badge.svg)
  [![codecov](https://codecov.io/gh/illuin-tech/configue/branch/master/graph/badge.svg)](https://codecov.io/gh/illuin-tech/configue)
  A YAML parser with advanced functionalities to ease your application configuration.

  This library is meant to be used in medium to large-scale applications, that have a lot of parameters to configure.
  Modular applications especially can greatly benefit from using `configue` to easily inject new modules.

  Run `pip install configue` to install from PyPI.
  Run `pip install .` to install from sources.
  This project follows the (Semantic Versioning Specification)[https://semver.org/].
  All breaking changes are described in the [Changelog](CHANGELOG.md).


  This library uses [PyYAML](https://github.com/yaml/pyyaml) to parse the YAML files and return the file content.
  ```python
  import configue
  config = configue.load("/path/to/yaml/file.yml")
  ```

  If you are not interested in loading the whole file, you can only load a subpath:
  ```yaml

  some_key:
    some_list:
      - first_item
      - second_item:
          item_key: item_value
  not_loaded_key: not_loaded_value
  ```
  ```python
  import configue
  config = configue.load("config.yml", "some_key.some_list.1.item_key")
  assert config == "item_value"
  ```

  Use `()` in your YAML files to instantiate classes:
  ```yaml

  (): "my_project.MyAwesomeClass"
  my_argument: "my_value"
  my_other_argument:
    (): "my_project.my_module.MyOtherClass"
  ```
  ```python
  import configue
  from my_project import MyAwesomeClass
  from my_project.my_module import MyOtherClass
  my_instance = configue.load("config.yml")
  assert isinstance(my_instance, MyAwesomeClass)
  assert my_instance.my_argument == "my_value"
  assert isinstance(my_instance.my_other_argument, MyOtherClass)
  ```
  This syntax also works to call functions:
  ```yaml

  (): "my_project.my_function"
  my_argument: "world"
  ```
  ```python
  import configue
  def my_function(my_argument: str) -> str:
    return "Hello " + my_argument
  my_value = configue.load("config.yml")
  assert my_value == "Hello world"
  ```

  ```yaml

  my_argument: !ext my_project.my_module.my_variable
  my_argument: !ext my_project.my_module.my_instance.my_attribute
  ```
  When using the `!ext` tag, the value will be imported from the corresponding python module.

  ```yaml

  my_object:
      my_instance:
          (): my_project.MyClass
  my_instance_shortcut: !cfg my_object.my_instance
  my_attribute_shortcut: !cfg my_object.my_instance.my_attribute
  ```
  When using the `!cfg` tag, the value will be loaded from the same configuration file (useful for a DRY configuration).

  If you want to load an environment variable in your YAML config file, you can use this syntax:
  ```yaml

  my_key: ${VAR_NAME}
  ```
  This will resolve as `"my_value"` if the environment variable `VAR_NAME` is set to this value.
  If you need a default value in case the environment variable is not set:
  ```yaml

  my_key: ${VAR_NAME-default}
  ```
  You can insert this syntax in the middle of a string:
  ```yaml

  my_key: prefix${VAR_NAME-default}suffix
  ```
  This will resolve as `"prefixmy_value_suffix"` if the value is set, `"prefixdefaultsuffix"` if it is not.
  If your environment variable resolves to a yaml value, it will be cast (unless you are using quotes):
  ```yaml

  my_key: ${VAR_NAME}
  my_quoted_key: "${VAR_NAME}"
  ```
  This will resolve as `True` if the value is set to `true`, `yes` or `y`, `None` if the value is set to `~` or `null`.

  If you want to expand a relative path in your YAML config file:
  ````yaml

  my_path: !path my_folder/my_file.txt
  ````
  Assuming your file structure looks like this:
  ```
  root/
  ├── config.yml
  └── my_folder
      └── my_file.txt
  ```
  The path is resolved starting from the folder containing the parent yml file, this example will resolve to
  `/root/my_folder/my_file.txt`
  Do not start the path with `/` as it will be treated as an absolute path instead.
  You can use environment variables in your file path.

  You can import another file directly in your YAML config file:
  ````yaml

  my_import: !import my_folder/my_other_config.yml
  ````
  ```yaml

  some_key:
      - var_1
      - var_2
  ```
  By default, the path is resolved starting from the folder containing the parent yml file, this example will resolve to
  `"my_import": {"some_key": [var_1, var_2]}`
  If you want to import only a section of the file, use the path in the tag suffix `!import:some_key.0`
  Do not start the import path with `/` as it will be treated as an absolute path instead.
  You can use environment variables in your import path.

  You can load the logging configuration for your application by using the `logging_config_path` parameter:
  ```yaml

  logging_config:
    version: 1
    handlers:
      console:
        class : logging.StreamHandler
        stream  : ext://sys.stdout
      custom_handler:
        \(): my_app.CustomHandler
        some_param: some_value
        level: ERROR
    root:
      level: INFO
      handlers:
        - console
  app_config:
    some_key: some_value
  not_loaded_key: not_loaded_value
  ```
  ```python
  import logging
  import configue
  app_config = configue.load("config.yml", "app_config", logging_config_path="logging_config")
  assert app_config == {"some_key": "some_value"}
  logger = logging.getLogger(__name__)
  logger.info("Hello world!")  # Uses the console handler
  ```
  The logging configuration should follow the format of `logging.config.dictConfig`
  (check [the documentation](https://docs.python.org/3/library/logging.config.html#logging-config-dictschema) for more
  details).
  Make sure to escape the constructors with `\()` instead of `()` for handlers, formatters and filters.

  Install the development dependencies with `pip install -r dev.requirements.txt`.
  Run `python -m unitttest discover` to run the tests.
  Run `pylint configue` to check the files linting.


pkgId: fd4d33f67b29eceb4ae1b2326db7e3019db0d374909a5857876521c323448105
name: python-configurable-http-proxy
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A python implementation of configurable-http-proxy
url: https://github.com/AbdealiJK/configurable-http-proxy
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configurable-http-proxy-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This is a pure python implementation of the
  [configurable-http-proxy](https://github.com/jupyterhub/configurable-http-proxy)
  written in nodejs. It is meant to be a drop in replacement.



  Prerequisite: Python 3.6+

  ```bash
  pip install configurable-http-proxy
  ```



  The following items are supported:

  - Proxying for Websocket and HTTP requests
  - Configuring the proxy using API requests
  - Auth token for API requests
  - Error management using error_path and error_target
  - Prepend path or include prefix
  - Timeouts
  - X-Forward related headers
  - Custom Headers
  - Customizable storage backends
  - PID file writing
  - Logging
  - Configurable storage backend

  The following options are additional (not available in nodejs CHP currently):
  - Ready to use DBMS storage backend

  The following options are not supported (yet):

  - SSL for proxy, client, API is not available (`--ssl-*`, `--api-ssl-*`, `--client-ssl-*`, `--insecure`)
  - Redirecting: `--redirect-port` and `--redirect-to`
  - Change Origin: `--change-origin`
  - Rewrites in Location header: `--protocol-rewrite` and `--auto-rewrite`
  - Metrics server: `--metrics-port` and `--metrics-ip`



  Using a SQL DBMS instead of the default in-memory store enables chp to be replicated
  in a High Availability scenario.

  To use a SQL DBMS as the storage backend:

  1. Install DBMS support

  ```bash
  $ pip install configurable-http-proxy[sqla]
  ```

  2. Set the CHP_DATABASE_URL env var to any db URL supported by SQLAlchemy. The default is `sqlite:///chp.sqlite`.

  ```bash
  $ export CHP_DATABASE_URL="sqlite:///chp.sqlite"
  $ configurable-http-proxy --storage-backend configurable_http_proxy.dbstore.DatabaseStore
  ```

  3. Optionally you may set the table name by setting the CHP_DATABASE_TABLE. The default is 'chp_routes'

  ```bash
  $ export CHP_DATABASE_TABLE="chp_routes"
  ```


pkgId: 6758de1bb6fff0c2a64d204c18e1492b42d3422d7c86ae52f185186a69311057
name: python-configuraptor
arch: src
version: 1.27.0
epoch: 0
release: 1
summary: Load toml/yaml/json config files into classes for a typed config (type hinting etc.)
url: https://pypi.org/project/configuraptor/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configuraptor-1.27.0-1.src.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [Usage](#usage)
  - [Supported Config File Types](#supported-config-file-types)
  - [License](#license)
  - [Changelog](#changelog)

  ```console
  pip install configuraptor
  ```

  Configuraptor can be used to load your config files into structured Python classes.
  ```toml

  [config]
  name = "Hello World!"
  [config.reference]
  number = 42
  numbers = [41, 43]
  string = "42"
  ```
  Could be loaded into Python classes using the following code:
  ```python

  from configuraptor import load_into, TypedConfig



  class SomeRegularClass:
      number: int
      numbers: list[int]
      string: str
  class Config:
      name: str
      reference: SomeRegularClass
  if __name__ == '__main__':
      my_config = load_into(Config, "example_from_readme.toml")  # or .json, .yaml, ...
      print(my_config.name)
      
      print(my_config.reference.numbers)
      



  class SomeOtherRegularClass:
      number: int
      numbers: list[int]
      string: str
  class OtherConfig(TypedConfig):
      name: str
      reference: SomeRegularClass
  if __name__ == '__main__':
      my_config = OtherConfig.load("https://api.my-server.dev/v1/config.json?secret=token")  # or .toml, .yaml, ...
      print(my_config.name)
      
      print(my_config.reference.numbers)
      
      
      my_config.update(numbers=[68, 70])
  ```
  The second argument of `.load_into` and the first argument of `.load` (which is `"example_from_readme.toml"` in the
  examples above), can be either a string or a Path to a file, a raw dictionary with data, a URL or empty.
  You can also use a list of these options to combine data sources.
  If it is left empty, the `pyproject.toml` will be used. You can supply a `key='tool.mytool.myconf'` to specify which
  section of the file should be read. For HTTP authentication, currently you can use http basic
  auth (`https://user:pass@host` or query parameters (like `?token=...`)).
  Other authentication methods are not currently supported.
  More examples can be found in [examples](https://github.com/trialandsuccess/configuraptor/blob/master/examples).

  - [`.toml`](https://docs.fileformat.com/programming/toml/): supports the most types (strings, numbers, booleans,
    datetime, lists/arrays, dicts/tables);
  - [`.json`](https://www.w3schools.com/js/js_json_datatypes.asp): supports roughly the same types as toml (except
    datetime);
  - [`.yaml`](https://docs.fileformat.com/programming/yaml): supports roughly the same types as toml, backwards compatible
    with JSON;
  - [`.env`](https://pypi.org/project/python-dotenv/): only supports strings. You can use `convert_types=True` to try to
    convert to your annotated types;
  - [`.ini`](https://docs.python.org/3/library/configparser.html): only supports strings. You can use `convert_types=True`
    to try to convert to your annotated types;
  For other file types, a custom Loader can be written.
  See [examples/readme.md#Custom File Types](https://github.com/trialandsuccess/configuraptor/blob/master/examples/readme.md#custom-file-types)

  You can also parse a [`struct`-packed](https://docs.python.org/3/library/struct.html) bytestring into a config class.
  For this, you have to use `BinaryConfig` with
  `BinaryField`s. Annotations are not supported in this case, because the order of properties is important for this type
  of config.
  ```python
  from configuraptor import BinaryConfig, BinaryField
  class MyBinaryConfig(BinaryConfig):
      
      
      number = BinaryField(int)
      string = BinaryField(str, length=5)
      decimal = BinaryField(float)
      double = BinaryField(float, format="d")
      other_string = BinaryField(str, format="10s")
      boolean = BinaryField(bool)
  MyBinaryConfig.load(
      b'*\x00\x00\x00Hello\x00\x00\x00fff@\xab\xaa\xaa\xaa\xaa\xaa\n@Hi\x00\x00\x00\x00\x00\x00\x00\x00\x01')
  ```

  `configuraptor` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

  [See CHANGELOG.md](https://github.com/trialandsuccess/configuraptor/blob/master/CHANGELOG.md)


pkgId: e5777a310fc4e3d50f4ad515593dcfc2f06aa65fad544c3433ad53899664bc3f
name: python-configurator
arch: src
version: 3.2.0
epoch: 0
release: 1
summary: A library for building a configuration store from one or more layered configuration sources
url: https://github.com/Simplistix/configurator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configurator-3.2.0-1.src.rpm
checksum_type: sha256
description:
  |CircleCI|_  |Docs|_
  This is a Python library for building a configuration store
  from one or more layered configuration sources.
  These are most commonly files, with YAML, TOML and JSON support included
  and other formats easily added.
  The sources don't have to be files, and support is included for both environment
  variables and command line options.
  In addition to an easy to use interface, configuration information is also made available
  as nested, simple python data types so that you can validate the schema of your configuration
  using the tool of your choice.
  Quickstart
  ~~~~~~~~~~
      fs.create_file('/etc/my_app/config.yaml',
                     contents='cache:\n  location: /var/my_app/\n')
      fs.create_dir('/var/logs/myapp/')
      replace('os.environ.MYAPP_THREADS', '2', strict=False)
      replace('os.environ.MYAPP_CACHE_DIRECTORY', '/var/logs/myapp/', strict=False)
      replace('sys.argv', ['myapp.py', '--threads', '3', '--max-files', '200'])
      from pprint import pprint
  To install the library, go for:
    pip install configurator[yaml,toml]
  Here's how you would handle a layered set of defaults, system-wide config
  and then optional per-user config:
      from configurator import Config
      defaults = Config({
          'cache': {
              'location': '/tmp/my_app',
              'max_files': 100,
          },
          'banner': 'default banner',
          'threads': 1,
      })
      system = Config.from_path('/etc/my_app/config.yaml')
      user = Config.from_path('~/.my_app.yaml', optional=True)
      config = defaults + system + user
  Now, if we wanted configuration from the environment and command line
  arguments to override those provided in configuration files, we could do so
  as follows:
      import os
      from argparse import ArgumentParser
      from configurator import convert, target, required
      config.merge(os.environ, {
          convert('MYAPP_THREADS', int): 'threads',
          required('MYAPP_CACHE_DIRECTORY'): 'cache.location',
      })
      parser = ArgumentParser()
      parser.add_argument('--threads', type=int)
      parser.add_argument('--max-files', type=int)
      args = parser.parse_args()
      config.merge(args, {
          'threads': 'threads',
          'max_files': 'cache.max_files',
      })
  To check the configuration we've accumulated is sensible we can use a data validation library
  such as `Voluptuous`__:
  __ https://github.com/alecthomas/voluptuous
      from os.path import exists
      from voluptuous import Schema, All, Required, PathExists
      schema = Schema({
          'cache': {'location': All(str, PathExists()), 'max_files': int},
          'banner': Required(str),
          'threads': Required(int),
          })
      schema(config.data)
  So, with all of the above, we could use the following sources of configuration:
  >>> import os, sys
  >>> print(open('/etc/my_app/config.yaml').read())
  cache:
    location: /var/my_app/
  <BLANKLINE>
  >>> os.environ['MYAPP_THREADS']
  '2'
  >>> os.environ['MYAPP_CACHE_DIRECTORY']
  '/var/logs/myapp/'
  >>> sys.argv
  ['myapp.py', '--threads', '3', '--max-files', '200']
  With the above sources of configuration, we'd end up with a configuration store that we can use as
  follows:
  >>> config.cache.location
  '/var/logs/myapp/'
  >>> config.cache.max_files
  200
  >>> config.banner
  'default banner'
  >>> config.threads
  3


pkgId: cfbc475e372c4a47e1b3633f148ae8c343432ad07c68c985e8ebd28b82c86f20
name: python-configure-dms-viz
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Configure your data for visualization with dms-viz.github.io
url: https://github.com/dms-viz
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configure-dms-viz-1.6.0-1.src.rpm
checksum_type: sha256
description:
  `configure_dms_viz` is a python command line utility that formats your data for the visualization tool [`dms-viz`](https://dms-viz.github.io/). [`dms-viz`](https://dms-viz.github.io/) is a tool that helps you take quantitative data associated with mutations to a protein and analyze that data using intuitive visual summaries and an interactive 3D protein structure. Visualizations created with dms-viz are **flexible**, **customizable**, and **shareable**.
  For more information on getting started with `dms-viz`, check out the [documentation](https://dms-viz.github.io/dms-viz-docs/).
  You can read our motivation for creating `dms-viz` in our [JOSS paper](https://doi.org/10.21105/joss.06129). If you use `dms-viz` in published research, please cite us:
  > Hannon et al., (2024). *dms-viz*: Structure-informed visualizations for deep mutational scanning and other mutation-based datasets. Journal of Open Source Software, 9(99), 6129, <https://doi.org/10.21105/joss.06129>

  To use `configure-dms-viz`, you must ensure that you have the correct version of `Python` (`>= 3.9`) installed on your operating system. You can check this by running:
  ```bash
  python --version
  ```
  The version number displayed should `>= 3.9.x`.

  `configure-dms-viz` is distributed on [PyPI](https://pypi.org/), allowing you to install `configure-dms-viz` using `pip`. To install the latest version of `configure-dms-viz`, run the following command:
  ```bash
  pip install configure-dms-viz
  ```
  `configure-dms-viz` should now be installed. You can double-check that the installation worked by running the following command:
  ```bash
  configure-dms-viz --help
  ```
  You should see a help message printed to the terminal.

  `configure_dms_viz` takes input data consisting of a quantitative metric associated with mutations to a protein sequence and returns a `.json` specification file that is uploaded to [`dms-viz`](https://dms-viz.github.io/) to create an interactive visualization. Below is a simple tutorial on `configure-dms-viz`; however, for a detailed guide to the `configure-dms-viz` API, check out the [documentation](https://dms-viz.github.io/dms-viz-docs/preparing-data/command-line-api/).
  `configure-dms-viz` has two commands, `format` and `join`. To format a single dataset for `dms-viz`, you execute the `configure-dms-viz format` command with the required and optional arguments as needed:
  ```bash
  configure-dms-viz format \
      --name <experiment_name> \
      --input <input_csv> \
      --metric <metric_column> \
      --structure <pdb_structure> \
      --output <output_json> \
      [optional_arguments]
  ```
  The information that is required to make a visualization file for **`dms-viz`** is as follows:
  1. `--name`: The name of your dataset as you'd like it to appear in the visualization.
  2. `--input`: The file path to your input data.
  3. `--metric`: The name of the column that contains the metric you want to visualize.
  4. `--structure`: The protein structure that you want to use as a 3D model.
  5. `--output`: The file path of the output `.json` file.
  The remaining arguments are _optional_ and configure the protein, appearance, and data included in your final visualization.
  Now, let's use `configure-dms-viz` with a minimal example. The example data is included in this GitHub repository under `tests/`. If you want to follow along, clone the repository and run the following command from the root of the directory.

  ```bash
  configure-dms-viz format \
     --name "REGN mAb Cocktail" \
     --input tests/SARS2-RBD-REGN-DMS/input/REGN_escape.csv \
     --metric "mut_escape" \
     --metric-name "Escape" \
     --sitemap tests/SARS2-RBD-REGN-DMS/sitemap/sitemap.csv \
     --structure "6XDG" \
     --included-chains "E" \
     --condition "condition" \
     --condition-name "Antibody" \
     --output ./REGN_escape.json
  ```
  First, we've specified that we want the _name_ of the dataset as it appears in `dms-viz` to be `REGN mAb Cocktail` (named after the Regeneron Antibody cocktail therapuetic for SARS-CoV-2). This isn't so crucial when there is only a single dataset; however, when combining multiple datasets with the `join` command, it's necessary to have unique and descriptive names.
  Next, we've pointed to the [input data](https://github.com/dms-viz/configure_dms_viz/blob/main/tests/SARS2-RBD-REGN-DMS/input/REGN_escape.csv) containing quantitative scores that measure the degree of antibody escape from the `REGN mAb Cocktail`. For details on the specific requirements for input data, check out the [Data Requirements](https://dms-viz.github.io/dms-viz-docs/preparing-data/data-requirements/) guide in the documentation. In addition to specifying the input data, we told `configure-dms-viz` which column contains the escape scores (`mut_escape`) and what to call that column in the plots (`Escape`).
  Then, we've specified a [sitemap](https://github.com/dms-viz/configure_dms_viz/blob/main/tests/SARS2-RBD-REGN-DMS/sitemap/sitemap.csv). This is optional information that describes how the sites in your input data correspond to your 3D protein structure. If you do not provide a sitemap, the sites in the input data are assumed to correspond one-to-one with the sites in the protein structure.
  After that, we specified a protein structure. In this case, we're fetching `6XDG` from the [RSCB PDB](https://www.rcsb.org/) and only showing our data on chain `E` of that structure.
  Finally, in this particular dataset, we have multiple 'conditions' for each mutation; this means there are multiple measurements (`mut_escape`) for each mutation/position (corresponding to escape from different antibodies). We need to specify the column that contains these `condition`s. In `dms-viz`, an interactive legend will let you toggle between conditions.
  The result of this command should be a message printed to the terminal providing some basic information from the `configure-dms-viz format` command that looks like this:
  **Output**
  ```md
  Formatting data for visualization using the 'mut_escape' column from 'tests/SARS2-RBD-REGN-DMS/input/REGN_escape.csv'...
  Using sitemap from 'tests/SARS2-RBD-REGN-DMS/sitemap/sitemap.csv'.
  'protein_site' column is not present in the sitemap. Assuming that the reference sites correspond to protein sites.
  About 95.98% of the wildtype residues in the data match the corresponding residues in the structure.
  About 4.02% of the data sites are missing from the structure.
  Success! The visualization JSON was written to './REGN_escape.json'
  ```
  That's how you use `configure-dms-viz` to format a single dataset! You can also combine multiple datasets into a single `.json` specification file using the `configure-dms-viz join` command. For more details on combining datasets to jointly visualize with `dms-viz`, check out the [API](https://dms-viz.github.io/dms-viz-docs/preparing-data/command-line-api/#configure-dms-viz-join).

  `configure-dms-viz` was developed using `Python` (>=3.9) and the [`click`](https://click.palletsprojects.com/en/8.1.x/) library.
  To contribute to `configure-dms-viz`, follow the instructions [here](https://dms-viz.github.io/dms-viz-docs/project-info/contributing-guide/#contributing-to-configure-dms-viz) for setting up a development environment.

  [`pytest`](https://docs.pytest.org/en/8.0.x/) is the testing framework for `configure-dms-viz`.
  The command line interface (CLI) of `configure-dms-viz` is tested using four example datasets from different projects and labs that cover 100% of its flags and features. These four examples are:
  1. [Deep mutational scanning of the SARS-CoV-2 Spike protein](/tests/SARS2-Omicron-BA1-DMS/README.md)
     Authors: **Bernadeta Dadonaite**, **Katharine H D Crawford**, **Caelan E Radford**, Ariana G Farrell, Timothy C Yu, William W Hannon, Panpan Zhou, Raiees Andrabi, Dennis R Burton, Lihong Liu, David D. Ho, Richard A. Neher, **Jesse D Bloom**
     Manuscript: https://www.sciencedirect.com/science/article/pii/S0092867423001034?via%3Dihub
  2. [Deep mutational scanning of the HIV BF520 strain Envelope protein](/tests/HIV-Envelope-BF520-DMS/README.md)
     Authors: **Caelan E. Radford**, Philipp Schommers, Lutz Gieselmann, Katharine H. D. Crawford, Bernadeta Dadonaite, Timothy C. Yu, Adam S. Dingens, Julie Overbaugh, Florian Klein, **Jesse D. Bloom**
     Manuscript: https://www.sciencedirect.com/science/article/pii/S1931312823002184?via%3Dihub
  3. [Phylogenetic fitness estimates of every SARS-CoV-2 protein](/tests/SARS2-Mutation-Fitness/README.md)
     Authors: **Jesse D. Bloom**, **Richard A. Neher**
     Manuscript: https://www.biorxiv.org/content/10.1101/2023.01.30.526314v2
  4. [Deep mutational scanning of the Influenza PB1 polymerse subunit](/tests/IAV-PB1-DMS/README.md)
     Authors: **Yuan Li**, Sarah Arcos, Kimberly R. Sabsay, Aartjan J.W. te Velthuis, **Adam S. Lauring**
     Manuscript: https://www.biorxiv.org/content/10.1101/2023.08.27.554986v1.full
  In addition to these test datasets, there are specific tests using dummy data for the key formatting functions. To run the tests, execute the following command from the root of the directory:
  ```
  poetry run pytest
  ```


pkgId: c036b05a1135906ff7aec122db2ab3acb608bcf25d88ff5ef544d1e1b3913575
name: python-configurematic
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Put configuration from one file into multiple files
url: https://pypi.org/project/configurematic/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-configurematic-0.0.1-1.src.rpm
checksum_type: sha256
description:
  Have you found yourself in the situation where you have the same configuration
  in multiple configuration files?  We all know config should be in one place
  only but sometimes we have several `.env` files, for example, for related apps,
  and `env` file for docker plus some configuration in places like
  `pyproject.toml`, `package.json`, etc.

  Configurematic lets you write a single `.env` file (called `config.env` by
  default) and have variable from that file substituted into any other file.
  It is a lightweight, compact script with `python-dotenv` as its only
  dependency.



  Install with

  ```shell
  pip install configurematic
  ```

  Alternatively, install it with `pipx`:

  ```shell
  pipx install configurematic
  ```



  First create your `config.env` file.  An example might be

  ```shell
  APP_NAME="My App Name"
  DBPASSWORD="SecretPassword"
  ```

  This is parsed by `dotenv` so you can have blank lines, comments starting
  with `#`, etc.

  Next create files you want to substitute these into.  Prefix them with
  `example-` (though this can be overridden with the `--prefix` option).

  For example you might have

  `example-env`:

  ```shell
  APP_NAME="__APP_NAME__"
  ```

  `app/example-.env`:

  ```shell
  APP_NAME="__APP_NAME__"
  PWD="__DBPASSWORD__"
  ```

  Anything between the `__` pairs is substituted by the variable matching that
  name in your `config.env`, provided it exists.

  Your `example-*` files don't have to be `.env`-like and can have multiple
  variables on one line, eg

  ```python
  print("The current version is __MAJOR__VERSION__.__MINOR_VERSION__")
  ```

  Variables starting and ending with `__` will only be substituted if they
  are in your `config.env` file.

  Next, create a file listing your templates (without the `example-` prefix),
  one per line:

  `files.txt`:

  ```
  env
  app/.env
  ```

  This file can also contain blank lines and comments starting with `#`.
  Alternatively you can list the files on the command line.  Whitespace at the
  start and end of each line though is stripped, therefore filenames cannot
  start or end with a whitespace character (not that they should).  Whitespace
  inside a filename is fine.  They also cannot start with a `#`, though it can
  appear elsewhere in the filename.

  If for some reason you do want a space at the beginning or end of a filename
  or you do want a file to start with `#`, list the files on the command line
  instead of in a file.

  Finally, run Configurematic:

  ```shell
  configurematic -f files.txt
  ```

  Next to each of your `example-*` files you will see a new file without
  the `example-` prefix.

  Run it again and the new files will be overwritten (warning, you will
  lose any manual changes) but the old versions will be copied to a new file
  next to it with a `.old` suffix (which can be overridden with `--backup-ext`).



  Use `--conf-file` or `-c` to use a different file instead of `config.env`.

  To output all the files to a different directory (with the same directory
  hierarchy within it), use `--outdir` or `-o`.

  Change the prefix with `-p` or `--prefix`.

  `-r` or `--recursive` turns on recusion (see below).

  Change `__` to something else with `-d` or `--delimeter`.

  Change the backup extension with `-b` or `--backup-ext`.  Set this to `""`
  to not write backup files.

  Turn off verbose output with `-q` or `--silent`.

  Instead of listing the files in a file pointed to with `-f`, you can list
  them on the command line, eg:

  ```shell
  configurematic env app/.env
  ```


  You can make substitution recursive with the `-r` or `--recursive` flag.

  Say you have the following in your `config.env`:

  ```shell
  VAR1="__VAR2__"
  VAR2="Value Here"
  ```

  and the following in a template:

  ```shell
  MY_VAR1="__VAR1__"
  ```

  The result will be

  ```shell
  MY_VAR1="Value Here"
  ```

  By default, recursion is off, meaning only one level of substitution is made.



  If you edit a generated file, then run Configurematic again, you will lose
  your changes (though they are kept in the backup file).  Thus it is best
  to edit your `example-*` files only (and of course `config.env`), and rerun
  Configurematic to generate the files again.



  Configurematic is distributed under the Apache licence.



  Matthew Baker is an IT manager at ETH Zurich.  He also does consultancy work.
  Contact him at `matt@mattbaker.ch`.

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


pkgId: 9d0a634c61b6050fb14e721d85d42bedd792e8bf87b41dafd12bae0d041889cf
name: python-confini
arch: src
version: 0.6.5
epoch: 0
release: 1
summary: Parse, verify and merge all ini files in a single directory
url: https://gitlab.com/nolash/python-confini
rpm_license: WTFPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confini-0.6.5-1.src.rpm
checksum_type: sha256
description:
  Configuration parser that process all sections and values in all `ini` files in a directory.



  ```
  import confini

  c = confini.Config('/path/to/config/dir')
  c.process()

  print(c.get('FOO_BAR_BAZ'))

  ```



  The values are stored in a single key/value dictionary, with section and name separated by _underscore_ and all letters transformed to uppercase.

  Consider this value in an ini section:

  ```
  [foO]
  bar_baz = 42
  ```

  This will be stored in the `confini` store with `FOO_BAR_BAZ` as the key.



  By default, the value of any environment variable matching a store key will overwrite the corresponding value in the store.

  A prefix can be provided on instantiation to define a separate namespace for environment variable overrides:

  ```
  >>> os.environ.set('FOO_BAZ_BAZ', 666)
  >>> c = config.Config('/path/to/config/dir')
  >>> c.process()
  >>> print(c.get('FOO_BAR_BAZ'))
  666
  >>> c = config.Config('/path/to/config/dir', 'XXX')
  >>> c.process()
  >>> print(c.get('FOO_BAR_BAZ'))
  42
  >>> os.environ.set('XXX_FOO_BAZ_BAZ', 13)
  >>> c = config.Config('/path/to/config/dir', 'XXX')
  >>> c.process()
  >>> print(c.get('FOO_BAR_BAZ'))
  13
  ```



  Keys can be set as required, and after processing independently validated:

  ```
  >>> c = config.Config('/path/to/config/dir')
  >>> c.require('BAR_BAZ', 'FOO')
  >>> c.process()
  >>> c.validate()
  True
  >>> c = config.Config('/path/to/config/dir')
  >>> c.require('BAR_BAZ_BAZ', 'FOO')
  >>> c.process()
  >>> c.validate()
  False
  ```



  The string representation of the confini object is a list of all stored values, one on each line.

  Display of individual values can be suppressed:

  ```
  >>> c = config.Config('/path/to/config/dir')
  >>> c.process()
  >>> print(c)
  FOO_BAR_BAZ = 666
  >>> c.censor('BAR_BAZ', 'FOO')
  >>> print(c)
  ***
  ```



  Values can be **GNUPG** encrypted by saving them in individual encrypted files providing the filename as value argument wrapped in a gpg directve:

  ```
  [foo]
  BAR_BAZ = !gpg(foo_bar_baz.asc)
  ```

  Decryption mode is on by default, and can be deactivated on instantiation:

  ```
  >>> c = config.Config('/path/to/config/dir')
  >>> c.process()
  >>> c.get()
  666
  >>> c = config.Config('/path/to/config/dir', decrypt=False)
  >>> c.process()
  >>> c.get()
  !gpg(foo_bar_baz.asc)
  ```

  The user keyring in the default location is used for decryption, which may be overridden as usual with the `GNUPGHOME` environment variable.


pkgId: eb6f75dcc318d6740ca10f9cf7ba7544046e435b55ab48f2e0a047d4167e0fb3
name: python-confio
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Configurations IO for various of data sources with unified interfaces.
url: https://gitee.com/wangankeji/confio
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confio-0.5.0-1.src.rpm
checksum_type: sha256
description:
  此组件用于对本地配置进行读写，目前支持以下类型作为配置数据源：

  - `ConfFS` 文件系统
  - `ConfMySQL` MySQL数据库
  - `ConfDameng` 达梦数据库
  - `ConfConsul`

  在安装时，使用不同的数据源类型，需要安装不同的依赖包。



  - [ ] 配置值加密支持
  - [ ] 其它配置源支持
      - [ ] Redis
      - [ ] sqlite
      - [ ] ini
      - [ ] yaml
      - [ ] properties
      - [ ] toml



  此组件针对不同的数据源提供了相同的数据读写接口，以避免开发过程中，读写不同数据源中配置的差异，以及无缝切换数据源。



  配置文件的存储基于 JSON 格式，并且扁平化读写。 配置项在配置文件中，以数组的方式存在，每项为一个配置项。

  可使用的配置字段如下：

  - `name` 配置项名称
  - `id_` 配置项标识，建议均为小写
  - `value` 系统值
  - `user_value` 用户值
  - `desc` 描述
  - `enabled` 是否启用，默认为 `true` (保留字)，暂未使用

  其中，`value` 为系统设置的值（或者叫做默认值），`user_value` 为用户设置的值，通过 `.value` 取值时，会优先获取 `user_value`
  ，为空时会使用 `value`

  字段名称 `value` 可以添加一些类型修饰符，详见 [#类型修饰符](#类型修饰符)

  > 一般来说，在项目的开发过程中，使用 json 数据格式来对配置进行管理。
  > 而在线上运行时，使用数据库对配置进行管理。



  类型修饰符用于简化一些数据的写法。只能写在 `value` 字段名上，其作用于 `value` 和 `user_value` 的值，写法如下：

  ```json
  {
    "value:path": "../to/path"
  }
  ```

  其中的 `:path` 就是修饰符，可选值好如下：

  0. 不指定类型
  1. `path` 其值为一个文件系统的路径
      - 在这种情况下，字段名称 `type` 值为 `path`
      - 其值可以是绝对路径，或者相对路径（相对于项目根目录）。 当其为相对路径时，组件会自动计算出其绝对路径
      - 在这种情况下，需要通过 `ValueParser.PATH_ROOT=` 或者 `ValueParser(path_root=)`
  2. `expr` 其值为一个表达式
      - 在这种情况下，字段名称 `type` 值为 `expr`
      - 一般来说，仅仅在字段的数据类型为数值时才应该指定这种类型
      - 其值应该是一个合法的 python 表达式（其中不能包含需要通过外部导入的模块）
      - 例：`60 * 10`, `5 * (20 + 8 * (27 - 4))`
      - 通过 `.value` 得到的值单位均为 数值类型 **int**
  3. `size` 其值为文件大小
      - 在这个情况下，字段名称 `type` 值为 `size`
      - 一般来说，仅仅在配置文件/占用空间大小等需要使用存储单位时才使用此值
      - 使用的进制为 `1024`
      - 写法：允许使用 `k/m/g/t` 作为单位
      - 例：`10m`, `50g`
      - 通过 `.value` 得到的值单位均为 数值类型 **byte**
  3. `time` 其值为时间范围（多少年，月，天，小时，分，秒）
      - 在这个情况下，字段名称 `type` 值为 `time`
      - 一般来说，仅仅在时间范围相关等需要使用时间存储单位时才使用此值
      - 写法：允许使用以下作为单位 **区分大小写**
          - `s` 秒（可以省略）
          - `m` 分钟
          - `h` 小时
          - `D` 天
          - `M` 月（一个月仅按30天计算）
          - `Y` 年（一年按365天计算）
      - 例：
          - `10m` 10 分钟
          - `500` 500 秒
          - `1h20m` 1 小时 20 分
      - 通过 `.value` 得到的值单位均为 数值类型 **秒**

  > 当指定类型修饰符时，`value` 和 `user_value` 的值必须是一个字符串



  配置文件 _/config/module1/conf.json_

  ```json
  [
    {
      "key": "foo",
      "value": "bar",
      "name": "test"
    },
    {
      "...": "..."
    }
  ]
  ```

  ```python
  from confio import ConfFS

  conf_root = '/config'

  conf = ConfFS(conf_root)

  conf.get('module1.conf.foo')

  conf.get('module1.conf.bar')

  conf.get('module1.conf.bar', default='foo')

  conf.match('module1.conf')
  ```



  **ConfFS** 基于文件系统 (JSON 格式) 的配置存储，其通过目录和文件进行模块分割。

  ```python
  from confio import ConfFS

  conf = ConfFS(conf_root='/config')
  ```

  `conf_root` 存放配置文件的根目录(应该是一个绝对路径)，所有的配置模块，基于此目录计算。

  > 此模块会自动缓存。在文件更改后会自动更新缓存(主动模式，即读取时才会更新)

  **ConfMySQL** 基于MySQL数据库的配置存储。

  > `ConfMySQL` 依赖 [dbutils](https://pypi.org/project/DBUtils/) 和 [PyMysql](https://pypi.org/project/PyMySQL/) 包。

  ```python
  from confio import ConfMySQL

  conf = ConfMySQL(
      database='database-name',
      host='127.0.0.1',
      port=3306,
      user='root',
      password='',
      charset='',
      table_name='conf_items'
  )
  ```

  > 在使用数据库时，其表名称默认为 `conf_items`

  可以指定一个值处理器 `ValueParser`，其用于处理字段 `type` 指定的不同类型。

  可以指定一个自定义的枚举类型，其用于扩展内置的 `ConfTypes` 枚举，在使用了自定义的 `type` 时会用到。

  在系统内使用了 `type=path` 时，那么需要通过以下方式指定根路径:

  ```python
  from confio import ValueParser, ConfItem


  ValueParser.PATH_ROOT = 'xxx'


  parser = ValueParser('xxx')
  ConfItem.parser = parser

  from enum import Enum


  class MyConfTypes(Enum):
      XXX = 'xxx'
      """
      支持 type="xxx": "key:xxx": 123
      """


  ValueParser.enum_class_ext = MyConfTypes
  ```



  ```python
  from confio import ValueParser, ConfTypes


  def value_handler(parse_type: ConfTypes, raw_value, parsed_value, prev_value):
      return prev_value


  ValueParser.add_interceptor(value_handler)
  ```



  在以下文档中，

  - `fs.abc()` 表示 `ConfFS().abc()`
  - `db.abc()` 表示 `ConfMySQL().abc()`



  加载所有配置项

  `load() -> List[ConfItem]`

  参数：

  _无_

  返回：

  所有配置项的列表



  获取指定配置项的值。

  `get(id_: str, default=None, value_only=True) -> Union[ConfItem, Any]`

  参数：

  - `id_` 指定的配置项 ID。其必须是与配置名称完全一致
  - `default` 指定的默认值。当指定的配置项不存在时，使用此值
  - `value_only` 是否仅返回配置项的值。指定为 `True` 时表示仅返回配置项的值， 为 `False` 时表示返回 `ConfItem` 对象

  返回：

  返回一个 `ConfItem` 对象(`value_only=False`)或具体的某个字段的值



  获取匹配指定前缀的所有配置项的值。

  `match(prefix: str, value_only=True, fullkey=False) -> Dict[str, Union[ConfItem, Any]]`

  参数：

  - `prefix` 指定的前缀。其必须按模块指定，如： 存在模块 `aaa.bbb.ccc`，只能通过 `aaa` 或 `aaa.bbb` 进行匹配， 不能通过 `aa` 或
    `aaa.b` 或者 `aaa.bbb.ccc`
    进行匹配
  - `value_only` 是否仅返回配置项的值。指定为 `True` 时表示仅返回配置项的值， 为 `False` 时表示返回 `ConfItem` 对象
  - `fullkey` 是否返回完整的 `id_`

  返回：

  配置项的键值对集合。

  当 `fullkey=True` 时，键名称为键名全称，否则为除去 `prefix` 后的名称

  如：

  `prefix='aaa'`，有配置项 `aaa.bbb.ccc=5`， 当 `fullkey=True` 时，返回 `{'aaa.bbb.ccc': 5}`； 当 `fullkey=False`
  时，返回 `{'bbb.ccc': 5}`；



  添加/更新配置项的值。

  `set(id_: str, value, update_sys_value=False, allow_add=False):`

  参数：

  - `id_` 指定的配置项
  - `value` 指定配置项的值，当此值类型为 `ConfItem` 时，会更新配置项的所有属性
  - `update_sys_value` 是否更新系统值，默认情况下更新用户值
  - `allow_add` 在指定项不存在时，是否允许添加新的配置项

  返回：

  _无_

  注意：当在更新用户值时， confio 会检查用户值与系统值的数据类型是否一致。



  批量添加/更新配置项的值。

  `set(items: Union[Dict[str, Any], List[ConfItem]], prefix: str = None, update_sys_value=False, allow_add=False):`

  参数：

  - `items` 指定的配置项
  - `prefix` 指定的配置项使用的前缀。在指定了此值后，会给 `items` 中的每一项的ID添加此前缀
  - `value` 指定配置项的值
  - `update_sys_value` 在 `value` **不**为 `ConfItem` 类型时有效。是否新增为系统值，默认情况下新增为用户值
  - `allow_add` 在指定项不存在时，是否允许添加新的配置项

  返回：

  _无_



  移除指定的配置项。

  `remove(id_: Union[str, List[str], Tuple[str]]) -> Optional[Union[ConfItem, List[ConfItem]]]`

  > 注意：指定的项不存在时，此项操作会被忽略。

  参数：

  - `id_` 要移除的配置项 ID(或 ID集合)

  返回：

  _无_



  为了便于对读写的值进行处理，可以实现钩子来对其进行自定义处理。

  ```python
  from confio import IHook, ConfItem


  class MyHook(IHook):
      def read_value(self, item: ConfItem):
          return True, 'customize_value'

      def read_raw_value(self, item: ConfItem):
          return True, 'customize_value'


  ConfItem.hooker = MyHook()
  ```


pkgId: ef10e2ec30640bbbc09159da5df70c2a457009d1bbc4d4fdc1e95b1300b6605b
name: python-confit
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Smart configuration framework
url: https://pypi.org/project/confit/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confit-0.6.0-1.src.rpm
checksum_type: sha256
description:
  ![Tests](https://img.shields.io/github/actions/workflow/status/aphp/confit/tests.yml?branch=main&label=tests&style=flat-square)
  [![Documentation](https://img.shields.io/github/actions/workflow/status/aphp/confit/documentation.yml?branch=main&label=docs&style=flat-square)](https://aphp.github.io/confit/latest/)
  [![PyPI](https://img.shields.io/pypi/v/confit?color=blue&style=flat-square)](https://pypi.org/project/confit/)
  [![Coverage](https://raw.githubusercontent.com/aphp/confit/coverage/coverage.svg)](https://raw.githubusercontent.com/aphp/confit/coverage/coverage.txt)




  Confit is a complete and easy-to-use configuration framework aimed at improving the reproducibility
  of experiments by relying on the Python typing system, minimal configuration files and
  command line interfaces.



  Install the library with pip:

  <div class="termy">

  ```bash
  pip install confit
  ```

  </div>

  Confit only abstracts the boilerplate code related to configuration and
  leaves the rest of your code unchanged.

  Here is an example:

  <h5 a><strong><code>script.py</code></strong></h5>

  ```diff
  + from confit import Cli, Registry, RegistryCollection

  + class registry(RegistryCollection):
  +     factory = Registry(("test_cli", "factory"), entry_points=True)

  + @registry.factory.register("submodel")
  class SubModel:
      
      def __init__(self, value: float, desc: str = ""):
          self.value = value
          self.desc = desc


  + @registry.factory.register("bigmodel")
  class BigModel:
      def __init__(self, date: datetime.date, submodel: SubModel):
          self.date = date
          self.submodel = submodel

  + app = Cli(pretty_exceptions_show_locals=False)


  + @app.command(name="script", registry=registry)
  def func(modelA: BigModel, modelB: BigModel, seed: int = 42):
      assert modelA.submodel is modelB.submodel
      print("modelA.date:", modelA.date.strftime("%B , %Y"))
      print("modelB.date:", modelB.date.strftime("%B , %Y"))

  + if __name__ == "__main__":
  +     app()
  ```


  Create a new config file

  The following also works with YAML files

  <h5 a><strong><code>config.cfg</code></strong></h5>

  ```ini

  [script]
  modelA = ${modelA}
  modelB = ${modelB}


  [modelA]
  @factory = "bigmodel"
  date = "2003-02-01"

  [modelA.submodel]
  @factory = "submodel"
  value = 12

  [modelB]
  date = "2003-04-05"
  submodel = ${modelA.submodel}
  ```

  and run the following command from the terminal

  <div class="termy">

  ```bash
  python script.py --config config.cfg --seed 43
  ```

  </div>

  You can still call the `function` method from your code, but now also benefit from
  argument validation !

  ```python
  from script import func, BigModel, SubModel


  from confit.utils.random import set_seed

  seed = 42
  set_seed(seed)

  submodel = SubModel(value=12)
  func(
      
      modelA=BigModel(date="2003-02-01", submodel=submodel),
      
      modelB=dict(date="2003-04-05", submodel=submodel),
      seed=seed,
  )
  ```

  ```
  modelA.date: February 1, 2003
  modelB.date: April 5, 2003
  ```



  You can also serialize registered classes, while keeping references between instances:

  ```python
  from confit import Config

  submodel = SubModel(value=12)
  modelA = BigModel(date="2003-02-01", submodel=submodel)
  modelB = BigModel(date="2003-02-01", submodel=submodel)
  print(Config({"modelA": modelA, "modelB": modelB}).to_str())
  ```

  ```ini
  [modelA]
  @factory = "bigmodel"
  date = "2003-02-01"

  [modelA.submodel]
  @factory = "submodel"
  value = 12

  [modelB]
  @factory = "bigmodel"
  date = "2003-02-01"
  submodel = ${modelA.submodel}
  ```



  You also benefit from informative validation errors:

  ```python
  func(
      modelA=dict(date="hello", submodel=dict(value=3)),
      modelB=dict(date="2010-10-05", submodel=dict(value="hi")),
  )
  ```

  ```
  ConfitValidationError: 2 validation errors for __main__.func()
  -> modelA.date
     invalid date format, got 'hello' (str)
  -> modelB.submodel.value
     value is not a valid float, got 'hi' (str)
  ```




  Visit the [documentation](https://aphp.github.io/confit/) for more information!



  We would like to thank [Assistance Publique – Hôpitaux de Paris](https://www.aphp.fr/)
  and [AP-HP Foundation](https://fondationrechercheaphp.fr/) for funding this project.

rpm_license:
  Copyright 2023 Assistance Publique - Hôpitaux de Paris  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: c5beba7169c688c953f685d98fcc08d52e3134a528afc804adae280a7852109b
name: python-conflator
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/ecmwf/conflator/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conflator-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  Load small app configurations from environment variables, command line arguments and config files, according to a pydantic model.

description:
  ![conflator logo](docs/conflator.png)

  > [!WARNING]
  > This project is under development and not yet feature complete or tested.

  > [!WARNING]
  > This project is BETA and will be experimental for the forseable future. Interfaces and functionality are likely to change, and the project itself may be scrapped. DO NOT use this software in any project/software that is operational.

  Conflator is a configuration-handling library for Python. It is designed to simplify the handling of configuration from multiple sources, such as environment variables, command line arguments, and configuration files. As an application or library developer, you specify your configuration schema with a Pydantic model, and conflator will handle the rest.

  Conflator loads configuration in the following order:

  1. Default values specified in the Pydantic model
  2. System-wide configuration in /etc/appname/config.json (and yaml)
  3. User configuration in ~/.appname.json (and yaml)
  4. Additional configuration files and values provided as command line args (e.g. `-f filename` or `--set value.deeper=foo`)
  4. Environment variables
  5. Command-line arguments
  6. Dictionaries passed to the load method

  ...and then validates the merged configuration against the Pydantic model.

  <!-- > Conflate (/kənˈfleɪt/): combine (two or more sets of information, texts, ideas, etc.) into one. -->



  Conflator is available on PyPI:

  ```bash
  pip install conflator
  ```

  Or using poetry:

  ```bash
  poetry add conflator
  ```



  1. **Define Your Configuration Model**: Begin by defining your configuration schema using Pydantic models. Annotate your model fields with `EnvVar` and `CLIArg` for environment variable and command-line argument support, respectively.

  ```python
  from pydantic import Field
  from conflator import EnvVar, CLIArg, ConfigModel
  from annotated_types import Annotated

  class AppConfig(ConfigModel):

      host: str = "localhost"
      port: Annotated[int, EnvVar("PORT"), CLIArg("--port")] = 5432
      user: Annotated[str, EnvVar("USER"), CLIArg("--user"), Field(description="Your username")] = "foo"
  ```

  2. **Initialize Conflator**: Create an instance of the Conflator class, passing your application's name and the configuration model.

  ```python
  from conflator import Conflator

  config = Conflator(app_name="my_app", model=AppConfig).load()
  ```

  3. **Access Configuration**: Use the loaded configuration throughout your application, knowing that the configuration has been fully validated.
  ```python
  print(f"User: {config.user}")
  ```
  Try setting MY_APP_USER in the environment to see the value change, or use the `--user` flag to override the value.





  ```bash
  your-app -f ./config/base.yaml -f ./config/production.yaml
  ```


  ```python
  from annotated_types import Annotated
  from conflator import EnvVar, CLIArg, ConfigModel

  class DeeperConfig(ConfigModel):
      nested: Annotated[str, EnvVar("NESTED"), CLIArg("--nested")] = "default"

  class Config(ConfigModel):
      host: str = "localhost"
      port: int = 543
      deeper: DeeperConfig = DeeperConfig()
  ```


  ```bash
  config = Conflator(app_name="my_app", model=AppConfig).schema() # uses pydantic's schema method behind the scenes
  ```



  * CLI arguments and environment variables are defined per model type, not per model instance. This means that you cannot have different CLI arguments or environment variables for different instances of the same model. Some support for this may be added in the future.

  * Including ConfigModel's from other packages, to nest their configuration with yours, is possible. However, there is no way to resolve conflicts between CLI arguments and environment variable naming between two different config schemas. Some support for this may be added in the future.


pkgId: bbf2e8855e6a8628b2483184c8266036a64b5dd67c717047cf997660f24b1615
name: python-confluent_avro
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: An Avro SerDe implementation that integrates with the confluent
url: https://github.com/DhiaTN/confluent-avro-py
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confluent_avro-1.8.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/confluent_avro?label=Python)](https://pypi.org/project/confluent-avro/)
  [![Build Status](https://travis-ci.com/DhiaTN/confluent-avro-py.svg?branch=master)](https://travis-ci.com/DhiaTN/avrokafka-py)
  [![Maintainability](https://api.codeclimate.com/v1/badges/fd596527a28dcaea1a2d/maintainability)](https://codeclimate.com/github/DhiaTN/confluent-avro-py/maintainability)
  [![codecov](https://codecov.io/gh/DhiaTN/confluent-avro-py/branch/master/graph/badge.svg)](https://codecov.io/gh/DhiaTN/confluent-avro-py)
  [![PyPI version](https://badge.fury.io/py/confluent_avro.svg)](https://badge.fury.io/py/confluent_avro)
  [![PyPI - License](https://img.shields.io/pypi/l/confluent_avro?color=ff69b4&label=License)](https://opensource.org/licenses/Apache-2.0)

  <br />
  <p align="center">
    <h1 align="center">ConfluentAvro</h1>

    <p align="center">
      An Avro SerDe implementation that integrates with the <a href="https://www.confluent.io/confluent-schema-registry/">confluent schema registry</a> and serializes and deserializes data according to the defined <a href="http://docs.confluent.io/current/schema-registry/docs/serializer-formatter.html#wire-format">confluent wire format</a>.
      <br />
      <br />
      <a href="examples">View Demo</a>
      ·
      <a href="https://github.com/DhiaTN/confluent-avro-py/issues">Report Bug</a>
      ·
      <a href="https://github.com/DhiaTN/confluent-avro-py/issues">Request Feature</a>
    </p>
  </p>





  To solve [schema management](https://docs.confluent.io/current/schema-registry/index.html) issues and ensure compatibility in the development of Kafka-based applications, the confluent team introduced the schema registry to store and share the schema between the different apps and apply compatibility checks on each newly registered schema. To make the schema sharing easy, they extend the Avro binary format by prepending the schema id before the actual record instead of including the full schema.

  -» You can find more about Confluent and Schema Registry in [Confluent documentation](https://docs.confluent.io/current/schema-registry/index.html).



  ConfluentAvro implemented according to the above specification. Before publishing to Kafka topic, the library prepends the schema id to the generated Avro binary and when consuming from Kafka, it retrieves the schema id and fetches the schema from the registry before deserializing the actual data.

  The underline API will automatically register new schemas used for the data serialization and will fetch the corresponding schema when deserializing it. Newly registered schemas and fetched schemas are both cached locally to speed up the process for future records.

  » The ConfluentAvro's bullet points:

  - Supports the confluent wire format
  - Integrates with the confluent schema registry
  - Retries with exponential backoff if connection to registry failed
  - Implements caching at the schema registry level
  - The underline decoder/encoder is built once for the same schema and reused for all upcoming records
  - Can be integrated with different Kafka clients




  - [fastavro](https://fastavro.readthedocs.io/en/latest/) (check [fastavro benchmark](https://github.com/DhiaTN/avro-benchmarking-py3))
  - [requests](https://requests.readthedocs.io)



  ```shell script
  » pip install confluent-avro
  ```



  > Check [examples](examples) for a fully working demo.



  ```python
  from kafka import KafkaConsumer

  from confluent_avro import AvroKeyValueSerde, SchemaRegistry
  from confluent_avro.schema_registry import HTTPBasicAuth

  KAFKA_TOPIC = "confluent_avro-example-topic"

  registry_client = SchemaRegistry(
      "https://myschemaregistry.com",
      HTTPBasicAuth("username", "password"),
      headers={"Content-Type": "application/vnd.schemaregistry.v1+json"},
  )
  avroSerde = AvroKeyValueSerde(registry_client, KAFKA_TOPIC)

  consumer = KafkaConsumer(
      KAFKA_TOPIC,
      group_id="random_group_id",
      bootstrap_servers=["localhost:9092",]
  )

  for msg in consumer:
      v = avroSerde.value.deserialize(msg.value)
      k = avroSerde.key.deserialize(msg.key)
      print(msg.offset, msg.partition, k, v)
  ```



  ```python
  from kafka import KafkaProducer

  from confluent_avro import AvroKeyValueSerde, SchemaRegistry
  from confluent_avro.schema_registry import HTTPBasicAuth

  KAFKA_TOPIC = "confluent_avro-example-topic"

  registry_client = SchemaRegistry(
      "https://myschemaregistry.com",
      HTTPBasicAuth("username", "password"),
      headers={"Content-Type": "application/vnd.schemaregistry.v1+json"},
  )

  avroSerde = AvroKeyValueSerde(registry_client, KAFKA_TOPIC)

  producer = KafkaProducer(bootstrap_servers=["localhost:9092"])
  producer.send(
      KAFKA_TOPIC,
      key=avroSerde.key.serialize({...}, key_schema),
      value=avroSerde.value.serialize({...}, value_schema),
  )
  ```


pkgId: 891ffe2d87061dd54bcfda8f1bf59d1cfe64d4bc601a7efe8feccf4e3c88bb20
name: python-confluentfucci
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/confluentfucci/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confluentfucci-1.1.1-1.src.rpm
checksum_type: sha256
description:
  A suite of tools for analyzing large scale confluent FUCCI experiments

  ConfluentFUCCI has now been peer-reviewed and the publication is freely available [here](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0305491).  To cite please use:

  **Goldstien L, Lavi Y, Atia L (2024) ConfluentFUCCI for fully-automated analysis of cell-cycle progression in a highly dense collective of migrating cells. PLoS ONE 19(6): e0305491. https://doi.org/10.1371/journal.pone.0305491**


  This repo includes an integration and automation layer for running [CellPose](https://github.com/MouseLand/cellpose) (person-in-the-loop ML driven cell segentation) and TrackMate (cell tracking). Furthermore, a set of analysis and visualization tools for studying confluent cellular dynamics using a FUCCI stain are included.



  The recommended way for trying out ConfluentFUCCI is to use our prebuilt conainer image:

  ```shell
  docker run -it --rm \
      -v /var/run/docker.sock:/var/run/docker.sock \
      -p 8080:8080 \
      -p 9876:9876 \
      leogold/confluentfucci:latest
  ```

  This will start a container that will serve ConfluentFUCCI on [localhost:8080](http://localhost:8080) and a virtual desktop on [localhost:9876](http://localhost:9876). The app served using the above command does not require a GPU, which significantly affects segmentation time. Too speed up segmentation by leveraging your [CUDA compatible GPU](https://developer.nvidia.com/cuda-gpus), please use:

  ```shell
  docker run -it --rm \
      -v /var/run/docker.sock:/var/run/docker.sock \
      -p 8080:8080 \
      -p 9876:9876 \
      --gpus all \
      leogold/confluentfucci:latest
  ```


  To simplify deployment, please check out our [docker-compose.yaml](https://github.com/leogolds/ConfluentFUCCI/blob/main/containers/confluentfucci/docker-compose.yaml). Placing this file in the same path as your data should allow you to test the app using:

  ```shell
  docker compose up
  ```

  If a [CUDA compatible GPU](https://developer.nvidia.com/cuda-gpus) is availble on your system, make sure to uncomment:

  ```shell







  ```



  This project is set up using poetry. To install the dependencies, run `poetry install` from the root of the project.

  ```shell
  poetry install
  ```

  To add a new dependency, run `poetry add <dependency>` from the root of the project.

  ```shell
  poetry add <dependency>
  ```


  This project uses [pytest](https://docs.pytest.org/en/stable/) for testing. To run the tests, run `pytest` from the root of the project in the poetry shell.

  ```shell
  poetry run pytest
  ```

  There are sensible defaults for pytest setup in the `pyproject.toml` file. You can override these defaults by passing in command line arguments. For example, to run the tests with debug logging enabled, run `pytest --log-cli-level=DEBUG` from the root of the project.

  ```shell
  poetry run pytest --log-cli-level=DEBUG
  ```


pkgId: 1e46517a509a01306d20dd5949b9d41f5146f7aabd1b86c95098b1ede53cb71b
name: python-conflux-web3
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Python SDK for Conflux network
url: https://github.com/conflux-chain/python-conflux-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conflux-web3-1.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/conflux-chain/python-conflux-sdk/dev?urlpath=tree/docs/en/examples/01-quickstart.ipynb)
  [![Documentation Status](https://readthedocs.org/projects/python-conflux-sdk/badge/?version=latest)](https://python-conflux-sdk.readthedocs.io/en/latest/?badge=latest)
  [![gitlocalized ](https://gitlocalize.com/repo/8175/whole_project/badge.svg)](https://gitlocalize.com/repo/8175/whole_project?utm_source=badge)
  [![codecov](https://codecov.io/github/Conflux-Chain/python-conflux-sdk/branch/dev/graph/badge.svg?token=GZ62V9QW0A)](https://codecov.io/github/Conflux-Chain/python-conflux-sdk)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/conflux-web3)

  [README](https://python-conflux-sdk.readthedocs.io/en/latest/README.html) | [中文文档](https://python-conflux-sdk.readthedocs.io/zh_CN/latest/README.html)

  - [Introduction](#introduction)
    - [Overview](#overview)
    - [Quickstart](#quickstart)
    - [Documentations](#documentations)
      - [Run Code Examples Online!](#run-code-examples-online)
      - [Localization](#localization)




  Python-conflux-sdk helps to interact with Conflux network using python. It is built over [web3.py](https://github.com/ethereum/web3.py) and most of its APIs are consistent with [web3.py](https://github.com/ethereum/web3.py).



  Requirements: python version >= 3.7

  ```bash
  $ pip3 install conflux-web3
  ```

  ```python
  from conflux_web3 import Web3

  w3 = Web3(Web3.HTTPProvider("https://test.confluxrpc.com"))

  acct = w3.account.from_key("0xxxxxxxxxxxxxx")
  w3.cfx.default_account = acct
  w3.cfx.contract(name="Faucet").claimCfx().transact().executed()

  w3.cfx.send_transaction({
      'to': w3.address.zero_address(),
      'value': 10**18,
  }).executed()
  ```

  Or you can also use API as you do in `web3.py`:

  ``` python

  from conflux_web3 import Web3
  w3 = Web3("https://test.confluxrpc.com")
  from conflux_web3.middleware import construct_sign_and_send_raw_middleware
  from cfx_account import Account
  acct = Account.create('KEYSMASH FJAFJKLDSKF7JKFDJ 1530')
  w3.middleware_onion.add(construct_sign_and_send_raw_middleware(acct))
  w3.cfx.default_account = acct.address

  transaction = {
      'to': w3.address.zero_address(),
      'value': 22,
  }
  w3.cfx.send_transaction(transaction)
  ```



  More detailed code examples are provided in the [documentation](https://python-conflux-sdk.readthedocs.io/en/latest/README.html).



  All code examples can be run online in [mybinder](https://mybinder.org/). You can click `🚀` -> `Binder` on the top bar to activate the running environment. All dependencies wil be installed and the example can be run immediately.



  Currently this documentation supports:

  * English version
  * Chinese version

  And welcome to provide translation in [GitLocalize](https://gitlocalize.com/repo/8175).


pkgId: ab09c3f1983d6511bd644629c359f95a1fd67bbed93c6e8e5db96a8f9fa93439
name: python-confme
arch: src
version: 2.0.3
epoch: 0
release: 1
summary: Easy configuration management in python
url: https://github.com/iwanbolzern/confme
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confme-2.0.3-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/confme?color=blue)](https://pypi.org/project/confme/) [![image](https://img.shields.io/pypi/l/confme)](https://pypi.org/project/confme/) [![image](https://github.com/iwanbolzern/ConfMe/workflows/Test/badge.svg?branch=master)](https://pypi.org/project/confme/)
  [![image](https://img.shields.io/pypi/pyversions/confme?color=blue)](https://pypi.org/project/confme/)

  ConfMe is a simple to use, production ready application configuration management library, which takes into consideration the following three thoughts:
  1. Access to configuration values must be safe at runtime. **No ```myconfig['value1']['subvalue']``` anymore!**
  2. The configuration must be checked for consistency at startup e.g. type check, range check, ...
  3. Secrets shall be injectable from environment variables

  ConfMe makes all these features possible with just a few type annotations on plain Python objects.


  ConfMe can be installed from the official python package repository [pypi](https://pypi.org/project/confme/)

  ```
  pip install confme
  ```

  Or, if you're using pipenv:

  ```
  pipenv install confme
  ```

  Or, if you're using poetry:

  ```
  poetry add confme
  ```


  Define your config structure as plain python objects with type annotations:

  ```python
  from confme import BaseConfig

  class DatabaseConfig(BaseConfig):
      host: str
      port: int
      user: str

  class MyConfig(BaseConfig):
      name: str
      database: DatabaseConfig
  ```

  Create a configuration yaml file with the same structure as your configuration classes have:

  ```yaml
  name: "Database Application"
  database:
      host: "localhost"
      port: 5000
      user: "any-db-user"
  ```

  Load the yaml file into your Python object structure and access it in a secure manner:

  ```python
  my_config = MyConfig.load('config.yaml')

  print(f'Using database connection {my_config.database.host} '
        f'on port {my_config.database.port}')
  ```

  In the background the yaml file is parsed and mapped to the defined object structure. While mapping the values to object properties, type checks are performed. If a value is not available or is not of the correct type, an error is generated already when the configuration is loaded.


  ConfMe is based on pydantic and supports all annotations provided by pydantic. The most important annotations are listed and explain bellow. For the whole list, please checkout [Field Types](https://pydantic-docs.helpmanual.io/usage/types/):
  - str
  - int
  - float
  - bool
  - typing.List[x]
  - typing.Optional[x]
  - [Secret](#secret)
  - [Range](#range)
  - [Enum](#enum)


  With the Secret annotation you can inject secrets from environment variables directly into your configuration structure. This is especially handy when you're deploying applications by using docker. Therefore, let's extend the previous example with a Secret annotation:

  ```python
  from confme import BaseConfig
  from confme.annotation import Secret

  class DatabaseConfig(BaseConfig):
      ...
      password: str = Secret('highSecurePassword')
  ```

  Now set the password to the defined environment variable:

  ```bash
  export highSecurePassword="This is my password"
  ```

  Load your config and check for the injected password.

  ```
  my_config = MyConfig.load('config.yaml')
  print(f'My password is: {my_config.database.password}')
  ```



  ConfME supports OpenRange, ClosedRange and MixedRange values. The terms open and close are similar to open and closed intervals in mathematics. This means, if you want to include the lower and upper range use ClosedRange otherwise OpenRange:
  * ```ClosedRange(2, 3)``` will include 2 and 3
  * ```OpenRange(2, 3)``` will not include 2 and 3

  If you want to have a mixture of both, e.g. include 2 but exclude 3 use MixedRange:
  * ```MixedRange(ge=2, lt=3)``` will include 2 but exclude 3

  ```python
  from confme import BaseConfig
  from confme.annotation import ClosedRange

  class DatabaseConfig(BaseConfig):
      ...
      password: int = ClosedRange(2, 3)
  ```



  If a Python Enum is set as type annotation, ConfMe expect to find the enum value in the configuration file.

  ```python
  from confme import BaseConfig
  from enum import Enum

  class DatabaseConnection(Enum):
      TCP = 'tcp'
      UDP = 'udp'

  class DatabaseConfig(BaseConfig):
      ...
      connection_type: DatabaseConnection
  ```


  A very common situation is that configurations must be changed based on the execution environment (dev, test, prod). This can be accomplished
  by registering a folder with one .yaml file per environment and seting the `ENV` environment variable to the value you need. An example could look
  like this:

  Let's assume we have three environments (dev, test, prod) and one configuration file per environment in the following folder structure:
  ```
  project
  │
  └───config
  │   │   my_prod_config.yaml
  │   │   my_test_config.yaml
  │   │   my_dev_config.yaml
  │
  └───src
  │   │   app.py
  │   │   my_config.py
  ```
  The definition of `my_config.py` is equivalent to the one used in the basic introduction section and `app.py` uses our configuration the
  following way:
  ```python

  MyConfig.register_folder(Path(__file__).parent / '../config')
  ...


  my_config = MyConfig.get()
  print(f'Using database connection {my_config.database.host} '
        f'on port {my_config.database.port}')
  ```
  If now one of the following environment variables (precedence in descending order): `['env', 'environment', 'environ', 'stage']` is
  set e.g. `export ENV=prod` it will load the configuration file with `prod` in its name.


  In addition to loading configuration parameters from the configuration file, they can be passed/overwritten from the command line or environment variables. Thereby, the following precedences apply (lower number means higher precedence):
  1. **Command Line Arguments**: Check if parameter is set as command line argument. If not go one line done...
  2. **Environment Variables**: Check if parameter is set as environment variable. If not go one line done...
  3. **Configuration File**: If value was not found in one of the previous sources, it will check in the configuration file.


  Especially in the Data Science and Machine Learning area it is useful to pass certain parameters for experimental purposes as command line arguments. Therefore, all properties defined in the configuration classes are automatically offered as command line arguments in the following format:

  **my_program.py:**

  ```python
  from confme import BaseConfig

  class DatabaseConfig(BaseConfig):
      host: str
      port: int
      user: str

  class MyConfig(BaseConfig):
      name: int
      database: DatabaseConfig

  config = MyConfig.load('test.yaml')
  ```

  When you now start your program from the command line with the ```++help``` argument, you get the full list of all configuration options. **CAVEAT!** In order to not interfere with other cli tools, the prefix - was changed to +:
  ```shell
  $ python my_program.py --help
  usage: my_program.py [+h] [++name NAME] [++database.host DATABASE.HOST] [++database.port DATABASE.PORT] [++database.user DATABASE.USER]

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

  Configuration Parameters:
    With the parameters specified bellow, the configuration values from the config file can be overwritten.

    ++name NAME
    ++database.host DATABASE.HOST
    ++database.port DATABASE.PORT
    ++database.user DATABASE.USER
  ```


  Likewise to overwriting parameters from the commandline you can also overwrite by passing environment variables. Therefore, simply set the environment variable in the same format as it would be passed as command line arguments and run your application:
  ```shell
  $ export database.host=localhost
  $ python my_programm.py
  ```


  Pydantic is the underlying library powering ConfMe and with the update to pydantic v2 some breaking changes where
  introduced. However, we tried our best to minimize the impact on your project and only passed a selection of changes
  to you. Please find these documented bellow:


  Pydantic V2 changes some of the logic for specifying whether a field annotated as Optional is required (i.e., has no
  default value) or not (i.e., has a default value of None or any other value of the corresponding type), and now more
  closely matches the behavior of dataclasses. Similarly, fields annotated as Any no longer have a default value of None.

  The following table describes the behavior of field annotations in V2:

  | State                                                 | Field Definition            |
  |-------------------------------------------------------|-----------------------------|
  | Required, cannot be `None`                            | `f1: str`                   |
  | Not required, cannot be `None`, is `'abc'` by default | `f3: str = 'abc'`           |
  | Required, can be `None`                               | `f2: Optional[str]`         |
  | Not required, can be `None`, is `None` by default     | `f3: Optional[str] = None`  |
  | Not required, can be `None`, is `'abc'` by default    | `f3: Optional[str] = 'abc'` |
  | Not required, cannot be `None`                        | `f4: str = 'Foobar'`        |
  | Required, can be any type (including `None`)          | `f5: Any`                   |
  | Not required, can be any type (including `None`)      | `f6: Any = None`            |




  ConfMe is released under the [MIT](LICENSE) license.


pkgId: b3b976a9e93b446dd522decdcdba91dc0ca9fb11158267f9caac3a1ca330cee4
name: python-confocal-raytracer
arch: src
version: 0.1.34
epoch: 0
release: 1
summary: Raytrace module
url: https://pypi.org/project/confocal-raytracer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confocal-raytracer-0.1.34-1.src.rpm
checksum_type: sha256
description:
  Specialized ray tracing engine designed for simulating and optimizing chromatic confocal sensors. This repository provides a powerful toolset for researchers and engineers working on precise optical measurement systems, enabling the accurate modeling of light interactions within chromatic confocal setups.



  The library can be simply installed by:

  ```
  pip install confocal-raytracer
  ```



  The optical setup is defined inside a JSON-like file. If, for example, an achromatic doublet is defined each face of both lenses should be defined as follows:

  ```
  doublet = {
      "AC500-150-A-ML_1": {
          "Front Face": dict(
              curvature=96.85, konic=0, z_0=0, aperture_radius=50 / 2
          ),
          "Back Face": dict(
              curvature=-73.74,
              konic=0,
              z_0=9.5,
              aperture_radius=50 / 2,
          ),
          "Material": "BAK4",
          "Calibration": False,
      },
      "AC500-150-A-ML_2": {
          "Front Face": dict(
              curvature=-73.74, konic=0, z_0=9.5, aperture_radius=50 / 2
          ),
          "Back Face": dict(
              curvature=-241.63,
              konic=0,
              z_0=13.5,
              aperture_radius=50 / 2,
          ),
          "Material": "SF10",
          "Calibration": False,
      },
      "AC500-150-A-ML_1_R": {
          "Front Face": dict(
              curvature=241.63,
              konic=0,
              z_0=0,
              aperture_radius=50 / 2,
          ),
          "Back Face": dict(
              curvature=73.74, konic=0, z_0=4, aperture_radius=50 / 2
          ),
          "Material": "BAK4",
          "Calibration": False,
      },
      "AC500-150-A-ML_2_R": {
          "Front Face": dict(
              curvature=73.74,
              konic=0,
              z_0=4,
              aperture_radius=50 / 2,
          ),
          "Back Face": dict(
              curvature=-96.85, konic=0, z_0=13.5, aperture_radius=50 / 2
          ),
          "Material": "SF10",
          "Calibration": False,
      },
      "Sensor": {
          "Front Face": dict(
              curvature=float("inf"),
              konic=0,
              z_0=170,
              aperture_radius=100,
          ),
          "Back Face": dict(
              curvature=float("inf"),
              konic=0,
              z_0=170,
              aperture_radius=100,
          ),
          "Material": "SF2",
          "Calibration": False,
      },
  }
  ```



  The materials available with their refractive indexes should be specified in a Pandas Data Frame. The custom spectrum intensity can also be specified in the same Data Frame as follows:

  |wl_nm|intensity                    |n_BK7 |n_SF2                                        |n_SF5             |n_BAF10           |n_SF10            |n_BAK4            |n_SF57            |
  |-----|-----------------------------|------|---------------------------------------------|------------------|------------------|------------------|------------------|------------------|
  |500.5|0.0851431638                 |1.5213856439764|1.6587264318676913                           |1.6847781738090497|1.67825           |1.74315           |1.57468           |1.86746           |
  |500.7|0.08645302802                |1.5213723632237195|1.6586929033319964                           |1.6847437966326086|1.6782202524647911|1.7430968741556505|1.574659846238762 |1.8673847333525386|
  |500.8|0.08502408117                |1.5213657288620468|1.658676166909398                            |1.684726608044388 |1.6782055071330022|1.7430704823647605|1.5746498284981434|1.8673473595993073|
  |501.0|0.08721513301                |1.5213524721680336|1.6586427497546976                           |1.6846922308679468|1.6781762683497092|1.7430180354906653|1.5746299095672376|1.86727312240276  |
  |501.1|0.08640539646                |1.5213458498356942|1.658626069022597                            |1.684675042279726 |1.6781617729016662|1.7429919781855066|1.5746200076850838|1.867236255427011 |



  ```

  from confocal_raytracer.simulation.raytrace import RayTrace
  from confocal_raytracer.simulation.setup import chromatic_confocal
  from confocal_raytracer.simulation._utils import plotter
  from confocal_raytracer.load_data import n_data
  import numpy as np
  import matplotlib.pyplot as plt
  import time
  import warnings




  warnings.filterwarnings("ignore")


  n_data["n_absorb"] = np.inf



  n_data = n_data[::5]


  optical_data = chromatic_confocal


  PINHOLE_SIZE = 25 / 1000  # milimeters


  N_RAYS = 3

  LIGHT_SOURCE_RADIUS = 0 / 1000  # milimeters


  THETA = 6.0  # Degrees


  N_RAYS_HEIGHT = 1

  Z0 = -33.4  # Light source position same as


  fig, ax = plt.subplots()


  raytrace = RayTrace(
      optical_data=optical_data,
      n_data=n_data,
      light_source_radius=LIGHT_SOURCE_RADIUS,
      n_rays=N_RAYS,
      theta=THETA,
      z0=Z0,
      n_rays_height=N_RAYS_HEIGHT,
  )

  t0 = time.perf_counter()




  frays = raytrace.intersect_full_system()
  print("Elapsed time (s): ", time.perf_counter() - t0)


  fig, ax = plotter(optical_data=optical_data, final_rays=frays, fig=fig, ax=ax)
  plt.plot(
      [
          optical_data["Sensor"]["Front Face"]["z_0"],
          optical_data["Sensor"]["Front Face"]["z_0"],
      ],
      [-PINHOLE_SIZE / 2, PINHOLE_SIZE / 2],
      c="r",
  )
  ax.set(xlabel="z-position (mm)", ylabel="y-position (mm)")
  axins = ax.inset_axes([0.25, 0.1, 0.35, 0.35])
  plotter(optical_data=optical_data, final_rays=frays, fig=fig, ax=axins)
  axins.plot(
      [
          optical_data["Sensor"]["Front Face"]["z_0"],
          optical_data["Sensor"]["Front Face"]["z_0"],
      ],
      [-PINHOLE_SIZE / 2, PINHOLE_SIZE / 2],
      c="r",
      lw=3,
      label="PINHOLE",
  )
  x1, x2, y1, y2 = (
      optical_data["Sensor"]["Front Face"]["z_0"] - 0.1,
      optical_data["Sensor"]["Front Face"]["z_0"] + 0.1,
      -0.1,
      0.1,
  )
  axins.legend()
  axins.set_xlim(x1, x2)
  axins.set_ylim(y1, y2)
  plt.gca().indicate_inset_zoom(axins, edgecolor="black")
  plt.tight_layout()
  plt.show()

  ```

  ![](https://github.com/brakisto/confocal-raytracer/raw/main/confocal_raytracer/figures/image.png)


pkgId: ca77b13b6d4120892b6a8f5d5816f2d9d76fec896bfb540fb70e9fbb54e6dbf5
name: python-conformer-qc
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: Molecular geometry library
url: https://fragment-qc.gitlab.io
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conformer-qc-0.1.3-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright 2018-2024 Fragment Contributors
  SPDX-License-Identifier: Apache-2.0
  -->


  A package for molecular systems


pkgId: b5fe3eb24af1683696de755b4dfe1cbcef1e6615fd667e328623020f0377d8a4
name: python-conformist
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Conformal prediction for machine learning classifiers
url: https://github.com/Molmed/conformist
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conformist-1.1.0-1.src.rpm
checksum_type: sha256
description:
  <!-- Link to Google Font -->
  <link rel="preconnect" href="https://fonts.googleapis.com">
  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
  <link href="https://fonts.googleapis.com/css2?family=League+Script&display=swap" rel="stylesheet">
  <link href="readme.css" rel="stylesheet">


  [![Python package](https://github.com/Molmed/conformist/actions/workflows/python-package.yml/badge.svg)](https://github.com/Molmed/conformist/actions/workflows/python-package.yml)
  [![Upload Python Package](https://github.com/Molmed/conformist/actions/workflows/python-publish.yml/badge.svg)](https://github.com/Molmed/conformist/actions/workflows/python-publish.yml)


  <h1 class="custom-font miami-neon-text">Conformist</h1>

  Conformist v1.1.0 is an implementation of conformal prediction, specifically conformal risk control. It was written using Python 3.8.

  *BaseCoP* contains utility functions common to all conformal predictors, such as splitting data into calibration and validation sets, and setting up runs. It is extended by *FNRCoP* that implements conformal risk control.

  The *ValidationRun* class contains the data from a single run, which entails shuffling the data randomly, splitting it into calibration and validation datasets, calibrating the conformal predictor on the calibration data and creating prediction sets for the validation data.

  The *ValidationTrial* class contains a list of runs and calculates statistics across these runs.


  `pip install conformist`



  The input to Conformist is a CSV file with the following columns:
  `id, known_class, predicted_class, [proba_columns]`

  The proba_columns should contain class-specific probability scores and correspond to the names used in the `known_class` and `predicted_class` columns.

  Example:
  | id      | known_class | predicted_class | ClassA | ClassB | ClassC |
  | --------| ----------- | --------------- | ------ | ------ | ------ |
  | Sample1 | ClassB      | ClassA          | 0.70   | 0.25   | 0.05   |
  | Sample2 | ClassA      | ClassA          | 0.98   | 0.02   | 0.0    |
  | Sample3 | ClassC      | ClassC          | 0.01   | 0.01   | 0.98   |


  ```
  from conformist import FNRCoP, PredictionDataset, ValidationTrial

  CALIB_DATA_CSV = 'path/to/calib.csv'
  TEST_DATA_CSV = 'path/to/test.csv'
  OUTPUT_DIR = 'path/to/output'
  ALPHA = 0.05 # Select a reasonable False Negative Rate


  calpd = PredictionDataset(predictions_csv=CALIB_DATA_CSV,
                            dataset_name='my_cal_data')
  testpd = PredictionDataset(predictions_csv=TEST_DATA_CSV,
                             dataset_name='my_test_data')


  calpd.run_reports(OUTPUT_DIR)


  mcp = FNRCoP(calpd, alpha=ALPHA)
  trial = mcp.do_validation_trial(n_runs=10000)
  trial.run_reports(OUTPUT_DIR)


  mcp = FNRCoP(calpd, alpha=ALPHA)
  mcp.calibrate()


  formatted_predictions = mcp.predict(testpd,
                                      OUTPUT_DIR)
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Mariya Lysenkova Wiklander  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: f803129fd8c520d750d786a63d6f2f3eef35b798ff97f3a0aaca21433ebeac2b
name: python-conformity
arch: src
version: 1.28.2
epoch: 0
release: 1
summary: Cacheable schema description and validation
url: http://github.com/eventbrite/conformity
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conformity-1.28.2-1.src.rpm
checksum_type: sha256
description:
  **Conformity** is a declarative schema validation library designed for use in libraries, services, application


pkgId: c61c70d97d7edba9f89b7f523267fbf747c731c1a65b08592dcde6d3b07ad146
name: python-confsmooth
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/gudasergey/confsmooth
rpm_license: GNU Lesser General Public License v3 or later (LGPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confsmooth-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  The algorithm smooths functions preserving local peaks. To distinguish peaks from noise it needs noise standard deviation

description:
  The algorithm smooths functions preserving local peaks. To distinguish peaks from noise it needs noise standard deviation.

  ![Demo](./example.png)



  pip install --upgrade confsmooth



  ```python
  import os, shutil, statsmodels
  import matplotlib.pyplot as plt
  import numpy as np
  from statsmodels.nonparametric.kernel_regression import KernelReg
  from confsmooth import confsmooth
  from scipy.signal import savgol_filter

  x = np.linspace(-2,2,500)
  real_noise_level = 0.002
  y = 1 - np.power(np.abs(x)+0.01,0.01) + np.random.normal(0, real_noise_level, len(x))


  savgol = savgol_filter(y,21,1)
  noise_level = np.std(y - savgol)
  print('Estimated noise level =', noise_level, 'Real noise level =', real_noise_level)

  smoothed_conf = confsmooth(y, noise_level, confidence=0.995, deg=2)

  kr = KernelReg(endog=y, exog=x, var_type='c', bw=[0.1])
  smoothed_kr, _ = kr.fit(x)

  fig,ax = plt.subplots()
  ax.plot(x, y, label='initial')
  ax.plot(x, savgol, label='savgol')
  ax.plot(x, smoothed_kr, label='Kernel regr')
  ax.plot(x, smoothed_conf, label='confsmooth')
  ax.legend()
  plt.show()
  ```


pkgId: 37695037fa9f83f9fb070c63c2716702e216d0577f465feb962994e53b15a835
name: python-confusable-homoglyphs
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Detect confusable usage of unicode homoglyphs, prevent homograph attacks.
url: https://github.com/vhf/confusable_homoglyphs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confusable-homoglyphs-3.3.1-1.src.rpm
checksum_type: sha256
description:
  This project has been adopted from `the original confusable_homoglyphs
  by Victor Felder
  <https://github.com/vhf/confusable_homoglyphs/tree/master>`_.
  *a homoglyph is one of two or more graphemes, characters, or glyphs with
  shapes that appear identical or very similar*
  `wikipedia:Homoglyph <https://en.wikipedia.org/wiki/Homoglyph>`__
  Unicode homoglyphs can be a nuisance on the web. Your most popular
  client, AlaskaJazz, might be upset to be impersonated by a trickster who
  deliberately chose the username ΑlaskaJazz.
  -  ``AlaskaJazz`` is single script: only Latin characters.
  -  ``ΑlaskaJazz`` is mixed-script: the first character is a greek
     letter.
  You might also want to avoid people being tricked into entering their
  password on ``www.micros﻿оft.com`` or ``www.faϲebook.com`` instead of
  ``www.microsoft.com`` or ``www.facebook.com``. `Here is a
  utility <http://unicode.org/cldr/utility/confusables.jsp>`__ to play
  with these **confusable homoglyphs**.
  Not all mixed-script strings have to be ruled out though, you could only
  exclude mixed-script strings containing characters that might be
  confused with a character from some unicode blocks of your choosing.
  - ``Allo`` and ``ρττ`` are fine: single script.
  - ``AlloΓ`` is fine when our preferred script alias is 'latin': mixed
    script, but ``Γ`` is not confusable.
  - ``Alloρ`` is dangerous: mixed script and ``ρ`` could be confused with
    ``p``.
  This library is compatible with Python 3.


pkgId: 1219426c2f42a1d7cba89abff3597cfc4509260077c39b825bb45feec663456e
name: python-confusables
arch: src
version: 1.2.0
epoch: 0
release: 1
url: https://github.com/woodgern/confusables
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confusables-1.2.0-1.src.rpm
checksum_type: sha256
summary:
  A python package providing functionality for matching words that can be confused for eachother, but contain different characters

description:
  [![Build Status](https://travis-ci.org/woodgern/confusables.svg?branch=master)](https://travis-ci.org/woodgern/confusables) [![PyPI version](https://badge.fury.io/py/confusables.svg)](https://badge.fury.io/py/confusables)




  Confusables is a python package that provides functionality for analyzing and matching words that "appear"
  to be the same or similar, but use different characters.

  Confusables uses the unicode confusable characters list (https://www.unicode.org/Public/security/8.0.0/confusables.txt)
  along with other methods of matching characters.

  This package can be used for any application where detecting words using any unexpected characters to pass filters
  is required. This could include finding malicious fake website names, analyzing or normalizing text data, or even detecting
  attempts to get past a profanity filter.




  Confusables can be installed through pip using
  `pip3 install confusables`




  The functions in the confusables module focus around comparing and finding strings that can be considered "confusable". This means that they can be humanly interpretable as the same string. Since this deals with human interpretation, the "confusable" definition is loose, and in later versions may be more or less strict.

  Currently, confusables provides: `is_confusable`, `confusable_characters`, and `confusable_regex`


  `is_confusable(string1, string2)` takes in 2 strings and outputs whether or not the two are "confusable". Keep in mind that in some cases, a single character can be confusable with 2 characters combined (eg. ‼ is a single character, !! is two)
  ```
  from confusables import is_confusable

  print(is_confusable('rover', 'Ʀỏ𝕍3ℛ'))

  ```



  `confusable_characters(char)` takes in a character and outputs a list of characters that are confusable with it. In some cases, as mentioned above, a single characters can be confusables with multiple characters, in which case those characters will be inluded in the list in the form of a string.
  ```
  from confusables import confusable_characters

  print(confusable_characters('c'))

  ```


  `confusable_regex(string, include_character_padding=False)` takes a string and outputs a regex string that matches words that are confusable with the input string.
  ```
  from confusables import confusable_regex
  import re

  regex_string = confusable_regex('bore', include_character_padding=True)
  regex = re.compile(regex_string)

  print(regex.search('Sometimes people say that life can be a ь.𝞂.ř.ɜ, but I don\'t agree'))

  ```



  `normalize(string, prioritize_alpha=False)` takes a string and outputs a list of possible "normal forms". This means that characters in the string get converted to their confusable ascii counterparts. The `prioritize_alpha` option means the outputted options will prioritize converting characters to characters of the latin alphabet over any others. This option is recommended when natural language is expected.
  ```
  from confusables import normalize

  print(normalize('Ʀỏ𝕍3ℛ', prioritize_alpha=True))


  print(normalize('Ʀỏ𝕍3ℛ', prioritize_alpha=False))

  ```



  If you find the latest version of this package to have an out of date version of the unicode official `confusables.txt`, then why not submit a PR to update it!

  First, find out what the latest version of unicode confusables is. Then, run
  ```
  make update VERSION=X.Y.Z
  ```

  Next, run
  ```
  make parse
  ```
  And that's it! Commit your changes and create a pull request.



  This module is something I put together because I'm interested in the field of language processing. I'm hoping to build out it's functionality, and I'm more than happy to take suggestions!

  Additionally, I think the effectiveness of the module could be greatly improved using some machine learning models, and I'm currently on the hunt for some useful data sets. Please let me know if you know of any!

  You can contact me through any normal Github means, or using my email, `woodgern@gmail.com`


pkgId: 7417e7945254cfb96373a8f42f580adf2dc74a8cdc52fde9fb0a15d2fc15a94a
name: python-confuse
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Painless YAML configuration.
url: https://github.com/beetbox/confuse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confuse-2.0.1-1.src.rpm
checksum_type: sha256
description:
  **Confuse** is a configuration library for Python that uses `YAML`_. It takes
  care of defaults, overrides, type checking, command-line integration,
  environment variable support, human-readable errors, and standard OS-specific
  locations.


pkgId: ea0ef3720ca2ee830a9dc4e8ce681e1efdfd69e4a87a00737d82d68db555fb23
name: python-confz
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: ConfZ is a configuration management library for Python based on pydantic.
url: https://github.com/Zuehlke/ConfZ
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-confz-2.0.1-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/Zuehlke/ConfZ/actions/workflows/test.yml/badge.svg)](https://github.com/Zuehlke/ConfZ/actions/workflows/test.yml)
  [![documentation](https://readthedocs.org/projects/confz/badge/?version=latest)](https://confz.readthedocs.io/en/latest/)
  [![coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/Zuehlke/ConfZ/actions/workflows/coverage.yml)  <!-- hard-code because can not merge if below 100 -->
  [![python](https://img.shields.io/pypi/pyversions/confz)](https://pypi.org/project/confz/)
  [![pypi](https://img.shields.io/pypi/v/confz)](https://pypi.org/project/confz/)

  `ConfZ` is a configuration management library for Python based on [pydantic](https://pydantic-docs.helpmanual.io/).
  It easily allows you to

  * load your configuration from config files, environment variables, command line arguments and more
  * transform the loaded data into a desired format and validate it
  * access the results as Python dataclass-like objects with full IDE support

  It furthermore supports you in common use cases like:

  * Multiple environments
  * Singleton with lazy loading
  * Config changes for unit tests
  * Custom config sources

  **UPDATE**: ConfZ 2 is here, with support for pydantic 2 and improved naming conventions.
  Check out the [migration guide](https://confz.readthedocs.io/en/latest/migration_guide.html).



  `ConfZ` is on [PyPI](https://pypi.org/project/confz/) and can be installed with pip:

  ```shell
  pip install confz
  ```




  The first step of using `ConfZ` is to declare your config classes and sources, for example in `config.py`:

  ```python
  from confz import BaseConfig, FileSource
  from pydantic import SecretStr, AnyUrl

  class DBConfig(BaseConfig):
      user: str
      password: SecretStr

  class APIConfig(BaseConfig):
      host: AnyUrl
      port: int
      db: DBConfig

      CONFIG_SOURCES = FileSource(file='/path/to/config.yml')
  ```

  Thanks to [pydantic](https://pydantic-docs.helpmanual.io/), you can use a wide variety of
  [field types](https://pydantic-docs.helpmanual.io/usage/types/) and
  [validators](https://pydantic-docs.helpmanual.io/usage/validators/).

  From now on, in any other file, you can access your config directly:

  ```python
  from config import APIConfig

  print(f"Serving API at {APIConfig().host}, port {APIConfig().port}.")
  ```

  As can be seen, the config does neither have to be loaded explicitly, nor instantiated globally. `ConfZ` automatically
  loads your config as defined in `CONFIG_SOURCES` the first time you access it. Thanks to its singleton mechanism, this
  happens the first time only, afterwards you get back a cached,
  [immutable](https://pydantic-docs.helpmanual.io/usage/models/#faux-immutability) instance, behaving like any other
  _pydantic_ instance.

  ```python
  assert APIConfig() is APIConfig()   # true because of singleton mechanism
  APIConfig().port = 1234             # raises an error because of immutability
  APIConfig().model_dump()            # call pydantic's method to get a dict representation
  ```

  **Note:** While the implicit and hidden loading of your config might be surprising and feel a bit like Python magic at
  first, it allows you to reduce a lot of boilerplate. Instead of having to load your config explicitly and then passing
  it down to all code layers that need it, you can directly access it from anywhere by just importing your config class
  and accessing for example `APIConfig().db.user` directly.



  `ConfZ` is highly flexible in defining the source of your config. Do you have multiple environments? No Problem:

  ```python
  from confz import BaseConfig, FileSource

  class MyConfig(BaseConfig):
      ...
      CONFIG_SOURCES = FileSource(
          folder='/path/to/config/folder',
          file_from_env='ENVIRONMENT'
      )
  ```

  Your config file can now be defined in the environment variable `ENVIRONMENT` and is relative to `folder`.

  You can also provide a list as config source and read for example from environment variables including a .env file and
  from command line arguments:

  ```python
  from confz import BaseConfig, EnvSource, CLArgSource

  class MyConfig(BaseConfig):
      ...
      CONFIG_SOURCES = [
          EnvSource(allow_all=True, file=".env.local"),
          CLArgSource(prefix='conf_')
      ]
  ```

  `ConfZ` now tries to populate your config either from environment variables having the same name as your attributes or
  by reading command line arguments that start with `conf_`. Recursive models are supported too, for example if you want
  to control the user-name in the API above, you can either set the environment variable `DB.USER` or pass the command
  line argument `--conf_db.user`.



  In some scenarios, the config should not be a global singleton, but loaded explicitly and passed around locally.
  Instead of defining `CONFIG_SOURCES` as class variable, the sources can also be defined in the constructor directly:

  ```python
  from confz import BaseConfig, FileSource, EnvSource

  class MyConfig(BaseConfig):
      number: int
      text: str

  config1 = MyConfig(config_sources=FileSource(file='/path/to/config.yml'))
  config2 = MyConfig(config_sources=EnvSource(prefix='CONF_', allow=['text']), number=1)
  config3 = MyConfig(number=1, text='hello world')
  ```

  As can be seen, additional keyword-arguments can be provided as well.

  **Note:** If neither class variable `CONFIG_SOURCES` nor constructor argument `config_sources` is provided, `BaseConfig`
  behaves like a regular _pydantic_ class.



  In some scenarios, you might want to change your config values, for example within a unit test. However, if you set the
  `CONFIG_SOURCES` class variable, this is not directly possible. To overcome this, every config class provides a context
  manager to temporarily change your config:

  ```python
  from confz import BaseConfig, FileSource, DataSource

  class MyConfig(BaseConfig):
      number: int
      CONFIG_SOURCES = FileSource(file="/path/to/config.yml")

  print(MyConfig().number)                            # will print the value from the config-file

  new_source = DataSource(data={'number': 42})
  with MyConfig.change_config_sources(new_source):
      print(MyConfig().number)                        # will print '42'

  print(MyConfig().number)                            # will print the value from the config-file again
  ```



  By default, your config gets loaded the first time you instantiate the class, e.g. with `MyConfig().attribute`. This
  prevents side effects like loading a file while you import your config classes. If the config class cannot populate all
  mandatory fields in the correct format, _pydantic_ will raise an error at this point. To make sure this does not happen
  in an inconvenient moment, you can also instruct `ConfZ` to load all configs beforehand:

  ```python
  from confz import validate_all_configs

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

  The function `validate_all_configs` will instantiate all config classes defined in your code at any (reachable)
  location that have `CONFIG_SOURCES` set.




  Now you've seen the two ways how `ConfZ` can be used: With class variable config sources, unlocking a singleton with
  lazy loading, or with keyword argument config sources, allowing to directly load your config values. In both cases,
  defining your config sources from files, command line arguments and environment variables is highly flexible
  (and also extendable, by the way), while _pydantic_ still makes sure that everything matches your expectations in the
  end. You've also seen how to temporarily change your config for example in unit tests and how to validate
  your singleton config classes early in the code already.

  The full documentation of `ConfZ`'s features can be found at [readthedocs](https://confz.readthedocs.io/).




  `ConfZ` was programmed and will be maintained by [Zühlke](https://www.zuehlke.com).
  The first version was realized by [Silvan](https://github.com/silvanmelchior).
  Special thanks to Iwan with his [ConfMe](https://github.com/iwanbolzern/ConfMe), which inspired this project.

  Want to contribute to `ConfZ`? Check out the contribution [instruction & guidelines](CONTRIBUTING.md).


pkgId: b64b323d8a86c6b3d95242d6ea067b5b3fefaf2da7bade267359e1f0e2713aae
name: python-congas
arch: src
version: 0.0.78
epoch: 0
release: 1
summary: Copy Number genotyping from single cell RNA sequencing
url: https://github.com/Militeee/congas
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-congas-0.0.78-1.src.rpm
checksum_type: sha256
description:
  A set of Pyro models and functions to infer CNA from scRNA-seq and scATAC-seq data.
  It comes with a companion [R package](https://github.com/caravagnalab/rcongas) that works as an interface and provides preprocessing, simulation and visualization routines.


  Currently providing:

  - A mixture model on segments where CNV are modelled as Categorical random variable (LatentCategorical)

  <!--Coming soon:
  - A linear model in the emission that can account for known covariates
  - The equivalent of MixtureGaussian but with CNVs as Categorical random variable
  - A model on genes (all the other models assume a division in segments)
  -->
  To install:

  `$ pip install congas`

  <!--
  To run a simple analysis on the example data

  ```python
  import congas as cn
  from congas.models import MixtureGaussian
  data_dict = cn.simulation_data
  params, loss = cn.run_analysis(data_dict,MixtureGaussian, steps=200, lr=0.05)
  ```


  [Full Documentation](https://annealpyro.readthedocs.io/en/latest/)
  -->


pkgId: bedb804191f3e907d042584d1e52ec79a74f6021f132b342b882e6796fac6ed6
name: python-congrad
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Generic conjugate gradient solver that works with your favorite backend
url: https://github.com/PMKielstra/PyConGrad
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-congrad-0.0.3-1.src.rpm
checksum_type: sha256
description:
  A somewhat optimized generic batch conjugate gradient algorithm that works with PyTorch, NumPy, CuPy, and whatever other backend you like as long as you code it up.

  Heavily inspired by [sbarratt/torch_cg](https://github.com/sbarratt/torch_cg) and uses similar function signatures.



  ```bash
  $ pip install congrad # If you already have either NumPy, PyTorch, CuPy, or your backend of choice installed
  $ pip install congrad[numpy] # To enforce NumPy dependency
  $ pip install congrad[torch] # To enforce PyTorch dependency
  $ pip install congrad[cupy] # To enforce CuPy dependency
  ```

  ```python
  from congrad.numpy import cg_batch # Or congrad.torch or congrad.cupy

  X = np.random.rand(100, 100)
  A = X @ X.T + 0.001 * np.eye(100)
  b = np.random.rand(100, 10) # PyConGrad expects matrix equations, so the rightmost dimension is for batching.

  def A_batch(x):
      return np.matmul(A, x)

  solution, solve_info = cg_batch(A_batch, b)
  ```

  For more information, documentation, and detailed instructions, see the `examples` folder.  In particular, notebook 2 shows you how to use a different batch dimension if you want to batch over vectors instead of matrices.


pkgId: 7ca3560483576de4766ccbac46edc4e4ed75b8555bde877d9505241bd6384c33
name: python-congrads
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A toolbox for using Constraint Guided Gradient Descent when training neural networks.
description: Elevate your neural networks with Congrads! 🚀
url: https://pypi.org/project/congrads/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-congrads-0.1.0-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 DTAI - KU Leuven  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.   "Commons Clause" License Condition v1.0  The Software is provided to you by the Licensor under the License, as defined below, subject to the following condition.  Without limiting other conditions in the License, the grant of rights under the License will not include, and the License does not grant to you, the right to Sell the Software.  For purposes of the foregoing, "Sell" means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting or consulting/ support services related to the Software), a product or service whose value derives, entirely or substantially, from the functionality of the Software. Any license notice or attribution required by the License must also include this Commons Clause License Condition notice.  Software: All CGGD-Toolbox associated files. License: MIT Licensor: DTAI - KU Leuven


pkgId: c9e6f8de4a53759da077c5cdcd3537fc2cabed825c65944d801047eba4358500
name: python-conics
arch: src
version: 0.1.0a1
epoch: 0
release: 1
summary: Conic sections library
url: https://pypi.org/project/conics/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conics-0.1.0a1-1.src.rpm
checksum_type: sha256
description:
  ![Linux](https://github.com/sergiud/conics/actions/workflows/linux.yml/badge.svg)
  [![codecov](https://codecov.io/gh/sergiud/conics/graph/badge.svg?token=89OIQDFWHV)](https://codecov.io/gh/sergiud/conics)
  [![Documentation Status](https://readthedocs.org/projects/conics/badge/?version=latest)](https://conics.readthedocs.io/en/latest/?badge=latest)
  ![PyPI - Version](https://img.shields.io/pypi/v/conics)


  Conics is a library for managing conic sections (or simply *conics*).



  * Conics construction and transformation
  * Algebraic and geometric fitting and conditioning
  * Computing intersections of conics
  * 5-D pose estimation of the supporting plane of an ellipse



  The library is provided under the [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0).


pkgId: d0e3ff620c695c4167fa4310260b3cae74b0441df7d9b9f8821a48fdbd1974ff
name: python-conjector
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Config injector for Python
url: https://github.com/yar-kik/conjector
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conjector-1.8.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/conjector)](https://pypi.org/project/conjector/)
  [![PyPI - Package Version](https://img.shields.io/pypi/v/conjector)](https://pypi.org/project/conjector/)
  [![PyPI - License](https://img.shields.io/pypi/l/conjector)](https://pypi.org/project/conjector/)
  [![Documentation Status](https://readthedocs.org/projects/conjector/badge/?version=latest)](https://conjector.readthedocs.io/en/latest/?badge=latest)
  [![Build](https://github.com/yar-kik/conjector/actions/workflows/package_build.yml/badge.svg?branch=master)](https://github.com/yar-kik/conjector/actions/workflows/package_build.yml)
  [![Coverage Status](https://coveralls.io/repos/github/yar-kik/conjector/badge.svg?branch=master)](https://coveralls.io/github/yar-kik/conjector?branch=master)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
  [![security: bandit](https://img.shields.io/badge/security-bandit-yellow.svg)](https://github.com/PyCQA/bandit)



  It is a simple library to inject non-sensitive configurations into class variables.
  Basically, it's like `BaseSettings` in `pydantic` library but for constants in `json`, `yaml`, `toml` or `ini` formats.
  `conjector` can work with different Python types (like `tuple`, `datetime`, `dataclass` and so on) and recursively cast config values to them.

  More information about the library and all features you can find in the official [documentation](https://conjector.readthedocs.io/en/latest/).


  * If you deal with constants in your code, like error messages, default values for something, numeric coefficients, and so on.
  * If you hate global variables, and you like non-python files to store static information.
  * If you want to have an easy way to manage different constants depending on environments (like `test`, `dev`, `prod`).
  * If you like type hints and clean code.


  To install this library just enter:
  ```shell
  pip install conjector
  ```
  By default, `conjector` work only with the builtin `json` and `ini` deserializers.
  To work with `yaml` or `toml` (if you are using `python <= 3.10`):
  ```shell
  pip install conjector[yaml]

  pip install conjector[toml]

  pip install conjector[json]
  ```


  For injecting values you need only the decorator `properties` under a target class.
  By default, the library will search a config file `application.yml` in the same directory
  where your file with the used decorator is located, like below:

  ```
  project_root
  |---services
  |   |   email_message_service.py
  |   |   application.yml
  |.....
  ```

  Example:

  `services/application.yml`:

  ```yaml
  default_text_style:
    size: 14
    weight: bold
    font: "Times New Roman"
    color:
      - 128
      - 128
      - 128
  language_greetings:
    - language: english
      text: hello
    - language: german
      text: hallo
    - language: french
      text: bonjour
  wellcome_message: "{greeting}! Thank you for registration, {username}!"
  mailing_frequency:
    days: 5
    hours: 12
  ```
  `services/email_message_service.py`:

  ```python
  from typing import TypedDict
  from dataclasses import dataclass
  from datetime import timedelta
  from conjector import properties


  @dataclass
  class TextStyle:
      size: int
      weight: str
      font: str
      color: tuple[int, int, int] | str


  class GreetingDict(TypedDict):
      language: str
      text: str


  @properties
  class EmailMessageService:
      default_text_style: TextStyle
      language_greetings: list[GreetingDict]
      wellcome_message: str
      mailing_frequency: timedelta | None

      
  ```

  And that's how will look an equivalent of the code above but with "hard-coded" constants, without config files and `@properties` decorator:
  ```python
  class EmailMessageService:
      default_text_style = TextStyle(
          size=14, weight="bold", font="Times New Roman", color=(128, 128, 128)
      )
      language_greetings = [
        GreetingDict(language="english", text="hello"),
        GreetingDict(language="german", text="hallo"),
        GreetingDict(language="french", text="bonjour"),
      ]
      wellcome_message = "{greeting}! Thank you for registration, {username}!"
      mailing_frequency = timedelta(days=5, hours=12)

      
  ```

  All config values will be inserted and cast according to the type annotations once during the application or script start.



  Using this library it's easy to manage different environments and corresponding config files.
  It could be done like so:

  ```python
  import os
  from conjector import properties


  @properties(filename=os.getenv("CONFIG_FILENAME", "application.yml"))
  class SomeEnvDependingService:
      env_depend_var: str
  ```
  In this case, you can set `CONFIG_FILENAME=application-dev.yml` in env variables, and `conjector` will use that file.



  You will make `conjector` better if you open issues or create pull requests with improvements.


pkgId: 7ac6cab0eda3826f2a6e2711e2d7ee1458a93d08a2e6f81f9251f5401178903b
name: python-conjugate-models
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Bayesian Conjugate Models in Python
url: https://wd60622.github.io/conjugate/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conjugate-models-0.11.0-1.src.rpm
checksum_type: sha256
description:
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![Tests](https://github.com/wd60622/conjugate/actions/workflows/tests.yml/badge.svg)](https://github.com/wd60622/conjugate/actions/workflows/tests.yml)
  [![PyPI version](https://badge.fury.io/py/conjugate-models.svg)](https://badge.fury.io/py/conjugate-models)
  [![docs](https://github.com/wd60622/conjugate/actions/workflows/docs.yml/badge.svg)](https://wd60622.github.io/conjugate/)
  [![codecov](https://codecov.io/github/wd60622/conjugate/branch/main/graph/badge.svg)](https://app.codecov.io/github/wd60622/conjugate)

  Bayesian conjugate models in Python




  ```bash
  pip install conjugate-models
  ```



  - [Connection to Scipy Distributions](https://wd60622.github.io/conjugate/examples/scipy-connection) with `dist` attribute
  - [Built in Plotting](https://wd60622.github.io/conjugate/examples/plotting) with `plot_pdf`, `plot_pmf`, and `plot_cdf` methods
  - [Vectorized Operations](https://wd60622.github.io/conjugate/examples/vectorized-inputs) for parameters and data
  - [Indexing Parameters](https://wd60622.github.io/conjugate/examples/indexing) for subsetting and slicing
  - [Generalized Numerical Inputs](https://wd60622.github.io/conjugate/examples/generalized-inputs) for any inputs that act like numbers
      - Out of box compatibility with `polars`, `pandas`, `numpy`, and more.
  - [Unsupported Distributions](https://wd60622.github.io/conjugate/examples/pymc-sampling) for sampling from unsupported distributions



  Many likelihoods are supported including

  - `Bernoulli` / `Binomial`
  - `Categorical` / `Multinomial`
  - `Poisson`
  - `Normal` (including linear regression)
  - and [many more](https://wd60622.github.io/conjugate/models/)



  1. Define prior distribution from `distributions` module
  1. Pass data and prior into model from `models` modules
  1. Analytics with posterior and posterior predictive distributions

  ```python
  from conjugate.distributions import Beta, BetaBinomial
  from conjugate.models import binomial_beta, binomial_beta_predictive


  X = 4
  N = 10


  prior = Beta(1, 1)
  prior_predictive: BetaBinomial = binomial_beta_predictive(n=N, beta=prior)

  posterior: Beta = binomial_beta(n=N, x=X, prior=prior)
  posterior_predictive: BetaBinomial = binomial_beta_predictive(n=N, beta=posterior)
  ```

  From here, do any analysis you'd like!

  ```python

  import matplotlib.pyplot as plt

  fig, axes = plt.subplots(ncols=2)

  ax = axes[0]
  ax = posterior.plot_pdf(ax=ax, label="posterior")
  prior.plot_pdf(ax=ax, label="prior")
  ax.axvline(x=X/N, color="black", ymax=0.05, label="MLE")
  ax.set_title("Success Rate")
  ax.legend()

  ax = axes[1]
  posterior_predictive.plot_pmf(ax=ax, label="posterior predictive")
  prior_predictive.plot_pmf(ax=ax, label="prior predictive")
  ax.axvline(x=X, color="black", ymax=0.05, label="Sample")
  ax.set_title("Number of Successes")
  ax.legend()
  plt.show()
  ```

  <img height=400 src="docs/images/binomial-beta.png" title="Binomial Beta Comparison">

  More examples on in the [documentation](https://wd60622.github.io/conjugate/).



  If you are interested in contributing, check out the [contributing guidelines](https://github.com/wd60622/conjugate/blob/main/CONTRIBUTING.md)


pkgId: 83da3bb1965dc3c5dc43e6ba93ec2172b6fbe8da58f3481c295982e6c68ee1cf
name: python-conjugate-prior
arch: src
version: 0.85
epoch: 0
release: 1
summary: Bayesian Statistics conjugate prior distributions
url: https://github.com/argmaxml/conjugate_prior
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conjugate-prior-0.85-1.src.rpm
checksum_type: sha256
description:
  Python implementation of the conjugate prior table for Bayesian Statistics

  [![Downloads](http://pepy.tech/badge/conjugate-prior)](http://pepy.tech/count/conjugate-prior)

  See wikipedia page:

  https://en.wikipedia.org/wiki/Conjugate_prior#Table_of_conjugate_distributions


  `pip install conjugate-prior`


    1. `BetaBinomial` - Useful for independent trials such as click-trough-rate (ctr), web visitor conversion.
    1. `BetaBernoulli` - Same as above.
    1. `GammaExponential` - Useful for churn-rate analysis, cost, dwell-time.
    1. `GammaPoisson` - Useful for time passed until event, as above.
    1. `NormalNormalKnownVar` - Useful for modeling a centralized distribution with constant noise.
    1. `NormalLogNormalKnownVar` - Useful for modeling a Length of a support phone call.
    1. `InvGammaNormalKnownMean` - Useful for modeling the effect of a noise.
    1. `InvGammaWeibullKnownShape` - Useful for reasoning about particle sizes over time.
    1. `DirichletMultinomial` - Extension of BetaBinomial to more than 2 types of events (Limited support).


    1. `model = GammaExponential(a, b)` - A Bayesian model with an `Exponential` likelihood, and a `Gamma` prior. Where `a` and `b` are the prior parameters.
    1. `model.pdf(x)` - Returns the probability-density-function of the prior function at `x`.
    1. `model.cdf(x)` - Returns the cumulative-density-function of the prior function at `x`.
    1. `model.mean()` - Returns the prior mean.
    1. `model.plot(l, u)` - Plots the prior distribution between `l` and `u`.
    1. `model.posterior(l, u)` - Returns the credible interval on `(l,u)` (equivalent to `cdf(u)-cdf(l)`).
    1. `model.update(data)` - Returns a *new* model after observing `data`.
    1. `model.predict(x)` - Predicts the likelihood of observing `x` (if a posterior predictive exists).
    1. `model.sample()` - Draw a single sample from the posterior distribution.





      from conjugate_prior import BetaBinomial
      heads = 95
      tails = 105
      prior_model = BetaBinomial() # Uninformative prior
      updated_model = prior_model.update(heads, tails)
      credible_interval = updated_model.posterior(0.45, 0.55)
      print ("There's {p:.2f}% chance that the coin is fair".format(p=credible_interval*100))
      predictive = updated_model.predict(50, 50)
      print ("The chance of flipping 50 Heads and 50 Tails in 100 trials is {p:.2f}%".format(p=predictive*100))



  Assume we have `10` creatives (variants) we can choose for our ad campaign, at first we start with the uninformative prior.

  After getting feedback (i.e. clicks) from displaying the ads, we update our model.

  Then we sample the `DirrechletMultinomial` model for the updated distribution.

      from conjugate_prior import DirichletMultinomial
      from collections import Counter
      
      model = DirichletMultinomial(10)
      mle = lambda M:[int(r.argmax()) for r in M]
      selections = [v for k,v in sorted(Counter(mle(model.sample(100))).most_common())]
      print("Percentage before 1000 clicks: ",selections)
      
      clicks = [400,200,100,50,20,20,10,0,0,200]
      model = model.update(clicks)
      selections = [v for k,v in sorted(Counter(mle(model.sample(100))).most_common())]
      print("Percentage after 1000 clicks: ",selections)



    from conjugate_prior import BetaBinomialRanker
    ranker = BetaBinomialRanker(prior=0.1) # 10% click-through-rate
    ranker["cmpgn1"]+=(1,9) # 1 click, 9 skips
    ranker["cmpgn2"]+=(10,90) # 10 click, 90 skips
    ranker["cmpgn3"]+=(1,2) # 1 click, 3 skips
    
    print(ranker.rank_by_ucb())


pkgId: 4021b587fac164eb081a7a66da501b5060627ef384fac6ce54f8703a0fa8381d
name: python-conjunto
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: Django application framework/helpers using HTMX, tabler.io, tables2, crispy-forms & more.
url: https://github.com/nerdocs/conjunto
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conjunto-0.0.21-1.src.rpm
checksum_type: sha256
description:
  Conjunto is a Django application framework using [HTMX](https://htmx.org), [tabler.io](https://tabler.io), [crispy-forms](https://github.com/django-crispy-forms/django-crispy-forms) and more.


  You can install the package by using pip (best using a virtualenv):

  ```bash
  pip install conjunto
  ```


  There is a separate section in the [documentation](https://conjunto.readthedocs.io) available.



  For setting up development environment you will need pytest, pre-commit and black. You can install these by running (in the project directory):

  ```bash
  pip install .[dev]
  ```


  Pull requests and general ideas are welcome. For major changes, please open an issue first to discuss what you would like to change.


  The Conjunto project is open-source and licensed under the MIT License. Please keep in mind that Conjunto uses many other libraries, which may be under different licenses.

rpm_license:
  Copyright 2023 Christian González  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: b0533c240b338f2bf90999c32bdb67020e6708e885032c815d7687ee15c0fce2
name: python-conjur
arch: src
version: 7.1.0
epoch: 0
release: 1
summary: APIs for interacting with the Conjur v5 appliance
url: https://github.com/conjurinc/conjur-api-python3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conjur-7.1.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/Certification%20Level-Certified-6C757D?link=https://github.com/cyberark/community/blob/main/Conjur/conventions/certification-levels.md)
  The Conjur CLI is a **Certified** level project. It's been reviewed by CyberArk to verify that it
  will securely work with CyberArk Conjur Enterprise (previously known as DAP) as documented. In
  addition, CyberArk offers Enterprise-level support for these features. For more detailed information
  on our certification levels,
  see [our community guidelines](https://github.com/cyberark/community/blob/main/Conjur/conventions/certification-levels.md#community)
  .

  ![](https://img.shields.io/badge/Certification%20Level-Community-28A745?link=https://github.com/cyberark/community/blob/main/Conjur/conventions/certification-levels.md)
  The Conjur Python SDK is a **Community** level project. It's a community contributed project that **
  is not reviewed or supported by CyberArk**. For more detailed information on our certification
  levels,
  see [our community guidelines](https://github.com/cyberark/community/blob/main/Conjur/conventions/certification-levels.md#community)
  .

  Are you using this project with [Conjur Open Source](https://github.com/cyberark/conjur)? Then we
  **strongly** recommend choosing the version of this project to use from the
  latest [Conjur OSS suite release](https://docs.conjur.org/Latest/en/Content/Overview/Conjur-OSS-Suite-Overview.html)
  . Conjur maintainers perform additional testing on the suite release versions to ensure
  compatibility. When possible, upgrade your Conjur Open Source version to match the
  [latest suite release](https://docs.conjur.org/Latest/en/Content/ReleaseNotes/ConjurOSS-suite-RN.htm)
  . When using integrations, choose the latest suite release that matches your Conjur Open Source
  version. For any questions, please contact us
  on [Discourse](https://discuss.cyberarkcommons.org/c/conjur/5).

  - Conjur Open Source v1.2.0 or later
  - Conjur Enterprise v11.2.1 (v5.6.3) or later

  - macOS Catalina or later
  - Windows 10 or later
  - Red Hat Enterprise Linux 7, 8


  To access the latest release of the Conjur CLI, go to
  our [release](https://github.com/cyberark/conjur-api-python3/releases)
  page. For instructions on how to set up and configure the CLI, see
  our [official documentation](https://docs.conjur.org/Latest/en/Content/Developer/CLI/cli-lp.htm).

  The SDK can be installed via PyPI. Note that the SDK is a **Community** level project meaning that
  the SDK is subject to alterations that may result in breaking change.
  To avoid unanticipated breaking changes, make sure that you stay up-to-date on our latest releases
  and review the project's [CHANGELOG.md](CHANGELOG.md).
  ```
  pip3 install conjur
  conjur --help
  ```
  Alternatively, you can install the library from the source. Note that this will install the latest
  work from the cloned source and not necessarily an official release.
  Clone the project and run:
  ```
  pip3 install
  ```


  For more information on how to set up, configure, and start using the Conjur CLI, see
  our [official documentation](https://docs.conjur.org/Latest/en/Content/Developer/CLI/cli-lp.htm).

  To start using the SDK in your applications, create a Client instance and then invoke the API on it:

  ```python3

  from conjur import Client
  client = Client(conjurrc_data=ConjurrcData(...),
                  ssl_verification_mode=SslVerificationMode.TRUST_STORE,
                  credentials_provider=FileCredentialsProvider(),
                  debug=False)
  print("Setting variable...")
  client.set('conjur/my/variable', 'new value')
  print("Fetching variable...")
  new_value = client.get('conjur/my/variable')
  print("Variable value is:", new_value.decode('utf-8'))
  ```

  A configuration file called `.conjurrc` is used to hold details required to communicate to the
  Conjur server. You can provide these details needed to open a connection to the Conjur endpoint in
  this file instead of passing them in (`url`, `account`, and `ca_bundle`)
  during initialization of the Client.
  The `.conjurrc` file should be saved to your home directory and should contain `conjur_url`,
  `conjur_account`, and`cert_file`.
  ```


pkgId: 6ee77e27a7cdf448b692cef3c3f54610e67ec2651d0bf5f7637ce630f8f576b7
name: python-conjur-api
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: HTTP client for CyberArk Conjur Secrets Manager
url: https://github.com/cyberark/conjur-api-python
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-conjur-api-0.1.2-1.src.rpm
checksum_type: sha256
description:
  An API client for Conjur written in python.

  Find more SDKs [from CyberArk](https://github.com/cyberark).



  ![](https://img.shields.io/badge/Certification%20Level-Community-28A745?link=https://github.com/cyberark/community/blob/master/Conjur/conventions/certification-levels.md)

  This repo is a **Community** level project. It's a community contributed project that **is not reviewed or supported by
  CyberArk**. For more detailed information on our certification levels,
  see [our community guidelines](https://github.com/cyberark/community/blob/master/Conjur/conventions/certification-levels.md#community)
  .



  This project requires a working Conjur server

  It officially requires python 3.10 and above but can run with lower versions compiled with openssl 1.1.1





  It is assumed that Conjur (OSS or Enterprise) have already been installed in the environment and running in the
  background. If you haven't done so, follow these instructions for installation of
  the [OSS](https://docs.conjur.org/Latest/en/Content/OSS/Installation/Install_methods.htm) and these for installation
  of [Enterprise](https://docs.cyberark.com/Product-Doc/OnlineHelp/AAM-DAP/Latest/en/Content/HomeTilesLPs/LP-Tile2.htm).

  Once Conjur is running in the background, you are ready to start setting up your python app to work with our Conjur
  python API!



  The SDK can be installed via PyPI. Note that the SDK is a **Community level** project meaning that the SDK is subject to
  alterations that may result in breaking change.

  ```sh

  pip3 install conjur

  ```

  To avoid unanticipated breaking changes, make sure that you stay up-to-date on our latest releases and review the
  project's [CHANGELOG.md](CHANGELOG.md).

  Alternatively, you can install the library from the source. Note that this will install the latest work from the cloned
  source and not necessarily an official release.

  If you wish to install the library from the source clone the [project](https://github.com/cyberark/conjur-api-python) and run:

  ```sh

  pip3 install .

  ```





  In order to login to conjur you need to have 5 parameters known from advance.

  ```python
  conjur_url = "https://my_conjur.com"
  account = "my_account"
  username = "user1"
  password = "SomeStr@ngPassword!1"
  ssl_verification_mode = SslVerificationMode.TRUST_STORE
  ```



  ConjurConnectionInfo is a data class containing all the non-credentials connection details.

  ```python
  connection_info = ConjurConnectionInfo(conjur_url=conjur_url,account=account,cert_file=None,service_id="ldap-service-id", proxy_params=None)
  ```

  * conjur_url - url of conjur server
  * account - the account which we want to connect to
  * cert_file - a path to conjur rootCA file. we need it if we initialize the client in `SslVerificationMode.SELF_SIGN`
    or `SslVerificationMode.CA_BUNDLE` mode
  * service_id - a service id for the Conjur authenticator. Required when using the ldap authenticator (see below) but not when using the default `authn` authenticator.
  * proxy_params - parameters for proxy connection. see `ProxyParams` class for more details - Optional



  The client uses credentials provider in order to get the connection credentials before making api command. This approach
  allow to keep the credentials in a safe location and provide it to the client on demand.

  We provide the user with `CredentialsProviderInterface` which can be implemented the way the user see as best
  fit (`keyring` usage for example)

  We also provide the user with a simple implementation of such provider called `SimpleCredentialsProvider`. Example of
  creating such provider + storing credentials:

  ```python
  credentials = CredentialsData(username=username, password=password, machine=conjur_url)
  credentials_provider = SimpleCredentialsProvider()
  credentials_provider.save(credentials)
  del credentials
  ```



  The client also uses an authentication strategy in order to authenticate to conjur. This approach allows us to implement different authentication strategies
  (e.g. `authn`, `authn-ldap`, `authn-k8s`) and to keep the authentication logic separate from the client implementation.

  We provide the `AuthnAuthenticationStrategy` for the default Conjur authenticator. Example use:

  ```python
  authn_provider = AuthnAuthenticationStrategy(credentials_provider)
  ```

  We also provide the `LdapAuthenticationStrategy` for the ldap authenticator, and `OidcAuthenticationStrategy` for the OIDC authenticator.
  Example use:

  ```python
  authn_provider = LdapAuthenticationStrategy(credentials_provider)
  authn_provider = OidcAuthenticationStrategy(credentials_provider)
  ```

  When using these strategies, make sure `connection_info` has a `service_id` specified.



  Now that we have created `connection_info` and `authn_provider`, we can create our client:

  ```python
  client = Client(connection_info,
                  authn_strategy=authn_provider,
                  ssl_verification_mode=ssl_verification_mode)
  ```

  * ssl_verification_mode = `SslVerificationMode` enum that states what is the certificate verification technique we will
    use when making the api request

  After creating the client we can login to conjur and start using it. Example of usage:

  ```python
  client.login() # login to conjur and return the api_key
  client.list() # get list of all conjur resources that the user authorize to read
  ```





  Gets a variable value based on its ID. Variable is binary data that should be decoded to your system's encoding. For example:
  `get(variable_id).decode('utf-8')`.



  Gets multiple variable values based on their IDs. Variables are returned in a dictionary that maps the variable name to
  its value.



  Sets a variable to a specific value based on its ID.

  Note: Policy to create the variable must have already been loaded, otherwise you will get a 404 error during invocation.



  Applies a file-based YAML to a named policy. This method only supports additive changes. Result is a dictionary object
  constructed from the returned JSON data.



  Replaces a named policy with one from the provided file. This is usually a destructive invocation. Result is a
  dictionary object constructed from the returned JSON data.



  Modifies an existing Conjur policy. Data may be explicitly deleted using the `!delete`, `!revoke`, and `!deny`
  statements. Unlike
  "replace" mode, no data is ever implicitly deleted. Result is a dictionary object constructed from the returned JSON
  data.



  Returns a list of all available resources for the current account.

  The 'list constraints' parameter is optional and should be provided as a dictionary.

  For example: `client.list({'kind': 'user', 'inspect': True})`

  | List constraints | Explanation                                                  |
  | ---------------- | ------------------------------------------------------------ |
  | kind             | Filter resources by specified kind (user, host, layer, group, policy, variable, or webservice) |
  | limit            | Limit list of resources to specified number                  |
  | offset           | Skip specified number of resources                           |
  | role             | Retrieve list of resources that specified role is entitled to see (must specify role's full ID) |
  | search           | Search for resources based on specified query                |
  | inspect          | List the metadata for resources                              |



  Checks for a privilege on a resource based on its kind, resource ID, and an optional role ID. Returns a boolean.



  Gets a resource based on its kind and ID. Resource is json data that contains metadata about the resource.



  Check the existence of a resource based on its kind and ID. Returns a boolean.



  Gets a role based on its kind and ID. Role is json data that contains metadata about the role.



  Check the existence of a role based on its kind and ID. Returns a boolean.



  Gets a role's memberships based on its kind and ID. Returns a list of all roles recursively inherited by this role.



  Lists the roles which have the named permission on a resource.



  Lists the resources which are members of the given resource.



  Creates Host Factory tokens for creating hosts



  Uses Host Factory token to create host



  Revokes the given Host Factory token



  Rotates another entity's API key and returns it as a string.

  Note: resource is of type Resource which should have `type` (user / host) and
  `name` attributes.



  Rotates the personal API key of the logged-in user and returns it as a string.



  Updates the current, logged-in user's password with the password parameter provided.

  Note: the new password must meet the Conjur password complexity constraints. It must contain at least 12 characters: 2
  uppercase, 2 lowercase, 1 digit, 1 special character.



  _Note: This method requires Conjur v1.9+_

  Returns a Python dictionary of information about the client making an API request (such as its IP address, user,
  account, token expiration date, etc).



  Allows enabling and disabling an authenticator.

  _Note: This functionality relies on an endpoint in Conjur which is part of an early implementation of support for
  enabling Conjur authenticators via the API, and is currently available at the Community (or early alpha) level. This
  endpoint is still subject to breaking changes in the future._



  Performs an authentication with Conjur, based on the authentication strategy and credentials provider there were given to the client.
  This method is not required, it will also be done implicitly and automatically when session with Conjur needs to be refreshed.



  We welcome contributions of all kinds to this repository. For instructions on how to get started and descriptions of our
  development workflows, please see our [contributing guide](CONTRIBUTING.md).



  Copyright (c) 2020 CyberArk Software Ltd. All rights reserved.

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
  License. You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "
  AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
  language governing permissions and limitations under the License.

  For the full license text see [`LICENSE`](LICENSE).


