# packages

pkgId: 21d8bf0d6dd8108cd0f6288bfcad87ee8c9dd5dd7c57fe126120530c31815835
name: python-check-uncommitted-git-changes
arch: src
version: 1.0.1
epoch: 0
release: 1
url: https://github.com/roskakori/check_uncommitted_git_changes
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-uncommitted-git-changes-1.0.1-1.src.rpm
checksum_type: sha256
summary:
  check for uncommitted git changes to identify outdated generated content during continuous integration

description:
  [![PyPI](https://img.shields.io/pypi/v/check_uncommitted_git_changes)](https://pypi.org/project/check_uncommitted_git_changes/)
  ![Python Versions](https://img.shields.io/pypi/pyversions/check_uncommitted_git_changes.svg)
  ![Build Status](https://github.com/roskakori/check_uncommitted_git_changes/actions/workflows/build.yaml/badge.svg)
  [![License](https://img.shields.io/github/license/roskakori/check_uncommitted_git_changes)](https://opensource.org/licenses/BSD-3-Clause)



  `check_uncommitted_git_changes` is a command line tool to check for
  uncommitted git changes to identify outdated generated content during
  continuous integration.



  While generated code generally should not be committed, there are cases for
  where it can make sense, for example `*.po` files containing translations that
  are derived from source code.

  Developers might change the underlying source code but forget to generate
  the files derived from it. This causes headache for the next developer
  who wants to a translated message while implementing a separate task, and
  not has to deal with the outdated content in some way.



  If your project uses continuous integration, you can use it to run the
  code generators. Ideally they produce the same code that has already been
  committed to the repository.

  However, if a developer forgot to commit up to date generated code, the
  code generators will produce slightly different code that can for example
  be viewed using

  ```bash
  git status
  ```

  Calling `check_uncommitted_git_changes` after the generators have run can
  check for such changes. If there are none, its exit code is 0 and
  continuous integration can continue. If changes are found, the exit code is
  1 and continuous integration fails.



  Add `check_uncommitted_git_changes` to your projects using the respective
  command depending on how you manage your Python packages.

  For poetry, run:

  ```bash
  poetry add --dev check_uncommitted_git_changes
  ```

  For setuptools, run:

  ```bash
  pip install --upgrade check_uncommitted_git_changes
  ```

  or add an entry to your `*requirements.txt`.

  The following example outlines a
  [GitHub action](https://github.com/features/actions) step that first collects
  all translated messages of a Django project and then checks if they differ
  from the versions found in the repository:

  ```yaml
  ...
  jobs:
    build:
      ...
      steps:
        ...
        - name: Check that translations are up to date
          run: |
            python manage.py makemessages --all --ignore venv --no-location --no-obsolete
            check_uncommitted_git_changes
  ```

  The same principle can be applied to
  [other continuous integration platforms](https://en.wikipedia.org/wiki/Comparison_of_continuous_integration_software).



  `Check_uncommitted_git_changes` is open source and distributed under the BSD
  license. The source code is available from
  <https://github.com/roskakori/check_uncommitted_git_changes>.



  See "CHANGES".



  For information on how to build the project and contribute to it see "CONTRIBUTING".


pkgId: 5efee865ec08c0befd59de274239ab3b3b394f5707b275ea314652d3e9f753dd
name: python-check-wheel-contents
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Check your wheels have the right contents
url: https://pypi.org/project/check-wheel-contents/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check-wheel-contents-0.6.1-1.src.rpm
checksum_type: sha256
description:
  ``check-wheel-contents`` requires Python 3.8 or higher.  Just use `pip
  <https://pip.pypa.io>`_ for Python 3 (You have pip, right?) to install
  ``check-wheel-contents`` and its dependencies::
      python3 -m pip install check-wheel-contents


pkgId: e29e9e81fe2095a30df766fe3e021510c1ca082d7022db0be0d655208af61f94
name: python-check11
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Check11 service for cpnits.com
url: https://github.com/jeex/check11
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check11-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Check11 checks Python >= 3.10 code for cpnits.com students.
  Current version: 0.1.2


  Check11 relies on a working github in your computer.

  Your github alias needs to be added to [cpnits.com/check11](https://cpnits.com/check11). Ask your teacher to do that for you.

  You can only check11 assignments that come with a check11 command. Your assignment should have a line somewhere mentioning: *"Use*
  ```
  check11 assignmentname
  ```
  *to check your solution for proper structure and output."*


  1. Make sure you have an activated **virtual environment**.
  2. Pip install check11 with...
  ```
  pip install check11
  ```


  Let's asume that your assignment is called **nerdy**.

  Check11 needs a path to the directory containing the Python files that you want tested.

  With an **absolute path** (starting with **/**) to the dir containg the python files:
  ```
  check11 nerdy /absolute/path/to/dir/with/assignment
  ```

  or with a **relative path** (a relative path never starts with **/**):
  ```
  check11 nerdy relative/path
  ```

  or by omitting the path and run check11 from the **current working directory**:
  ```
  check11 nerdy
  ```


  ```
  check11 -h
  ```

  or:
  ```
  check11 -help
  ```


  Additional argument for **no traceback** in the testreport:
  ```
  check11 nerdy --t /some/dir
  ```

  Additional argument for **errors only** in the test report:
  ```
  check11 nerdy --e /some/dir
  ```

  Additional argument for **clearing the prompt** before printing the test report:  :
  ```
  check11 nerdy --p /some/dir
  ```

  Combined arguments for **no traceback** and **errors only**:
  ```
  check11 nerdy --et /some/dir
  ```


  Example, where **nerdy** is the name of the assignment (assignment in **current dir**, **errors only**, **no traceback**, **clear prompt**):
  ```
  check11 nerdy --etp
  ```

  Example (assignment in **relative dir**, **clear prompt**):
  ```
  check11 nerdy --p some/dir
  ```

  <!-- [GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/) -->
  <!-- python3 -m pip install --upgrade build for building the thing -->
  <!-- twine upload dist/* for uploading to pypi -->


pkgId: 0657cf016b74e147ca83995d0ad17c40c4c21f4238265a293ccf753b595d5951
name: python-check50
arch: src
version: 3.3.11
epoch: 0
release: 1
summary: This is check50, with which you can check solutions to problems for CS50.
url: https://github.com/cs50/check50
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check50-3.3.11-1.src.rpm
checksum_type: sha256
description:
  check50 is a testing tool for checking student code. As a student you can use check50 to check your CS50 problem sets or any other Problem sets for which check50 checks exist. check50 allows teachers to automatically grade code on correctness and to provide automatic feedback while students are coding.

  You can find documentation and instructions for writing your own checks at https://cs50.readthedocs.io/projects/check50/.


pkgId: cc57f091532205151492acb82eeb93519059fb9a2180f17caa3985de19f7103c
name: python-checkPy
arch: src
version: 2.0.13
epoch: 0
release: 1
summary: A simple python testing framework for educational purposes
url: https://github.com/Jelleas/CheckPy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkPy-2.0.13-1.src.rpm
checksum_type: sha256
description:
  A Python tool for running tests on Python source files. Intended to be
  used by students whom are taking courses from [Programming Lab at the UvA](https://www.proglab.nl).

  Check out <https://github.com/spcourse/tests> for examples of tests.



      pip install checkpy

  To download tests, run checkPy with ``-d`` as follows:

      checkpy -d YOUR_GITHUB_TESTS_URL

  For instance:

      checkpy -d spcourse/tests

  Here spcourse/tests points to <https://github.com/spcourse/tests>. You can also use the full url. This tests repository contains a test for `hello.py`. Here is how to run it:

      $ echo 'print("hello world")' > hello.py
      $ checkpy hello
      Testing: hello.py
      :( prints "Hello, world!"
          assert 'hello world\n' == 'Hello, world!\n'
          - hello world
          ? ^
          + Hello, world!
          ? ^    +      +
      :) prints exactly 1 line of output



      usage: checkpy [-h] [-module MODULE] [-download GITHUBLINK] [-register LOCALLINK] [-update] [-list] [-clean] [--dev]
                      [--silent] [--json] [--gh-auth GH_AUTH]
                      [files ...]

      checkPy: a python testing framework for education. You are running Python version 3.10.6 and checkpy version 2.0.0.

      positional arguments:
      files                 names of files to be tested

      options:
      -h, --help            show this help message and exit
      -module MODULE        provide a module name or path to run all tests from the module, or target a module for a
                              specific test
      -download GITHUBLINK  download tests from a Github repository and exit
      -register LOCALLINK   register a local folder that contains tests and exit
      -update               update all downloaded tests and exit
      -list                 list all download locations and exit
      -clean                remove all tests from the tests folder and exit
      --dev                 get extra information to support the development of tests
      --silent              do not print test results to stdout
      --json                return output as json, implies silent
      --gh-auth GH_AUTH     username:personal_access_token for authentication with GitHub. Only used to increase  GitHub api's rate limit.

  To test a single file call:

       checkpy YOUR_FILE_NAME



  Tests in checkpy are functions with assertions. For instance:

  ```Py
  from checkpy import *

  @test()
  def printsHello():
      """prints Hello, world!"""
      assert outputOf() == "Hello, world!\n"
  ```

  checkpy's `test` decorator marks the function below as a test. The docstring is a short description of the test for the student. This test does just one thing, assert that the output of the student's code matches the expected output exactly. checkpy leverages pytest's assertion rewriting to autmatically create assertion messages. For instance, a student might see the following when running this test:

      $ checkpy hello
      Testing: hello.py
      :( prints Hello, world!
          assert 'hello world\n' == 'Hello, world!\n'
          - hello world
          ? ^
          + Hello, world!
          ? ^    +      +



  Tests are discovered by filename. If you want to test a file called ``hello.py``, the corresponding test must be named ``helloTest.py``. These tests must be placed in a folder called `tests`. For instance: `tests/helloTest.py`. Tests are distributed via GitHub repositories, but for development purposes tests can also be registered locally via the `-r` flag. For instance:

      mkdir tests
      touch tests/helloTest.py
      checkpy -r tests/helloTest.py

  Once registered, checkpy will start looking in that directory for tests. Now we need a test. A test minimally consists of the following:

  ```Py
  from checkpy import *

  @test()
  def printsHello():
      """prints Hello, world!"""
      assert outputOf() == "Hello, world!\n"
  ```

  A function marked as a test through checkpy's test decorator. The docstring is a short, generally one-line, description of the test for the student. Then at least one assert.

  > Quick tip, use only binary expressions in assertions and keep them relatively simple for students to understand. If a binary expression is not possible, or you do not want to spoil the output, raise your own assertionError instead: ```raise AssertionError("Your program did not output the answer to the ultimate question of life, the universe, and everything")```.

  While developing, you can run checkpy with the `--dev` flag to get verbose error messages and full tracebacks. So here we might do:

      $ checkpy --dev hello
      Testing: hello.py
      :( prints "Hello, world!"
      assert 'hello world\n' == 'Hello, world!\n'
          - hello world
          ? ^
          + Hello, world!
          ? ^    +      +
      :) prints exactly 1 line of output

  Check out <https://github.com/spcourse/tests> for many examples of checkpy tests.





  ```Py
  @test()
  def exactHello():
      """prints \"Hello, world!\""""
      assert outputOf() == "Hello, world!\n"

  @failed(exactHello)
  def oneLine():
      """prints exactly 1 line of output"""
      assert outputOf().count("\n") == 1

  @passed(exactHello)
  def allGood():
      """Good job, everything is correct! You are ready to hand in."""
  ```



  ```Py
  @test()
  def testSquare():
      """square(2) returns 4"""
      assert getFunction("square")(4) == 4
  ```



  ```Py
  @test()
  def testSquare():
      """square(2) returns 4"""
      assert getFunction("square")(4) == 4, "did you remember to round your output?"
  ```



  ```Py
  @test()
  def testThrowDice():
      """throw() returns 7 on average"""
      throw = getFunction("throw")
      avg = sum(throw() for i in range(1000)) / 1000
      assert avg == approx(7, abs=0.5)
  ```



  ```Py
  import ast

  @test()
  def testSquare():
      """square(2) returns 4"""
      assert ast.While not in static.AbstractSyntaxTree()
      assert getFunction("square")(4) == 4
  ```



  ```Py
  @test()
  def testFibonacci():
      """fibonacci(10) returns the first ten fibonacci numbers"""
      fibonacci = getFunction("fibonacci")
      assert fibonacci(10) == Type(list[int])
      assert fibonacci(10) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
  ```



  > Calling `only`, `include`, `exclude`, `require` or `download` has checkpy create a temporary directory to which the specified files are copied/downloaded. The tests then run in that directory.

  ```Py
  only("sentiment.py")
  download("pos_words.txt", "https://github.com/spcourse/text/raw/main/en/sentiment/pos_words.txt")
  download("neg_words.txt", "https://github.com/spcourse/text/raw/main/en/sentiment/neg_words.txt")

  @test()
  def testPositiveSentiment():
      """recognises a positive sentence"""
      ...
  ```



  ```Py
  @test(timeout=60)
  def exactHello():
      """prints \"Hello, world!\""""
      assert outputOf() == "Hello, world!\n"
  ```



  > This is a new style of tests for simple repetative use cases. Be sure to check out <https://github.com/spcourse/tests> for many more examples. For example [sentimentTest.py](https://github.com/spcourse/tests/blob/676cf5f0d2b0fbc82c7580a76b4359af273b0ca7/tests/text/sentimentTest.py)

  ```Py
  correctForPos = test()(declarative
      .function("sentiment_of_text")
      .params("text")
      .returnType(int)
      .call("Coronet has the best lines of all day cruisers.")
      .returns(1)
      .description("recognises a positive sentence")
  )
  ```



  checkpy downloads tests directly from Github repos. The requirement is that a folder called ``tests`` exists within the repo that contains only tests and folders (which checkpy treats as modules). There must also be at least one release in the Github repo. checkpy will automatically target the latest release. To download tests call checkpy with the optional ``-d`` argument and pass your github repo url. checkpy will automatically keep tests up to date by checking for any new releases on GitHub.




      python3 run_tests.py


pkgId: 446d60f28fac82ba3dc4b16aa2253f244fc795cb931a35a842ef7e915e03c700
name: python-check_done
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Check done issues on a GitHub project board
url: https://github.com/siisurit/check_done
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-check_done-1.0.0-1.src.rpm
checksum_type: sha256
description:
  "
  ```
  In order to avoid having to commit tokens and keys into your repository, you can use environment variables for the values in the configuration YAML by starting them with a `$` symbol and wrapping them with curly braces. For example:
  ```yaml
  personal_access_token: ${MY_PERSONAL_ACCESS_TOKEN_ENVVAR}
  ```

  By default, check_done checks all issues and pull requests in the last selectable project status. If you left the default names when creating the GitHub project board, this would be the `"✅ Done"` project status.
  If you want to check a different project status, you can specify a partial or exact matching name with this option. For example:
  ```yaml
  project_status_name_to_check = "Done"
  ```
  The name takes the first project status that partially matches the case sensitivity. For example, `"Done"` will also match `"✅ Done"`, but not `"done"`.
  If no project status matches, the resulting error messages will show you the exact name of the available project status selections.


pkgId: 6c9f619cd1d6e065e3636fc2cf3b4eec9c5fda673de8a6bb42f459261d20f9f3
name: python-checkbox-ng
arch: src
version: 1.18.1
epoch: 0
release: 1
summary: Checkbox - Command Line Test Runner
url: https://launchpad.net/checkbox-ng/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkbox-ng-1.18.1-1.src.rpm
checksum_type: sha256
description:
  ``Checkbox-ng`` is a hardware testing tool useful for certifying laptops,
  desktops, servers and IOT devices with Ubuntu.


pkgId: d44aa897bb5185d8a95a58f185f31c162266806f775f30fdcba76c7600444b8d
name: python-checkbox-support
arch: src
version: 0.39.0
epoch: 0
release: 1
summary: CheckBox support library
url: https://launchpad.net/checkbox/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkbox-support-0.39.0-1.src.rpm
checksum_type: sha256
description:
  CheckBox Support library is a collection of python modules used by PlainBox
  providers scripts.
  They were originally provided by the checkbox python package.


pkgId: 1605f0115dde5883a7dd2728979454b56568645c59c1a6b89f0addd8ac09115e
name: python-checkdigit
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A check digit library for data validation
url: https://checkdigit.rtfd.io
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkdigit-0.5.0-1.src.rpm
checksum_type: sha256
description:
  **checkdigit** is a pure Python library built for identification numbers.
  You want to validate a credit card number, or maybe even calculate a missing digit on an ISBN code?
  We've got you covered 😎.
  Want to know more? Check out the `API Reference and documentation <https://checkdigit.readthedocs.io/en/latest/reference.html>`_!


pkgId: cc81f8ff72f58c837887b30975811a5dba498021549943fb4815415581bf186b
name: python-checkdmarc
arch: src
version: 5.5.0
epoch: 0
release: 1
summary: A Python module and command line parser for SPF and DMARC records
url: https://github.com/domainaware/checkdmarc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkdmarc-5.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Python tests](https://github.com/domainaware/checkdmarc/actions/workflows/python-tests.yaml/badge.svg)](https://github.com/domainaware/checkdmarc/actions/workflows/python-tests.yaml)
  [![PyPI](https://img.shields.io/pypi/v/checkdmarc)](https://pypi.org/project/checkdmarc/)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/checkdmarc?color=blue)](https://pypistats.org/packages/checkdmarc)

  A Python module and command line utility for validating SPF and DMARC DNS records



  - API and CLI
  - Can test multiple domains at once
  - CLI output in JSON or CSV format
  - Parses and validates MX, SPF, and DMARC records
  - Checks for DNSSEC deployment
  - Lists name servers
  - Checks for STARTTLS and TLS support on each mail server


pkgId: 3ab8c9c24611c2819d05370feb5cec6df4b93173cdee72f088cb92fb9bfdff79
name: python-checking
arch: src
version: 0.9.1
epoch: 0
release: 1
summary: A small library for unit-testing
url: https://github.com/kotolex/checking
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checking-0.9.1-1.src.rpm
checksum_type: sha256
description:
  Test "__main__.check_cat" [Cat from 140288585437776] SUCCESS!
  ```
  If you want to use a text file as a data source, you can use `DATA_FILE` helper function to skip the file handling boilerplate code:
  ```python
  from checking import *
  DATA_FILE('files/data.txt', name='provider')   # Use the file located at <module folder>/files/data.txt
  @test(data_provider='provider')
  def try_prov(it):
      print(it)
      is_true(it)
  ```
  The helper lazy-loads specified data file line by line.
  Raises FileNotFoundError if the file is not found.
  Also, you can transform all the lines before feeding them into the test,
  for example delete trailing newlines at the end of each line:
  ```python
  from checking import *
  DATA_FILE('files/data.txt', name='provider', map_function=str.rstrip)   # Feed each line through str.rstrip()
  @test(data_provider='provider')
  def try_prov(it):
      is_true(it)
  ```
  If you don't specify provider_name for the DATA_FILE helper, file_path will be used:
  ```python
  from checking import *
  DATA_FILE('data.txt')   # Use text file located at the module folder. Note, that no provider_name is specified.
  @test(data_provider='data.txt')   # Use the specified file_name parameter for provider lookup
  def try_prov(it):
      is_true(it)
  ```
  If your test suite uses a data provider more than once, you might want to avoid the IO overhead,
  if this provider fetches the data from some external source (database, file system, http request etc.).
  You can use the `cached` parameter to force the provider to fetch the data only once and store it into memory.
  Please, be varied of the memory consumption, because the cache persists until the whole suite is done running.
  Also, be careful when using the cache when running tests in parallel.
  DATA_FILE helper can use this parameter too.
  ```python
  from checking import *
  DATA_FILE('data.csv', name='csv', cached=True)   # Enable caching
  @test(data_provider='csv')   # First provider use -- data is fetched from the file and stored into memory
  def check_one(it):
      not_none(it)
  @test(data_provider='csv')   # Second use -- no file reads, cached data is used
  def check_two(it):
      not_none(it)
  if __name__ == '__main__':
      start(0)
  ```
  If your provider is a simple one-liner (string, list comprehension, generator expression, etc.),
  you can use the CONTAINER helper function to avoid full function definition boilerplate:
  ```python
  from checking import *
  CONTAINER([e for e in range(10)], name='range')   # Provide data from a listcomps, set provider name to 'range'
  @test(data_provider='range')
  def try_container(it):
      is_true(it in range(10))
  ```
  'name' parameter is optional, 'container' is used by default,
  but it's strongly recommended using a unique name:
  ```python
  from checking import *
  CONTAINER((e for e in range(10)))   # Provide data from a genexps
  @test(data_provider='container')
  def try_container(it):
      is_true(it in range(10))
  ```
  **Important!** You must define DATA_FILE or CONTAINER providers at the module scope, not in the fixtures and tests.

  You can manage the test execution mode by passing a number of parameters to the @test decorator:
  **enabled** (bool) - if set to False, the test will be skipped, all other parameters are ignored. By default, set to True.
  **name** (str) - the name of the test. Is bound to the decorated function name if not specified.
  **description** (str) - test description. If absent, the test function docstring is used.
  If both description and docstring are present, description takes precedence.
  **data_provider** (str) - the name of the data provider to use with the test.
  If specified, the test function must take one argument to be fed with the data from the provider.
  Raises UnknownProviderName if no providers with the specified name found.
  **retries** (int) - the number of times to run the failing test. If test does not fail, no more runs attempted. By default, set to 1.
  **groups** (Tuple[str]) - a tuple of strings, representing the test group names a test is a part of.
  All tests belong to some test group, the default group holds all tests from the current module and is named after the module.
  Use this parameter to manage test execution groups.
  **priority** (int) - test priority. The higher the value the later the test will be executed.
  Use this parameter to fine tune test run order. By default, set to 0.
  **timeout** (int) - amount of time to wait for the test to end.
  If the time runs out, the thread running the test is terminated and the test is marked as "broken".
  Use sparingly due to potential memory leaks.
  **only_if** (Callable[None, bool]) - boolean predicate, which is evaluated before the test execution.
  The test will be executed only if the predicate evaluates to True.
  Use this parameter for conditional test execution e.g. run only if the OS is Linux, etc.

  Each test group or all test-suite can have preconditions and post-actions. For example, open DB connection before test starts and close it after that.
  You can easily make it with before/after fixtures. The function that marked with before/after should be without arguments.
  @before  - run function before EACH test in group, by default group is current module, but you can specify it with parameter
  @after  - run function after EACH test in group, by default group is current module, but you can specify it with parameter.
  This function will not be run if there is @before and it failed!
  ```python
  @before(group_name='api')
  def my_func():
      do_some_precondition()
  @after(group_name='api')
  def another_func():
      do_post_actions()
  ```
  @before_group - function run once before running test in group, by default group is current module, but you can specify it with parameter.
  @after_group - function run once after running all test in group, by default group is current module, but you can specify it with parameter.
  This function will not be run if there is @before_group and it failed, except using parameter always_run = True
  ```python
  @before_group(name='api')
  def my_func():
      do_some_precondition_for_whole_group()
  @after_group(name='api', always_run =True)
  def another_func():
      do_post_actions_for_whole_group()
  ```
  @before_suite - function runs once before any group at start of the test-suite
  @after_suite - function run once after all groups, at the end of the test-suite.
  This function will not be run if there is @before_suite, and it failed, except using parameter 'always_run = True'
  ```python
  @before_suite
  def my_func():
      print('start suite!')
  @after_suite(always_run=True)
  def another_func():
      print('will be printed, even if before_suite failed!')
  ```

  For testing purposes you sometimes need to fake some behaviour or to isolate your application from any other classes/libraries etc.
  If you need your test to use fake object, without doing any real calls, you can use mocks:
  **1. Fake one of the builtin function.**
  Let say you need to test function which is using standard input() inside.
  But you cannot wait for real user input during the test, so fake it with mock object.
  ```python
  def our_weird_function_with_input_inside():
      text = input()
      return text.upper()
  @test
  def mock_builtins_input():
      with mock_builtins('input', lambda : 'test'): # Now input() just returns 'test', it does not wait for user input.
          result_text = our_weird_function_with_input_inside()
          equals('TEST', result_text)
  ```
  More convenient way is to use mock_input or mock_print for simple and most common cases.
  From code above we can test our_weird_function this way
  ```python
  @test
  def check_input():
      with mock_input(['test']): # Now input() just returns 'test', it does not wait for user input.
          result_text = our_weird_function_with_input_inside()
          equals('TEST', result_text)
  ```
  Now let's say we have simple function with print inside and need to test it:
  ```python
  def my_print(x):
      print(x)
  @test
  def check_print():
      with mock_print([]) as result: # now print just collects all to list result
          my_print(1)
          my_print('1')
      equals([(1,), ('1',)], result) # checks all args are in result list
  ```
  and more complicated case, when our function works forever, printing all inputs, until gets 'exit':
  ```python
  def use_both():
      while True:
          word = input('text>>>')
          if word == 'exit':
              break
          print(word)
  @test
  def check_print_and_input():
      
      
      with mock_input(['a', 'b', 'exit']), mock_print([]) as result:
          use_both()
      equals([('a',), ('b',)], result)
  ```
  **2. Fake function of the 3-d party library**
  For working with other modules and libraries in test module, you need to import this module and to mock it function.
  For example, you need to test function, which is using requests.get inside, but you do not want to make real http
  request. Let it mock
  some_module_to_test.py
  ```python
  import requests
  def func_with_get_inside(url):
      response = requests.get(url)
      return response.text
  ```
  our_tests.py
  ```python
  import requests # need to import it for mock!
  from some_module_to_test import func_with_get_inside
  @test
  def mock_requests_get():
      stub = Stub(text='test') # create simple stub, with attribute text equals to 'test'
      with mock(requests, 'get', lambda x: stub):  # Mock real requests with stub object
          equals('test', func_with_get_inside('https://yandex.ru'))  # Now no real requests be performed!
  ```
  **3. Mock read/write to file**
  If you need to mock open function, push data to read from file and gets back with write to file, you can use
  mock_open context-manager
  ```python
  def my_open():
      
      with open('my_file.txt', encoding='utf-8') as f, open('another.txt', 'wt') as f2:
          f2.write(f.readline().upper())
  @test
  def mock_open_both():
      
      with mock_open(on_read_text='test') as result:
          my_open()
      equals(['TEST'], result) # checks we get test uppercase
  ```
  **4. Spy object**
  Spy is the object which has all attributes of original, but spy not performed any action,
  all methods return None (if not specified what to return). Therefore, spy log all actions and arguments.
  It can be useful if your code has inner object, and you need to test what functions were called.
  ```python
  def function_with_str_inside(value):
      
      return value.upper()
  @test
  def spy_for_str():
      spy = Spy('it is a string') # Spy, which is like str, but it is not str!
      function_with_str_inside(spy) # Send our spy instead a str
      is_true(spy.upper.was_called()) # Verify upper was called
  ```
  You can even specify what to return when some function of the spy will be called!
  ```python
  def function_with_str_inside(value):
      
      return value.upper()
  @test
  def spy_with_return():
      spy = Spy('string')
      spy.upper.returns('test') # Tells what to return, when upper will be call
      result = function_with_str_inside(spy)
      is_true(spy.upper.was_called())
      equals('test', result) # verify our spy returns 'test'
  ```
  Spy object can be created without original inner object and can be call itself, it can be useful when you need
  some dumb object to know it was called.
  ```python
  @test
  def check_spy():
      spy = Spy()  # Create "empty" spy
      spy()  # Call it
      is_true(spy.was_called())  # Checks spy was called
  ```
  **5. TestDouble object**
  Test-Double object is like the Spy, but it saves original object behaviour, so its methods returns
  real object methods results if not specified otherwise.
  ```python
  @test
  def check_double():
      spy = TestDouble("string")  # Create str double-object
      equals(6, len(spy))  # Len returns 6 - the real length of original object ("string")
      spy.len.returns(100)  # Fake len result
      equals(100, len(spy))  # Len now returns 100
  ```
  **Important!** Both spy and TestDouble override **isinstance**, so they emulate type of the original object. It can be useful for
  testing functions, which has isinstance check inside. For example:
  ```python
  def function_that_checks_class(obj):
      if isinstance(obj, str):  # check for argument type (string)
          return "OK"
      return "Not OK"
  @test
  def isinstance_check():
      spy = Spy("fake string")  # fake the real string
      result = function_that_checks_class(spy)  # get "OK" here, cause function thinks it's a string, not Spy
      equals("OK", result)
  ```
  **6. Stub object**
  Stub object is just a helper for testing, its purpose not to check or assert something, but to give data
  and perform some simple action, when application under test need it. Unlike spy or double, Stub
  is not remember calls, it just a simple replacement for some object with minimum or no logic inside.
  Let's say we have a function which gets some object, take its attribute, calculates something and
  return result. We wish to isolate our testing from real objects, just test important behaviour, besides
  this data-object can be hard to create or complicated.
  ```python
  from checking import *


  def function(some_object)->int:
      initial_value = some_object.value
      result = 2 + some_object.complicate_function()*initial_value  # Some calculation we need to test
      return result
  @test
  def check_with_stub():
      stub = Stub(value=2) # Creates stub with attribute value=2
      stub.complicate_function.returns(2) # Says, when complicate_function will be called returns 2
      equals(6, function(stub))  # Asserts 6 == 2+(2*2)
  ```
  Pay attention - when you look for some attribute in stub - it always has it! But it will be a wrapper to use with
  expression like `stub.any_attribute.returns('test')`.
  So, if you need to have some attribute (not method) on stub, you just use `stub.attr=10`, but for methods just use expression above.

  You can execute all test at current module using function start(). For example:
  ```python
  from checking import *
  @test
  def some_check():
      equals(4, 2+2)
  if __name__ == '__main__':
      start(3) # Here we run our test function some_check
  ```
  There are parameters to run your tests in different ways:
  **suite_name**  - name of the test-suite, to use in reports or in logs
  **listener** - object of Listener class, test listener, is the way to work with test results and execution
  DefaultListener is used by default. If set, then the verbose parameter is ignored (the one in the listener is used).
  **verbose** is the report detail, 0 - briefly (only dots and 1 letter), 1 - detail, indicating only failed
  tests, 2 - detail, indicating successful and fallen tests, 3 - detail and at the end, a list of fallen and broken ones
  If verbose is not between 0 and 3, then 0 is accepted
  Example (name and verbose)
  ```python
  from checking import *
  @test
  def some_check():
      equals(4, 2 + 2)
  @test
  def some_check_two():
      equals(2, 1 + 1)
  @test
  def failed():
      equals(5, 2 + 2)  # Will fail
  @test
  def broken():
      int('a')  # Will be broken
  if __name__ == '__main__':
      start(suite_name='My Suite', verbose=0)
  ```
  This code will gave output (mention dots and chars!):
  ```text


pkgId: 50f7e03dd9a07ae8f298b3d31600c6c66e21ccbe29f9da227815e3eab524ab89
name: python-checkm-genome
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Assess the quality of putative genome bins.
url: http://pypi.python.org/pypi/checkm-genome/
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkm-genome-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![version status](https://img.shields.io/pypi/v/checkm-genome.svg)](https://pypi.python.org/pypi/checkm-genome)
  [![Bioconda](https://img.shields.io/conda/vn/bioconda/checkm-genome.svg?color=green)](https://anaconda.org/bioconda/checkm-genome)
  [![Downloads](https://pepy.tech/badge/checkm-genome/month)](https://pepy.tech/project/checkm-genome)
  [![BioConda Install](https://img.shields.io/conda/dn/bioconda/checkm-genome.svg?style=flag&label=BioConda%20install)](https://anaconda.org/bioconda/checkm-genome)


  Please see the project home page for usage details and installation instructions: https://github.com/Ecogenomics/CheckM/wiki

  We do not recommend installing CheckM from the master branch. This may be unstable. Please install an official release of CheckM or use pip.



  Information about obtaining improved quality estimates for CPR (Patescibacteria) genomes can be found here:
  https://github.com/Ecogenomics/CheckM/wiki/Workflows#using-cpr-marker-set



  CheckM has been ported to Python 3 to accomodate Python 2 reaching [end of life](https://pythonclock.org/) on January 1, 2020. CheckM >=1.1.0 requires Python 3. Python 2 will no longer be actively supported. Apologies for any issues this may cause.

  Massive thanks to [baudrly](https://github.com/baudrly), [Vini Salazar](https://github.com/vinisalazar), and [Asaf Peer](https://github.com/asafpr) for initial Python 2 to 3 porting.



  Porting of CheckM to Python 3 was validation on a set of 1,000 genomes randomly select from the [GTDB](https://gtdb.ecogenomic.org/) R89 representative genomes. Results were compared to those generated with CheckM v1.0.18, the last Python 2 version of CheckM. Identical results were obtained for the 'lineage_wf', 'taxonomy_wf', and 'ssu_finder' methods across this set of test genomes. Other CheckM methods have been executed on a small set of 3 genomes to verify they run to completion under Python 3.



  The following features have been removed from CheckM v1.1.x in order to simplify the code base and focus CheckM and support requests on critical functionality:
   * bin_qa_plot: non-critical, rarely used plot which does not scale to the large numbers of MAGs now being recovered
   * par_plot: non-critical plot and the same information is better presented in the reference distribution plots
   * cov_pca, tetra_pca: alternatives to these static plots exist in tools such as [Anvi'o](http://merenlab.org/software/anvio/)
   * len_plot: rarely used plot which is largely redundant with the len_hist and nx_plot plots
    * bin_union, bin_compare: feature rich alternative now exist such as [DAS Tool](https://github.com/cmks/DAS_Tool) and [UniteM](https://github.com/dparks1134/UniteM)



  Please report bugs through the GitHub issues system.

  Copyright © 2014 Donovan Parks, Connor Skennerton, Michael Imelfort. See LICENSE for further details.


pkgId: 570370ac48c7900b4331fbbf60833ccf114bb69a490f60ca26add33636887198
name: python-checkmate5
arch: src
version: 4.0.91
epoch: 0
release: 1
summary: A meta-code checker written in Python.
url: https://pypi.org/project/checkmate5/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkmate5-4.0.91-1.src.rpm
checksum_type: sha256
description:
  This is a modified version of original Checkmate.

  Original author(s), license(s), acknowelegement(s): https://github.com/quantifiedcode/checkmate



  Checkmate is a cross-language (meta-)tool for static code analysis, written in Python. Unlike other tools, it provides a global overview of the code quality in a project and aims to provide clear, actionable insights to the user.




  * Checkmate is licensed under the MIT license. To view a copy of this license, visit [https://opensource.org/licenses/MIT](https://opensource.org/licenses/MIT).

  * Original Checkmate's parts remain release under MIT License. However modifications are finally released under AGPL-3.0 license (previously LGPL 2.1 with Commons Clause). Please refer to LICENSE for more info.


pkgId: aaf0906eec77082b5083ad258705f55cae3ef3c231fb707f98bf52aca8808c57
name: python-checkmk-dev-tools
arch: src
version: 0.1.65
epoch: 0
release: 1
summary: Checkmk DevOps tools
url: https://github.com/Checkmk/checkmk-dev-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkmk-dev-tools-0.1.65-1.src.rpm
checksum_type: sha256
description:
  This repository includes scripts/tools for Checkmk developers.

  TBD: what should go here
  TBD: what shouldn't go here




  While you can just clone and use the tools inside of course (they're just plain Python or Bash
  scripts), the intended way to use it is via `pip` or inside a virtual environment.

  Install it locally using `pip`:

  ```sh
  [<PYTHON> -m] pip[3] install [--user] [--upgrade] checkmk-dev-tools
  ```







  `ci-artifacts` is a tool for accessing and triggering (currently Jenkins only) CI job builds and
  making build artifacts available locally in an efficient way (i.e. avoiding unnessessary builds by
  comparing certain constraints like job parameters and time of already available builds).

  Formerly it was only used to make artifacts available which is the reason for the name and some
  CLI desing desicions.




  Run `ci-artifacts --help` in general. Here come a few more detailed examples,
  which might be outdated.

  Assuming credentials are configured and you don't have any more constraints than
  a build has been completed successfully, `fetch` downloads a given jobs artifacts
  to a folder called `out`:
  ```
  ci-artifacts fetch checkmk/master/winagt-build
  ```

  In contrast, this is what a more detailed call might look like
  ```
  ci-artifacts --log-level debug \
      --credentials url_env=JENKINS_URL,username_env=JENKINS_USERNAME,password_env=JENKINS_PASSWORD \
      fetch checkmk/master/winagt-build \
      --params EDITION=raw,DISTRO="ubuntu-22.04" \
      --params-no-check DISABLE_CACHE=false \
      --dependency-paths agents/wnx,agents/windows,packages/cmk-agent-ctl \
      --time-constraints today \
      --base-dir ~/my-git-projects/checkmk/master \
      --out-dir package_download
  ```

  **`--credentials <CREDENTIALS>`**

  Provide URL, username and password to your Jenkins instance.

  **`--params <JOB-PARAMETERS>`**

  Comma separated list of job-parameters used for identifying existing builds and
  to start new ones.

  **`--params-no-check <JOB-PARAMETERS>`**

  Comma separated list of job-parameters used only to start new ones.

  **`--time-constraints <SPECIFIER>`**

  Check for build date constraints when looking for existing builds - currently
  only `today` is taken into account.

  **`--dependency-paths <PATH,..>`**

  Comma separated list of relative paths to files and directories checked for
  differences when looking for existing builds

  **`--base-dir <PATH>`**

  Path taken as repository base dir to prefix paths provided with `--dependency-paths`
  as well as base dir for `--out-dir`.

  **`--out-dir <PATH>`**

  Artifact download destination directory.

  **`--omit-new-build`**

  Don't start new builds, even when no matching build could be found.

  **`--force-new-build`**

  Don't look for existing builds, always start a new build instead.

  **`--log-level`**

  Provide a Python `logging` level name, e.g. `DEBUG` (case-insensitive)



  - [ ] split into `request` and `download`
  - [ ] request CI build from local changes






  For active development you need to have `poetry` and `pre-commit` installed

  ```sh
  python3 -m pip install --upgrade --user poetry pre-commit
  git clone ssh://review.lan.tribe29.com:29418/checkmk_dev_tools
  cd checkmk_dev_tools
  pre-commit install

  poetry env use ~/.pyenv/versions/3.10.4/bin/python3
  poetry install
  ```



  * (once and only for publishing to PyPi) Get token on PyPi.org
  * (once and only for publishing to PyPi) `poetry config pypi-token.pypi pypi-<LONG-STRING>`
    (will write to `~/.config/pypoetry/auth.toml`)
  * modify and check commits via `pre-commit`
  * after work is done locally:
    - adapt version in `pyproject.toml`
    - build and check a package
  ```sh
  poetry build && \
  poetry run twine check dist/* &&
  python3 -m pip uninstall -y checkmk_dev_tools && \
  python3 -m pip install --user dist/checkmk_dev_tools-$(grep -E "^version.?=" pyproject.toml | cut -d '"' -f 2)-py3-none-any.whl
  ```
    - check installed package
    - go through review process
    - publish the new package `poetry publish --build`
    - commit new version && push


pkgId: 40d4c7642c4d92d0a70a05275a9c6412e1f73f9cd98111360ed41ecbc2f92de4
name: python-checkmk-dev-tools
arch: src
version: 0.1.68
epoch: 0
release: 1
summary: Checkmk DevOps tools
url: https://github.com/Checkmk/checkmk-dev-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkmk-dev-tools-0.1.68-1.src.rpm
checksum_type: sha256
description:
  This repository includes scripts/tools for Checkmk developers.

  - TBD: what should go here
  - TBD: what shouldn't go here



  While you can just clone and use the tools inside of course (they're just plain Python or Bash
  scripts), the intended way to use it is via `pip` or inside a virtual environment.

  Install it locally using `pip`:

  ```sh
  [<PYTHON> -m] pip[3] install [--user] [--upgrade] checkmk-dev-tools
  ```





  `ci-artifacts` is a tool for accessing and triggering (currently Jenkins only) CI job builds and
  making build artifacts available locally in an efficient way (i.e. avoiding unnessessary builds by
  comparing certain constraints like job parameters and time of already available builds).

  Formerly it was only used to make artifacts available which is the reason for the name and some
  CLI desing desicions.



  Run `ci-artifacts --help` in general to get more details about the usage of the tool.

  If no API key, username and URL to Jenkins is provided in `~/.config/jenkins_jobs/jenkins_jobs.ini` those parameters have to be specified explicitly.

  This is a template of the `jenkins_jobs.ini` file

  ```
  [jenkins]
  user=carl.lama


  password=API_KEY_NOT_YOUR_PASSWORD
  url=https://JENKINS_URL.tld
  query_plugins_info=False
  ```



  Wait for an existing and specified build to finish. Nothing is downloaded.

  ```sh
  ci-artifacts --log-level debug \
      await-result checkmk/master/builders/build-cmk-distro-package:6066
  ```

  The returned result is a JSON might look like

  ```json
  {"result": "SUCCESS", "artifacts": null}
  ```



  Wait for an existing and specified build to finish and download the artifacts.

  The destination of the artifacts can be specified with the optional argument `--out-dir` (defaults to `out`) and is relative to the base directory (`--base-dir`, defaults to current directory) used to fetch hashes of the downloaded artifacts.
  The flag `--no-remove-others` can be used to keep additional files in the download directory which were not part of the download. This is like a built-in garbage collection.

  ```sh
  ci-artifacts --log-level debug \
      download checkmk/master/builders/build-cmk-distro-package:6066 \
      --base-dir ~/my-git-projects/checkmk/master \
      --out-dir package_download \
      --no-remove-others
  ```

  The returned result is a JSON might look like

  ```json
  {"result": "SUCCESS", "artifacts": ["check-mk-enterprise-2.4.0-2024.10.31_0.jammy_amd64.deb"]}
  ```



  If there are no more constraints than a build has been completed successfully, `fetch` downloads a given jobs artifact, just like with `download` but for the latest build instead of a specified build number.

  Pressing `CTRL+C` while the script is running will ask for confirmation, default answer is `no` and cancel the build.

  ```sh
  ci-artifacts --log-level debug \
      fetch checkmk/master/winagt-build
  ```

  In contrast, this is what a more detailed call might look like

  ```sh
  ci-artifacts --log-level debug \
      fetch checkmk/master/winagt-build \
      --params EDITION=raw,DISTRO="ubuntu-22.04",CUSTOM_GIT_REF=85fa488e0a32f6ea55d8875ab9c517bdc253a8e1 \
      --params-no-check DISABLE_CACHE=false,CIPARAM_OVERRIDE_BUILD_NODE=fra001 \
      --dependency-paths agents/wnx,agents/windows,packages/cmk-agent-ctl \
      --time-constraints today \
      --base-dir ~/my-git-projects/checkmk/master \
      --out-dir package_download
  ```

  **`--params <JOB-PARAMETERS>`**

  Comma separated list of job-parameters used for identifying existing builds and
  to start new ones.

  **`--params-no-check <JOB-PARAMETERS>`**

  Comma separated list of job-parameters used only to start a new build. These parameters are ignored during the search of an already existing build.

  **`--time-constraints <SPECIFIER>`**

  Check for build date constraints when looking for existing builds - currently
  only `today` is taken into account.

  **`--dependency-paths <PATH,..>`**

  Comma separated list of relative paths to files and directories checked for
  differences when looking for existing builds.

  **`--omit-new-build`**

  Don't start new builds, even when no matching build could be found.

  **`--force-new-build`**

  Don't look for existing builds, always start a new build instead.



  Like `fetch` but with the optional parameter `--passive` which outputs the informations needed to trigger a build instead of triggering the build.
  This is helpful in pipeline scripts to keep track of issuers of a build.

  ```sh
  ci-artifacts --log-level debug \
      request checkmk/master/winagt-build \
      --params EDITION=raw,DISTRO="ubuntu-22.04",CUSTOM_GIT_REF=85fa488e0a32f6ea55d8875ab9c517bdc253a8e1 \
      --params-no-check DISABLE_CACHE=false,CIPARAM_OVERRIDE_BUILD_NODE=fra001 \
      --time-constraints today \
      --base-dir ~/my-git-projects/checkmk/master \
      --passive
  ```

  ```json
  {
      "new_build":
      {
          "path": "checkmk/master/winagt-build",
          "params":
          {
              "EDITION": "raw",
              "DISTRO": "ubuntu-22.04",
              "CUSTOM_GIT_REF": "85fa488e0a32f6ea55d8875ab9c517bdc253a8e1",
              "DISABLE_CACHE": "false",
              "CIPARAM_OVERRIDE_BUILD_NODE": "fra001"
          }
      }
  }
  ```

  Without the `--passive` flag the build is triggered if no matching one is found. If a matching build with the specified parameters was found the returned JSON might look like

  ```json
  {
      "existing":
      {
          "path": "checkmk/master/winagt-build",
          "number": 6066,
          "url": "https://JENKINS_URL.tld/job/checkmk/job/master/job/winagt-build/6066/",
          "result": "SUCCESS",
          "new_build": false
      }
  }
  ```



  The `validate` subcommand is a combination of several other commands. It requests, identifies a matching of triggers a new build while waiting for the build to complete. Nothing is downloaded. It has the same parameters as `fetch`.
  This subcommand can be used to trigger a remote build with custom parameters or check if an existing build with these parameters passed or not.

  ```sh
  ci-artifacts --log-level debug \
      validate checkmk/master/winagt-build \
      --params EDITION=raw,DISTRO="ubuntu-22.04",CUSTOM_GIT_REF=85fa488e0a32f6ea55d8875ab9c517bdc253a8e1 \
      --params-no-check DISABLE_CACHE=false,CIPARAM_OVERRIDE_BUILD_NODE=fra001 \
      --time-constraints today
  ```

  ```json
  {"result": "SUCCESS", "artifacts": []}
  ```



  - [ ] request CI build from local changes





  For active development you need to have `poetry` and `pre-commit` installed

  ```sh
  python3 -m pip install --upgrade --user poetry pre-commit
  git clone ssh://review.lan.tribe29.com:29418/checkmk_dev_tools
  cd checkmk_dev_tools
  pre-commit install

  poetry env use ~/.pyenv/versions/3.10.4/bin/python3
  poetry install


  poetry self add poetry-bumpversion
  ```



  * (once and only for publishing to PyPi) Get token on PyPi.org
  * (once and only for publishing to PyPi) `poetry config pypi-token.pypi pypi-<LONG-STRING>`
    (will write to `~/.config/pypoetry/auth.toml`)
  * modify and check commits via `pre-commit run --all-files`
  * after work is done locally:
    - adapt version in `pyproject.toml` with
  ```sh


  poetry version [patch, minor, major] [--dry-run]
  ```
    - may update dependencies before/with a new release
  ```sh
  poetry lock
  ```
    - build and check package locally
  ```sh
  poetry build && \
  poetry run twine check dist/* &&
  python3 -m pip uninstall -y checkmk_dev_tools && \
  python3 -m pip install --user dist/checkmk_dev_tools-$(grep -E "^version.?=" pyproject.toml | cut -d '"' -f 2)-py3-none-any.whl
  ```
    - commit, push, review and merge the changes, see `checkmk_dev_tools/+/88632/`
  ```sh
  git add ...
  git commit -m "cmk-dev-tools: bump version, update dependencies"

  ```
    - publish new package version
  ```sh
  poetry publish --build [--repository checkmk_dev_tools]
  git tag -a v<VERSION> <MERGE_COMMIT> -m "v<VERSION>"
  ```


pkgId: 93bf80717e5392453b298bf32827650ddfb804aad4728008bdc6b58f7f6a6a7d
name: python-checkout-sdk
arch: src
version: 3.1.2
epoch: 0
release: 1
summary: Checkout.com Python SDK
url: https://github.com/checkout/checkout-sdk-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkout-sdk-3.1.2-1.src.rpm
checksum_type: sha256
description:
  [![build-status](https://github.com/checkout/checkout-sdk-python/workflows/build-main/badge.svg)](https://github.com/checkout/checkout-sdk-python/actions/workflows/build-main.yml)
  ![CodeQL](https://github.com/checkout/checkout-sdk-python/workflows/CodeQL/badge.svg)

  [![build-status](https://github.com/checkout/checkout-sdk-python/workflows/build-release/badge.svg)](https://github.com/checkout/checkout-sdk-python/actions/workflows/build-release.yml)
  [![GitHub release](https://img.shields.io/github/release/checkout/checkout-sdk-python.svg)](https://GitHub.com/checkout/checkout-sdk-php/releases/)
  [![PyPI - latest](https://img.shields.io/pypi/v/checkout-sdk?label=latest&logo=pypi)](https://pypi.org/project/checkout-sdk)

  [![GitHub license](https://img.shields.io/github/license/checkout/checkout-sdk-python.svg)](https://github.com/checkout/checkout-sdk-python/blob/main/LICENSE.md)



  ```

  pip install checkout-sdk==<version>
  ```

  > **Version 3.0.0 is here!**
  >  <br/><br/>
  > We improved the initialization of SDK making it easier to understand the available options. <br/>
  > Now `NAS` accounts are the default instance for the SDK and `ABC` structure was moved to a `previous` prefixes. <br/>
  > If you have been using this SDK before, you may find the following important changes:
  > * Imports: if you used to import `checkout_sdk.payments.payments` now use `checkout_sdk.payments.payments_previous`
  > * Marketplace module was moved to Accounts module, same for classes and references.
  > * In most cases, IDE can help you determine from where to import, but if you’re still having issues don't hesitate to open a [ticket](https://github.com/checkout/checkout-sdk-python/issues/new/choose).






  * [Official Docs (Default)](https://docs.checkout.com/)
  * [Official Docs (Previous)](https://docs.checkout.com/previous)



  * [API Reference (Default)](https://api-reference.checkout.com/)
  * [API Reference (Previous)](https://api-reference.checkout.com/previous)



  This SDK can be used with two different pair of API keys provided by Checkout. However, using different API keys imply
  using specific API features. Please find in the table below the types of keys that can be used within this SDK.

  | Account System | Public Key (example)                    | Secret Key (example)                    |
  |----------------|-----------------------------------------|-----------------------------------------|
  | Default        | pk_nruiensgius784thg489hio3481          | sk_nguierhg984hg4nig489gh48931          |
  | Previous       | pk_gdf78gdg-rf56-3fgr-34rf-5435g456gg6y | sk_hg5643g6-4r5t-gt67-ht6t-5467567g6f56 |

  Note: sandbox keys have a `sbox_` or `test_` identifier, for Default and Previous accounts respectively.

  If you don't have your own API keys, you can sign up for a test
  account [here](https://www.checkout.com/get-test-account).

  **PLEASE NEVER SHARE OR PUBLISH YOUR CHECKOUT CREDENTIALS.**



  Default keys client instantiation can be done as follows:

  ```python
  from checkout_sdk.checkout_sdk import CheckoutSdk
  from checkout_sdk.environment import Environment


  def default():
      
      checkout_api = CheckoutSdk
          .builder()
          .secret_key('secret_key')
          .public_key('public_key') # optional, only required for operations related with tokens
          .environment(Environment.sandbox()) # or production()
          .environment_subdomain("subdomain") # optional, Merchant-specific DNS name
          .build()

      payments_client = checkout_api.payments
      payments_client.refund_payment('payment_id')
  ```



  The SDK supports client credentials OAuth, when initialized as follows:

  ```python
  from checkout_sdk.checkout_sdk import CheckoutSdk
  from checkout_sdk.environment import Environment
  from checkout_sdk.oauth_scopes import OAuthScopes


  def oauth():
      checkout_api = CheckoutSdk
          .builder()
          .oauth()
          .client_credentials(client_id='client_id', client_secret='client_secret')
          .environment(Environment.sandbox()) # or production()
          .environment_subdomain("subdomain") # optional, Merchant-specific DNS name
          .scopes([OAuthScopes.GATEWAY_PAYMENT_REFUNDS, OAuthScopes.FILES]) # optional, array of scopes
          .build()

      payments_client = checkout_api.payments
      payments_client.refund_payment('payment_id')
  ```



  If your pair of keys matches the Previous type, this is how the SDK should be used:

  ```python
  from checkout_sdk.checkout_sdk import CheckoutSdk
  from checkout_sdk.environment import Environment

  def previous():
      
      checkout_api = CheckoutSdk
          .builder()
          .previous()
          .secret_key('secret_key')
          .public_key('public_key') # optional, only required for operations related with tokens
          .environment(Environment.sandbox()) # or production()
          .environment_subdomain("subdomain") # optional, Merchant-specific DNS name
          .build()

      payments_client = checkout_api.payments
      payments_client.refund_payment('payment_id')
  ```



  Checkout SDK custom logger can be enabled and configured through Python's logging module:

  ```python
  import logging
  logging.basicConfig()
  logging.getLogger('checkout').setLevel(logging.INFO)
  ```



  Checkout SDK uses `requests` library to perform http operations, and you can provide your own custom http client implementing `HttpClientBuilderInterface`

  ```python
  import requests
  from requests import Session

  import checkout_sdk
  from checkout_sdk.checkout_sdk import CheckoutSdk
  from checkout_sdk.environment import Environment
  from checkout_sdk.oauth_scopes import OAuthScopes
  from checkout_sdk.http_client_interface import HttpClientBuilderInterface


  class CustomHttpClientBuilder(HttpClientBuilderInterface):

      def get_client(self) -> Session:
          session = requests.Session()
          session.max_redirects = 5
          return session


  def oauth():
      checkout_api = CheckoutSdk
          .builder()
          .oauth()
          .client_credentials(client_id='client_id', client_secret='client_secret')
          .environment(Environment.sandbox()) # or production()
          .environment_subdomain("subdomain") # optional, Merchant-specific DNS name
          .http_client_builder(CustomHttpClientBuilder()) # optional
          .scopes([OAuthScopes.GATEWAY_PAYMENT_REFUNDS, OAuthScopes.FILES]) # optional, array of scopes
          .build()

      payments_client = checkout_api.payments
      payments_client.refund_payment('payment_id')
  ```



  All the API responses that do not fall in the 2** status codes will cause a `CheckoutApiException`. The exception encapsulates
  the `http_metadata` and a dictionary of `error_details`, if available.

  ```python
  try:
      checkout_api.customers.get("customer_id")
  except CheckoutApiException as err:
      http_status_code = err.http_metadata.status_code
      error_details = err.error_details
  ```



  Once you checkout the code from GitHub, the project can be built using `pip`:

  ```

  python -m pip install --upgrade pip


  pip install -r requirements-dev.txt


  python -m pytest
  ```

  The execution of integration tests require the following environment variables set in your system:

  * For Default account systems: `CHECKOUT_DEFAULT_PUBLIC_KEY` & `CHECKOUT_DEFAULT_SECRET_KEY`
  * For OAuth account systems: `CHECKOUT_DEFAULT_OAUTH_CLIENT_ID` & `CHECKOUT_DEFAULT_OAUTH_CLIENT_SECRET`
  * For Previous account systems: `CHECKOUT_PREVIOUS_PUBLIC_KEY` & `CHECKOUT_PREVIOUS_SECRET_KEY`



  Please refer to [Code of Conduct](CODE_OF_CONDUCT.md)



  [MIT](LICENSE.md)


pkgId: ad8f9a01769cf489128f921bcc12c2dba8b112bc749e8e8b5d6497ea6ac6a1ec
name: python-checkov2
arch: src
version: 1.0.970
epoch: 0
release: 1
summary: Infrastructure as code static analysis
url: https://github.com/nimrodkor/checkov
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkov2-1.0.970-1.src.rpm
checksum_type: sha256
description:
  [![checkov](https://raw.githubusercontent.com/bridgecrewio/checkov/master/docs/web/images/checkov_by_bridgecrew.png)](#)

  [![Maintained by Bridgecrew.io](https://img.shields.io/badge/maintained%20by-bridgecrew.io-blueviolet)](https://bridgecrew.io/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov)
  [![build status](https://github.com/bridgecrewio/checkov/workflows/build/badge.svg)](https://github.com/bridgecrewio/checkov/actions?query=workflow%3Abuild)
  [![security status](https://github.com/bridgecrewio/checkov/workflows/security/badge.svg)](https://github.com/bridgecrewio/checkov/actions?query=event%3Apush+branch%3Amaster+workflow%3Asecurity)
  [![code_coverage](https://raw.githubusercontent.com/bridgecrewio/checkov/master/coverage.svg?sanitize=true)](https://github.com/bridgecrewio/checkov/actions?query=workflow%3Acoverage)
  [![docs](https://img.shields.io/badge/docs-passing-brightgreen)](https://www.checkov.io/documentation?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov)
  [![PyPI](https://img.shields.io/pypi/v/checkov)](https://pypi.org/project/checkov/)
  [![Python Version](https://img.shields.io/github/pipenv/locked/python-version/bridgecrewio/checkov)](#)
  [![Terraform Version](https://img.shields.io/badge/tf-%3E%3D0.12.0-blue.svg)](#)
  [![Downloads](https://pepy.tech/badge/checkov)](https://pepy.tech/project/checkov)
  [![slack-community](https://slack.bridgecrew.io/badge.svg)](https://slack.bridgecrew.io/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov)


  **Checkov** is a static code analysis tool for infrastructure-as-code.

  It scans cloud infrastructure provisioned using [Terraform](https://terraform.io/), Terraform plan, [Cloudformation](https://aws.amazon.com/cloudformation/), [Kubernetes](https://kubernetes.io/), Dockerfile,  [Serverless](https://www.serverless.com/) or [ARM Templates](https://docs.microsoft.com/en-us/azure/azure-resource-manager/templates/overview) and detects security and compliance misconfigurations.


  Checkov also powers [**Bridgecrew**](https://bridgecrew.io/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov), the developer-first platform that codifies and streamlines cloud security throughout the development lifecycle. Bridgecrew identifies, fixes, and prevents misconfigurations in cloud resources and infrastructure-as-code files.

  <a href="https://www.bridgecrew.cloud/login/signUp/?utm_campaign=checkov-github-repo&utm_source=github.com&utm_medium=get-started-button" title="Try_Bridgecrew">
      <img src="https://dabuttonfactory.com/button.png?t=Try+Bridgecrew&f=Open+Sans-Bold&ts=26&tc=fff&hp=45&vp=20&c=round&bgt=unicolored&bgc=662eff" align="right" width="120">
  </a>


  <a href="https://docs.bridgecrew.io?utm_campaign=checkov-github-repo&utm_source=github.com&utm_medium=read-docs-button" title="Docs">
      <img src="https://dabuttonfactory.com/button.png?t=Read+the+Docs&f=Open+Sans-Bold&ts=26&tc=fff&hp=45&vp=20&c=round&bgt=unicolored&bgc=662eff" align="right" width="120">
  </a>



  - [Features](#features)
  - [Screenshots](#screenshots)
  - [Getting Started](#getting-started)
  - [Disclaimer](#disclaimer)
  - [Support](#support)

   

   * [Over 500 built-in policies](docs/3.Scans/resource-scans.md) cover security and compliance best practices for AWS, Azure and Google Cloud.
   * Scans Terraform, Terraform Plan, CloudFormation, Kubernetes, Serverless framework and ARM template files.
   * Detects [AWS credentials](docs/3.Scans/Credentials%20Scans.md) in EC2 Userdata, Lambda environment variables and Terraform providers.
   * Evaluates [Terraform Provider](https://registry.terraform.io/browse/providers) settings to regulate the creation, management, and updates of IaaS, PaaS or SaaS managed through Terraform.
   * Policies support evaluation of [variables](docs/2.Concepts/Evaluations.md) to their optional default value.
   * Supports in-line [suppression](docs/2.Concepts/Suppressions.md) of accepted risks or false-positives to reduce recurring scan failures. Also supports global skip from using CLI.
  * [Output](docs/1.Introduction/Results.md) currently available as CLI, JSON, JUnit XML and github markdown and link to remediation [guides](https://docs.bridgecrew.io/docs/aws-policy-index).



  Scan results in CLI

  ![scan-screenshot](https://raw.githubusercontent.com/bridgecrewio/checkov/master/docs/checkov-recording.gif)

  Scheduled scan result in Jenkins

  ![jenikins-screenshot](https://raw.githubusercontent.com/bridgecrewio/checkov/master/docs/checkov-jenkins.png)




   * Python >= 3.7 (Data classes are available for Python 3.7+)
   * Terraform >= 0.12




  ```sh
  pip3 install checkov
  ```

  Installation on Alpine:
  ```sh
  pip3 install --upgrade pip && pip3 install --upgrade setuptools
  pip3 install checkov
  ```

  Installation on Ubuntu 18.04 LTS:

  Ubuntu 18.04 ships with Python 3.6. Install python 3.7 (from ppa repository)

  ```sh
  sudo apt update
  sudo apt install software-properties-common
  sudo add-apt-repository ppa:deadsnakes/ppa
  sudo apt install python3.7
  sudo apt install python3-pip
  sudo python3.7 -m pip install -U checkov #to install or upgrade checkov)
  ```

  or using homebrew (MacOS only)

  ```sh
  brew install checkov
  ```

  or

  ```sh
  brew upgrade checkov
  ```



  if you installed checkov with pip3
  ```sh
  pip3 install -U checkov
  ```



  ```sh
  checkov --directory /user/path/to/iac/code
  ```

  Or a specific file or files

  ```sh
  checkov --file /user/tf/example.tf
  ```
  Or
  ```sh
  checkov -f /user/cloudformation/example1.yml -f /user/cloudformation/example2.yml
  ```

  Or a terraform plan file in json format
  ```sh
  terraform init
  terraform plan -out tf.plan
  terraform show -json tf.plan  > tf.json
  checkov -f tf.json
  ```
  Note: `terraform show` output  file `tf.json` will be single line.
  For that reason all findings will be reported line number 0 by checkov
  ```sh
  check: CKV_AWS_21: "Ensure all data stored in the S3 bucket have versioning enabled"
  	FAILED for resource: aws_s3_bucket.customer
  	File: /tf/tf.json:0-0
  	Guide: https://docs.bridgecrew.io/docs/s3_16-enable-versioning
    ```

  If you have installed `jq` you can convert json file into multiple lines with the following command:
  ```sh
  terraform show -json tf.plan | jq '.' > tf.json
  ```
  Scan result would be much user friendly.

  ```sh
  checkov -f tf.json
  Check: CKV_AWS_21: "Ensure all data stored in the S3 bucket have versioning enabled"
  	FAILED for resource: aws_s3_bucket.customer
  	File: /tf/tf1.json:224-268
  	Guide: https://docs.bridgecrew.io/docs/s3_16-enable-versioning

  		225 |               "values": {
  		226 |                 "acceleration_status": "",
  		227 |                 "acl": "private",
  		228 |                 "arn": "arn:aws:s3:::mybucket",

  ```





  ```sh
  Passed Checks: 1, Failed Checks: 1, Suppressed Checks: 0
  Check: "Ensure all data stored in the S3 bucket is securely encrypted at rest"
  /main.tf:
  	 Passed for resource: aws_s3_bucket.template_bucket
  Check: "Ensure all data stored in the S3 bucket is securely encrypted at rest"
  /../regionStack/main.tf:
  	 Failed for resource: aws_s3_bucket.sls_deployment_bucket_name
  ```

  Start using Checkov by reading the [Getting Started](docs/1.Introduction/Getting%20Started.md) page.




  ```sh
  docker pull bridgecrew/checkov
  docker run --tty --volume /user/tf:/tf bridgecrew/checkov --directory /tf
  ```
  Note: if you are using Python 3.6(Default version in Ubuntu 18.04) checkov will not work and it will fail with `ModuleNotFoundError: No module named 'dataclasses'`  error message. In this case, you can use the docker version instead.

  Note that there are certain cases where redirecting `docker run --tty` output to a file - for example, if you want to save the Checkov JUnit output to a file - will cause extra control characters to be printed. This can break file parsing. If you encounter this, remove the `--tty` flag.



  Using command line flags you can specify to run only named checks (allow list) or run all checks except
  those listed (deny list).

  List available checks:
  ```sh
  checkov --list
  ```

  Allow only 2 checks to run:
  ```sh
  checkov --directory . --check CKV_AWS_20,CKV_AWS_57
  ```

  Run all checks except 1 specified:
  ```sh
  checkov -d . --skip-check CKV_AWS_52
  ```

  Run all checks except checks with specified patterns:
  ```sh
  checkov -d . --skip-check CKV_AWS*
  ```

  For Kubernetes workloads, you can also use allow/deny namespaces.  For example, do not report any results for the
  kube-system namespace:
  ```sh
  checkov -d . --skip-check kube-system
  ```



  Like any static-analysis tool it is limited by its analysis scope.
  For example, if a resource is managed manually, or using subsequent configuration management tooling,
  a suppression can be inserted as a simple code annotation.



  To skip a check on a given Terraform definition block or CloudFormation resource, apply the following comment pattern inside it's scope:

  `checkov:skip=<check_id>:<suppression_comment>`

  * `<check_id>` is one of the [available check scanners](docs/3.Scans/resource-scans.md)
  * `<suppression_comment>` is an optional suppression reason to be included in the output



  The following comment skip the `CKV_AWS_20` check on the resource identified by `foo-bucket`, where the scan checks if an AWS S3 bucket is private.
  In the example, the bucket is configured with a public read access; Adding the suppress comment would skip the appropriate check instead of the check to fail.

  ```hcl-terraform
  resource "aws_s3_bucket" "foo-bucket" {
    region        = var.region
      
    bucket        = local.bucket_name
    force_destroy = true
    acl           = "public-read"
  }
  ```

  The output would now contain a ``SKIPPED`` check result entry:

  ```bash
  ...
  ...
  Check: "S3 Bucket has an ACL defined which allows public access."
  	SKIPPED for resource: aws_s3_bucket.foo-bucket
  	Suppress comment: The bucket is a public static content host
  	File: /example_skip_acl.tf:1-25

  ...
  ```

  To suppress checks in Kubernetes manifests, annotations are used with the following format:
  `checkov.io/skip#: <check_id>=<suppression_comment>`

  For example:

  ```bash
  apiVersion: v1
  kind: Pod
  metadata:
    name: mypod
    annotations:
      checkov.io/skip1: CKV_K8S_20=I don't care about Privilege Escalation :-O
      checkov.io/skip2: CKV_K8S_14
      checkov.io/skip3: CKV_K8S_11=I have not set CPU limits as I want BestEffort QoS
  spec:
    containers:
  ...
  ```



  For detailed logging to stdout setup the environment variable `LOG_LEVEL` to `DEBUG`.

  Default is `LOG_LEVEL=WARNING`.


  To skip a whole directory, use the environment variable `CKV_IGNORED_DIRECTORIES`.
  Default is `CKV_IGNORED_DIRECTORIES=node_modules,.terraform,.serverless`



  If you want to use checkov's within vscode, give a try to the vscode extension availble at [vscode](https://marketplace.visualstudio.com/items?itemName=Bridgecrew.checkov)



  For Terraform compliance scanners check out [tfsec](https://github.com/liamg/tfsec) and [Terraform AWS Secure Baseline](https://github.com/nozaq/terraform-aws-secure-baseline) for secured basline.

  For CloudFormation scanning check out [cfripper](https://github.com/Skyscanner/cfripper/) and [cfn_nag](https://github.com/stelligent/cfn_nag).

  For Kubernetes scanning check out [kube-scan](https://github.com/octarinesec/kube-scan) and [Polaris](https://github.com/FairwindsOps/polaris).



  Contribution is welcomed!

  Start by reviewing the [contribution guidelines](CONTRIBUTING.md). After that, take a look at a [good first issue](https://github.com/bridgecrewio/checkov/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).

  Looking to contribute new checks? Learn how to write a new check (AKA policy) [here](docs/5.Contribution/New-Check.md).


  `checkov` does not save, publish or share with anyone any identifiable customer information.
  No identifiable customer information is used to query Bridgecrew's publicly accessible guides.
  `checkov` uses Bridgecrew's API to enrich the results with links to remediation guides.
  To skip this API call use the flag `--no-guide`.



  [Bridgecrew](https://bridgecrew.io/?utm_source=github&utm_medium=organic_oss&utm_campaign=checkov) builds and maintains Checkov to make policy-as-code simple and accessible.

  Start with our [Documentation](https://bridgecrewio.github.io/checkov/) for quick tutorials and examples.

  If you need direct support you can contact us at info@bridgecrew.io.


pkgId: b5414f11a9ce7c5838f1b97e7f52c5c05039b881b8cc749572540882d2eba991
name: python-checkpoint-schedules
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Schedules for incremental checkpointing of adjoint simulations.
url: https://www.firedrakeproject.org/checkpoint_schedules/
rpm_license: LGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkpoint-schedules-1.0.4-1.src.rpm
checksum_type: sha256
description:
  *checkpoint_schedules* provides schedules for step-based incremental
  checkpointing of the adjoints to computer models. The schedules contain
  instructions indicating the sequence of forward and adjoint steps to be
  executed, and the data storage and retrieval to be performed.

  The schedule instructions are independent of the model implementation,
  which enables the model authors to switch between checkpointing algorithms
  without recoding their adjoint solvers. Conversely, *checkpoint_schedules*
  provides developers of checkpointing algorithms with a direct mechanism to convey
  their work to model authors.


  *checkpoint_schedules* is a Python package and can be installed using pip
  ```
  pip install checkpoint-schedules
  ```


  The usage guide of *checkpoint_schedules* is available [here](https://nbviewer.org/github/firedrakeproject/checkpoint_schedules/blob/main/docs/notebooks/tutorial.ipynb).



  We welcome contributions to *checkpoint_schedules*!
  To contribute please consider the following steps:
  1. Fork the repository.
  2. Make your changes.
  3. Make sure that the tests pass by running `pytest test` and `pytest --nbval-lax docs/notebooks/`
  4. Add tests for your changes (if applicable).
  5. Add documentation for your changes that follows the [Sphinx](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html) format.
  6. Submit your pull request.


  Please report bugs on the [issue tracker](https://github.com/firedrakeproject/checkpoint_schedules/issues).


  The complete documentation for checkpoint_schedules is available at [Firedrake project website](https://www.firedrakeproject.org/checkpoint_schedules/).


  *checkpoint_schedules* is licensed under the GNU LGPL version 3. See the LICENSE file for details.


  If you use *checkpoint_schedules* in your research, please cite this paper
  [![DOI](https://joss.theoj.org/papers/10.21105/joss.06148/status.svg)](https://doi.org/10.21105/joss.06148).


pkgId: 9e83c27531923ac633ccf4583fede3ee3d76b73d71b1941cd16394ce778e0d5a
name: python-checks-cli
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Command-line tool to manage tasks list.
url: https://github.com/anas-shakeel/checks
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checks-cli-1.0.1-1.src.rpm
checksum_type: sha256
description:
  A CLI application for managing todo tasks while coding. (rather than managing `TODO.md` or similar files.)







  Run `checks` command in the terminal in your project directory (or anywhere)



  ```shell

  >> checks

  ```







  This readme is currently being written.


pkgId: 3033bca6427a1ab8693b78e316a82a4f9f319f53d4e10bc2ad6c2b207a0e9f76
name: python-checksum-dict
arch: src
version: 1.1.4
epoch: 0
release: 1
url: https://github.com/BobTheBuidler/checksum_dict
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checksum-dict-1.1.4-1.src.rpm
checksum_type: sha256
summary:
  checksum_dict's objects handle the simple but repetitive task of checksumming addresses before setting/getting dictionary values.


pkgId: a2b6eef27b1a191ced03fb4975ca4831d94aa5e00801b76475e843db019c2849
name: python-checkvsphere
arch: src
version: 0.3.12
epoch: 0
release: 1
summary: check_vsphere monitoring plugin
url: https://pypi.org/project/checkvsphere/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-checkvsphere-0.3.12-1.src.rpm
checksum_type: sha256
description:
  This is a monitoring plugin for naemon, icinga, nagios like systems. It
  is meant as a successor of check\_vmware\_esx. check\_vmware\_esx is written
  Perl but VMWare™ has dropped support for the Perl SDK. So this plugin is written
  in Python using pyVmomi.



  The plugin has modes to check various aspects of these components:

  * datastores
  * host-runtime
  * host-service
  * host-storage
  * host-nic
  * snapshots
  * vsan

  Check the
  [Documentation](https://omd.consol.de/docs/plugins/check_vsphere/)
  for further details.



  ```
  pip install checkvsphere
  ```



  If not stated otherwise in a source file everything is licensed under
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3.

  See also the LICENSE file.


pkgId: 55bebea813a3561331de32f6e003bb3587a348ab073db5cf114870fb1c62f52b
name: python-cheesechaser
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Swiftly get tons of images from indexed tars on Huggingface.
url: https://github.com/deepghs/cheesechaser
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheesechaser-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cheesechaser)](https://pypi.org/project/cheesechaser/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cheesechaser)
  ![Loc](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/narugo1992/eedf334ff9d7ff02e7ec9535e43a1faa/raw/loc.json)
  ![Comments](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/narugo1992/eedf334ff9d7ff02e7ec9535e43a1faa/raw/comments.json)

  [![Code Test](https://github.com/deepghs/cheesechaser/workflows/Code%20Test/badge.svg)](https://github.com/deepghs/cheesechaser/actions?query=workflow%3A%22Code+Test%22)
  [![Package Release](https://github.com/deepghs/cheesechaser/workflows/Package%20Release/badge.svg)](https://github.com/deepghs/cheesechaser/actions?query=workflow%3A%22Package+Release%22)
  [![codecov](https://codecov.io/gh/deepghs/cheesechaser/branch/main/graph/badge.svg?token=XJVDP4EFAT)](https://codecov.io/gh/deepghs/cheesechaser)

  [![Discord](https://img.shields.io/discord/1157587327879745558?style=social&logo=discord&link=https%3A%2F%2Fdiscord.gg%2FTwdHJ42N72)](https://discord.gg/TwdHJ42N72)
  ![GitHub Org's stars](https://img.shields.io/github/stars/deepghs)
  [![GitHub stars](https://img.shields.io/github/stars/deepghs/cheesechaser)](https://github.com/deepghs/cheesechaser/stargazers)
  [![GitHub forks](https://img.shields.io/github/forks/deepghs/cheesechaser)](https://github.com/deepghs/cheesechaser/network)
  ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/deepghs/cheesechaser)
  [![GitHub issues](https://img.shields.io/github/issues/deepghs/cheesechaser)](https://github.com/deepghs/cheesechaser/issues)
  [![GitHub pulls](https://img.shields.io/github/issues-pr/deepghs/cheesechaser)](https://github.com/deepghs/cheesechaser/pulls)
  [![Contributors](https://img.shields.io/github/contributors/deepghs/cheesechaser)](https://github.com/deepghs/cheesechaser/graphs/contributors)
  [![GitHub license](https://img.shields.io/github/license/deepghs/cheesechaser)](https://github.com/deepghs/cheesechaser/blob/master/LICENSE)

  Swiftly get tons of images from indexed tars on Huggingface



  ```shell
  pip install cheesechaser
  ```



  This library is based on the mirror datasets on huggingface.

  For the Gelbooru mirror dataset repository, such
  as [deepghs/gelbooru_full](https://huggingface.co/datasets/deepghs/gelbooru_full), each data packet includes a tar
  archive file and a corresponding JSON index file. The JSON index file contains detailed information about the files
  within the tar archive, including file size, offset, and file fingerprint.

  The files in this dataset repository are organized according to a fixed pattern based on their IDs. For example, a file
  with the ID 114514 will have a modulus result of 4514 when divided by 10000. Consequently, it is stored
  in `images/4/0514.tar`.

  Utilizing the quick download feature
  from [hfutils.index](https://deepghs.github.io/hfutils/main/api_doc/index/index.html), users can instantly access
  individual files. Since the download service is provided through Huggingface's LFS service and not the original website
  or an image CDN, there is no risk of IP or account blocking. **The only limitations to your download speed are your
  network bandwidth and disk read/write speeds.**

  This efficient system ensures a seamless and reliable access to the dataset without any restrictions.



  * Danbooru

  ```python
  from cheesechaser.datapool import DanbooruNewestDataPool

  pool = DanbooruNewestDataPool()


  pool.batch_download_to_directory(
      resource_ids=range(2010000, 2010300),
      dst_dir='/data/exp2',
      max_workers=12,
  )
  ```

  * Danbooru With Tags Query

  ```python
  from cheesechaser.datapool import DanbooruNewestDataPool
  from cheesechaser.query import DanbooruIdQuery

  pool = DanbooruNewestDataPool()
  my_waifu_ids = DanbooruIdQuery(['surtr_(arknights)', 'solo'])


  pool.batch_download_to_directory(
      resource_ids=my_waifu_ids,
      dst_dir='/data/exp2_surtr',
      max_workers=12,
  )
  ```

  * Konachan (Gated dataset, you should be granted first and set `HF_TOKEN` environment variable)

  ```python
  from cheesechaser.datapool import KonachanDataPool

  pool = KonachanDataPool()


  pool.batch_download_to_directory(
      resource_ids=range(210000, 210300),
      dst_dir='/data/exp2',
      max_workers=12,
  )
  ```

  * Civitai (this mirror repository on hf is private for now, you have to use hf token of an authorized account)

  ```python
  from cheesechaser.datapool import CivitaiDataPool

  pool = CivitaiDataPool()



  pool.batch_download_to_directory(
      resource_ids=range(7810000, 7810300),
      dst_dir='/data/exp2',
      max_workers=12,
  )
  ```

  More supported:

  * `RealbooruDataPool` (Gated Dataset)
  * `ThreedbooruDataPool` (Gated Dataset)
  * `FancapsDataPool` (Gated Dataset)
  * `BangumiBaseDataPool` (Gated Dataset)
  * `AnimePicturesDataPool` (Gated Dataset)
  * `KonachanDataPool` (Gated Dataset)
  * `YandeDataPool` (Gated Dataset)
  * `ZerochanDataPool` (Gated Dataset)
  * `GelbooruDataPool` and `GelbooruWebpDataPool` (Gated Dataset)
  * `DanbooruNewestDataPool` and `DanbooruNewestWebpDataPool`



  ```python
  from itertools import islice

  from cheesechaser.datapool import DanbooruNewestDataPool
  from cheesechaser.pipe import SimpleImagePipe, PipeItem

  pool = DanbooruNewestDataPool()
  pipe = SimpleImagePipe(pool)


  ids = range(7349990, 7359990)
  with pipe.batch_retrieve(ids) as session:
      
      for i, item in enumerate(islice(session, 20)):
          item: PipeItem
          print(i, item)

  ```


pkgId: fa51cc3cf7404babd540393e7a58fcf7f64cfccc64ebe1a2209e832292fae1c5
name: python-chef-recipes
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Personal recipe management app.
url: https://github.com/xyzjonas/chef
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chef-recipes-2.5.0-1.src.rpm
checksum_type: sha256
description:
  > ! second generation execution environment required.
  - `BUCKET`: name of your GCP/CloudStorage bucket.
  - `MNT_DIR`: target where the bucket will be mounted.
  - `IMAGES_FOLDER`: where the app will be looking for and storing uploaded images, has to be somewhere inside your bucket.
  - `DATABASE_URI`: specify your posgres or possibly put an sqlite file in the bucket as well.


pkgId: e8db464b129c5f7215b868c35a2ca9e4c6e923c3e3f6c2703cb543c792c5a398
name: python-chellow
arch: src
version: 1729081025.0.0
epoch: 0
release: 1
summary: Web Application for checking UK energy bills.
url: https://github.com/WessexWater/chellow
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chellow-1729081025.0.0-1.src.rpm
checksum_type: sha256
description:
  A web application for checking UK electricity and gas bills for organizations with
  a large number of supplies and / or high consumption.

  Website: https://www.chellow.org/




  Chellow is released under the [GPL v3](http://www.gnu.org/licenses/gpl.html).




  Chellow is a web application for checking UK electricity and gas bills. It's designed
  for organizations with high electricity consumption. The software is hosted at
  https://github.com/WessexWater/chellow.

  [![Build Status](https://github.com/WessexWater/chellow/workflows/chellow/badge.svg)](https://github.com/WessexWater/chellow/workflows/chellow)




  Chellow is a Python web application that uses the PostgreSQL database. To install
  Chellow, follow these steps:

  * Install [PostgreSQL](http://www.postgresql.org/) 12
    * Set the PostgreSQL time zone to 'UTC'.
  * Create a PostgreSQL database: `createdb --encoding=UTF8 chellow`
  * Set up the following environment variables to configure Chellow:

  | Name         | Default     | Description            |
  | ------------ | ----------- | ---------------------- |
  | `PGUSER`     | `postgres`  | Postgres user name     |
  | `PGPASSWORD` | `postgres`  | Postgres password      |
  | `PGHOST`     | `localhost` | Postgres host name     |
  | `PGPORT`     | `5432`      | Postgres port          |
  | `PGDATABASE` | `chellow`   | Postgres database name |

  In bash an environment variable can be set by doing:

  `export PGUSER=postgres`

  in Windows an environment variable can be set by doing:

  `set PGUSER=postgres`

  * Install Python 3.9 (tested on the [CPython 3.9.8](http://www.python.org/) interpreter)
  * Create a virtual environment: `python3 -m venv venv`
  * Activate the virtual environment: `source venv/bin/activate`
  * Install Chellow: `pip install chellow`
  * Start Chellow:`waitress-serve --host=0.0.0.0 --port=8080 --call chellow:create_app`
  * You should now be able to visit `http://localhost:8080/` in a browser. You should be
    prompted to enter a username and password. Enter the admin user name
    `admin@example.com` and the password `admin`, and then the home page should appear.
    Change the admin password from the `users` page.




  To upgrade to the latest version of Chellow do: `pip install --upgrade chellow`




  The bash script [chellow\_upgrader.sh](bin/chellow_upgrader.sh) will check for a new
  version of Chellow and if one's there it will stop Chellow, then do the upgrade, then
  start Chellow.




  Copy the following files into the `/etc/systemd/system` directory:

  * [chellow.service](systemd/chellow.service)
  * [chellow\_upgrader.service](systemd/chellow_upgrader.service)
  * [chellow\_upgrader.timer](systemd/chellow_upgrader.timer)

  and modify them as appropriate. The `chellow_upgrader.service` uses the
  `chellow_upgrader.sh` script above. The you should be able to use the following
  commands:

  * Start Chellow: `sudo systemctl start chellow`
  * Make Chellow run on startup: `sudo systemctl enable chellow`
  * Start the Chellow Upgrader: `sudo systemctl start chellow_upgrader.timer`
  * Make Chellow Upgrader run on startup: `sudo systemctl enable chellow_upgrader.timer`




  Chellow comes bundled with the
  [Waitress](http://docs.pylonsproject.org/projects/waitress/en/latest/) webserver, but
  the is also a Python WSGI web application so Chellow can be used with any WSGI compliant
  application server, eg Gunicorn. The WSGI app that should be specified is `chellow.app`.




  This is a brief guide to setting things up after you've installed Chellow. It
  assumes that you have a basic knowledge of
  [UK electricity billing](https://en.wikipedia.org/wiki/Electricity_billing_in_the_UK). It goes through the steps of adding a half-hourly (HH) metered supply,
  and producing virtual bills for it, and then importing an actual bill and
  running a bill check.

  Chellow can handle non-half-hourly supplies as well as half-hourly, and it can
  also deal with gas supplies, but we'll use a half-hourly electricity supply for
  this example.




  Assuming you've installed Chellow correctly, you should be able to open your
  browser, type in the URL of the Chellow application, and see the Chellow home
  page.




  Before any users are added, if you access Chellow from `localhost` you'll have
  read / write access. Once users are added, you have to log in as one of those
  users. Users are added from the 'users' page.




  Follow the instructions at `/e/mdd_imports` to import the Market Domain Data into
  Chellow.




  Every supply must a have a data collector. Add in a new HHDC by going to the
  'HHDC Contracts' page and then clicking on the 'Add' link.




  Every supply must a have a meter operator. Add in a new MOP by going to the
  'MOP Contracts' page and then clicking on the 'Add' link. For now just put in a
  simple virtual bill for the MOP, so in the 'script' field enter:

  ```
      from chellow.utils import reduce_bill_hhs


      def virtual_bill_titles():
          return ['net-gbp']


      def virtual_bill(data_source):
          for hh in data_source.hh_data:
  	bill_hh = data_source.mop_bill_hhs[hh['start-date']]
              if hh['utc-is-month-end']:
                  bill_hh['net-gbp'] = 10
          data_source.mop_bill = reduce_bills_hh(data_source.mop_bill_hhs)
  ```




  Click on the 'supplier contracts' link and then fill out the 'Add a contract'
  form. For the Charge Script field enter:

  ```
      from chellow.utils import reduce_bill_hhs

      def virtual_bill_titles():
          return ['net-gbp', 'day-kwh', 'day-gbp', 'night-kwh', 'night-gbp']

      def virtual_bill(data_source):
          bill = data_source.supplier_bill

          for hh in data_source.hh_data:
  						bill_hh = data_source.supplier_bill_hhs[hh['start-date']]
              if 0 < hh['utc-decimal-hour'] < 8:
                  bill_hh['night-kwh'] = hh['msp-kwh']
                  bill_hh['night-gbp'] = hh['msp-kwh'] * 0.05
              else:
                  bill_hh['day-kwh'] = hh['msp-kwh']
                  bill_hh['day-gbp'] = hh['msp-kwh'] * 0.1

  		bill_hh['net-gbp'] = sum(
  		v for k, v in bill_hh.items() if k[-4:] == '-gbp')

  		data_source.supplier_bill = reduce_bill_hhs(
  			data_source.supplier_bill_hhs)
  ```

  This will generate a simple virtual bill based on a day / night tariff.
  Supplier contract scripts can be much more sophisticated than this, including
  DUoS, TNUoS, BSUoS, RO and many other standard charges. These will be addressed
  later on in this guide.

  Also, don't worry about the 'properties' field for now.




  Go to the 'sites' link on the home page, and click 'add'. Fill out the form
  and create the site.




  To add a supply to a site, go to the site's page and click on 'edit'. Half-way
  down the page there's an 'Insert an electricity supply' form. For a standard
  electricity supply the 'source' is 'net'. Make sure the profile class (PC) is
  '00' to indicate to Chellow that it's a half-hourly metered supply. The SSC
  field is left blank for a half-hourly as they don't have an SSC.

  A supply is formed from a series of eras. Each era has different
  characteristics to capture the history of a supply.




  At this stage it should be possible to run a virtual bill for the supply you've
  added. Go to the supply's page and click on the 'Supplier Virtual Bill' link.
  That should return a page showing the virtual bill for the supply.

  Of course, the consumption will be zero because we haven't added in any
  half-hourly data yet.




  On the page of the supply you've created, you'll see that there's a 'channels'
  link, with an 'add' link next to it. Add an active import channel for the
  half-hourly data to be attached to.

  Back on the supply page a link to the channel you just created will have
  appeared. Click on this and fill out the form for adding a half-hour of data.

  If you then re-run the virtual bill for the period in which you added the
  half-hour, it should show up in the virtual bill.

  It's tedious to add HH data one by one, so if you go to the page of the HHDC
  contract that you've created, you'll see a 'HH Data Imports' link. Click on
  this and there's a form for uploading HH data in bulk in a variety of formats.
  Chellow can also be set up to import files automatically from an FTP server.




  To see the virtual bills for a supplier contract, go to the contract page and
  follow the Virtual Bills link.




    * Site
    * Supply
      * Supply Era
        * Site
        * MOP Contract
        * DC Contract
        * Profile Class
        * Imp / Exp Supplier Contract
        * Imp / Exp Mpan Core
        * Imp / Exp LLFC
        * Imp / Exp Supply Capacity
        * Imp / Exp Channels
          * HH Data
    * Supplier Contracts (Same for DC and MOP)
      * Rate Scripts
      * Batches
        * Bills
          * Supply
          * Register Reads
    * DNOs (Distribution Network Operators)
      * LLFCs (Line Loss Factor Classes)




  The menu has a link called 'General Import' which take you to a page for doing
  bulk insert / update / delete operations on Chellow data (eg. Sites, Supplies,
  LLFCs etc.) using a CSV file.






  Say there are two supplies A and B, and you want to end up with just A. The
  steps are:

  1. Back up the data by taking a snapshot of the database.
  2. Check that A and B have the same header data (LLFC, MTC etc).
  3. See if there are any overlapping channels, eg. do both A and B have import
     kVArh? If there are, then decide which one is going to be kept.
  4. Load the hh data for the required channels from the backup file. First
     take a copy of the file, then edit out the data you don't want, then
     further edit the file so that it loads into the new supply.
  5. Delete supply B.




  Core reports come with Chellow, but it's possible for users to create custom
  reports. Reports are written in Python, and often use a Jinja2 template. You
  can display a link to a report of user reports by adding the `local_reports_id`
  to the `configuration` non-core contract.




  Default users can be automatically assigned to requests from certain IP
  addresses. To associate an IP address to a user, go to the non-core contract
  `configuration` and add a line to the 'properties' field similar to the
  following:

  ```
    {
      'ips': {'127.0.0.1': 'implicit-user@localhost'}
    }
  ```

  Note that multiple IP addresses can be mapped to the same user.

  It's also possible to use Microsoft Active Directory to authenticate users
  with a reverse proxy server. Edit the `configuration` non-core contract and add
  something like:

  ```
    {
      "ad_authentication": {
        "default_user": "readonly@example.com",
        "on": true
    }
  ```




  Why don't you use the +/- infinity values for timestamps? The problem is that it's not clear how this would translate into Python. So we currently use null for infinity, which naturally translates into None in Python.


pkgId: dde01542b48f6e84ad612d536e3ba1fc7316877d26a3fa34e45a029e24627d81
name: python-chem
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: A helper library for chemistry calculations,used by the edx-platform
url: https://github.com/openedx/openedx-chem
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chem-1.3.0-1.src.rpm
checksum_type: sha256
description:
  A helper library for chemistry calculations,
  used by the `edx-platform`_.
  This code originally lived in the `edx-platform`_ repo,
  but now exists here independently.


pkgId: 14c49792c5d861c75307d14f36e873079088959dc0db20cabc4e368027d7df38
name: python-chembl-webresource-client
arch: src
version: 0.10.9
epoch: 0
release: 1
summary: Python client fot accessing ChEMBL webservices.
url: https://www.ebi.ac.uk/chembl/api/data/docs
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chembl-webresource-client-0.10.9-1.src.rpm
checksum_type: sha256
description:
      Documentation and repository: https://github.com/chembl/chembl_webresource_client.
      This is the only official Python client library developed and supported by ChEMBL (https://www.ebi.ac.uk/chembl/) group.

      The library helps accessing ChEMBL data and cheminformatics tools from Python.
      You don't need to know how to write SQL.
      You don't need to know how to interact with REST APIs.
      You don't need to compile or install any cheminformatics framework.
      Results are cached.


pkgId: ea924dd05a86e4e64cd33312b6ae7c2bed497547fe612338e5f2221bbb910145
name: python-chemcell
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: highly modifiable tabulation for chemical reactions
url: https://github.com/SynAeri/Chemcell
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemcell-0.2.5-1.src.rpm
checksum_type: sha256
description:
  [Link to pypi](https://pypi.org/project/chemcell/0.1/)
  A personal study on a curiosity + A free use package for tabulating chemical properties for your data needs!
  &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

  ![Python](https://img.shields.io/badge/python-v3.10+-blue.svg)
  ![Contributions welcome](https://img.shields.io/badge/contributions-welcome-orange.svg)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)



  A Software used to scrape data from [Nist](https://www.nist.gov/), [Chemeo](https://www.chemeo.com/) and [Pubchem](https://pubchem.ncbi.nlm.nih.gov/) to format chemical properties in csv form originally as a study for organic compounds and its partition coefficient, to see if we could use a deepforest algorithm to predict other following reactions.


  Chemcell is a byproduct of a bit of a study I have done with a peer at another University, to both learn new skills and improve efficiency for data processing and analysation,
  This serves to benefit scraping bulk amounts of reaction data from Nist and then using data from pubchem and chemeo (where I personally average the data), I realised (and my peer),
  I could make this a tool to use later while also adding onto it (having the option to allow outliers).

  In essence this is a tool to help with the process of tabulating data for data analysis and personal research purposes - for fun



  ```
  pip install chemcell
  ```


  Getting a bulk dataset including a specific element while modifying what is tabulated from Sites Pubchem, Chemeo and referencing Nist's handy reaction list.
  ```
  from chemcell import Chemcell as Chc
  example = Chc(["HCl"], False, "file_source").range(5,20)
  data = example.tabulate()
  ```
  For self study and educational purposes, general Ml predictions et al.


  Chemical and physical properties from Cheméo.


pkgId: 1cc7b83038e3ad08e1a90f3a08cb035fc466b3fcaf16f8bd7bf2bf67db7ca91f
name: python-chemcloud
arch: src
version: 0.12.1
epoch: 0
release: 1
summary: Fast, secure, scalable quantum chemistry. A Python client for the the ChemCloud server.
url: https://mtzgroup.github.io/chemcloud-client/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemcloud-0.12.1-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/chemcloud.svg)](https://pypi.python.org/pypi/chemcloud)
  [![image](https://img.shields.io/pypi/l/chemcloud.svg)](https://pypi.python.org/pypi/chemcloud)
  [![image](https://img.shields.io/pypi/pyversions/chemcloud.svg)](https://pypi.python.org/pypi/chemcloud)
  [![Actions status](https://github.com/mtzgroup/chemcloud-client/workflows/Tests/badge.svg)](https://github.com/mtzgroup/chemcloud-client/actions)
  [![Actions status](https://github.com/mtzgroup/chemcloud-client/workflows/Basic%20Code%20Quality/badge.svg)](https://github.com/mtzgroup/chemcloud-client/actions)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)



  `chemcloud` is a python client for the [ChemCloud Server](https://github.com/mtzgroup/chemcloud-server). The client provides a simple yet powerful interface to perform computational chemistry calculations using nothing but modern Python and an internet connection.

  **Documentation**: <https://mtzgroup.github.io/chemcloud-client>

  `chemcloud` works in harmony with a suite of other quantum chemistry tools for fast, structured, and interoperable quantum chemistry.



  - [qcio](https://github.com/coltonbh/qcio) - Elegant and intuitive data structures for quantum chemistry, featuring seamless Jupyter Notebook visualizations. [Documentation](https://qcio.coltonhicks.com)
  - [qcparse](https://github.com/coltonbh/qcparse) - A library for efficient parsing of quantum chemistry data into structured `qcio` objects.
  - [qcop](https://github.com/coltonbh/qcop) - A package for operating quantum chemistry programs using `qcio` standardized data structures. Compatible with `TeraChem`, `psi4`, `QChem`, `NWChem`, `ORCA`, `Molpro`, `geomeTRIC`, and many more, featuring seamless Jupyter Notebook visualizations.
  - [BigChem](https://github.com/mtzgroup/bigchem) - A distributed application for running quantum chemistry calculations at scale across clusters of computers or the cloud. Bring multi-node scaling to your favorite quantum chemistry program, featuring seamless Jupyter Notebook visualizations.
  - `ChemCloud` - A [web application](https://github.com/mtzgroup/chemcloud-server) and associated [Python client](https://github.com/mtzgroup/chemcloud-client) for exposing a BigChem cluster securely over the internet, featuring seamless Jupyter Notebook visualizations.



  ```sh
  pip install chemcloud
  ```



  - Create a ChemCloud account at [https://chemcloud.mtzlab.com/signup](https://chemcloud.mtzlab.com/signup) (or the address of the ChemCloud Server you want to communicate with).
  - Instantiate a client
  - Configure client (only required the very first time you use `CCClient`)

  ```python
  from chemcloud import CCClient

  client = CCClient()
  client.configure() # only run this the very first time you use CCClient

  client.supported_engines
  ['psi4', 'terachem', ...]

  client.hello_world("Colton")
  'Welcome to ChemCloud, Colton'
  ```

  - Run calculations just like you would with `qcop` except calling `client.compute` instead of `qcop.compute`. Rather than getting back an `Output` object directly, `client.compute` returns a `FutureOutput` object which can be used to get the output of the computation once it is complete.

  ```python
  from qcio import Structure, ProgramInput
  from chemcloud import CCClient

  client = CCClient()


  h2o = Structure.open("h2o.xyz")


  prog_input = ProgramInput(
      structure=h2o,
      calctype="energy",
      model={"method": "hf", "basis": "sto-3g"},
      keywords={"purify": "no", "restricted": False},
  )


  future_output = client.compute("terachem", prog_input, collect_files=True)

  future_result.status

  output = future_output.get()


  output.input_data # Input data used by the QC program
  output.success # Whether the calculation succeeded
  output.results # All structured results from the calculation
  output.stdout # Stdout log from the calculation
  output.pstdout # Shortcut to print out the stdout in human readable format
  output.files # Any files returned by the calculation
  output.provenance # Provenance information about the calculation
  output.extras # Any extra information not in the schema
  output.traceback # Stack trace if calculation failed
  output.ptraceback # Shortcut to print out the traceback in human readable format
  ```



  Examples of various computations can be found in the [examples directory](https://github.com/mtzgroup/chemcloud-client/tree/main/examples).



  Visualize all your results with a single line of code!

  First install the visualization module:

  ```sh
  pip install qcio[view]
  ```

  or if your shell requires `''` around arguments with brackets:

  ```sh
  pip install 'qcio[view]'
  ```

  Then in a Jupyter notebook import the `qcio` view module and call `view.view(...)` passing it one or any number of `qcio` objects you want to visualizing including `Structure` objects or any `ProgramOutput` object. You may also pass an array of `titles` and/or `subtitles` to add additional information to the molecular structure display. If no titles are passed `qcio` with look for `Structure` identifiers such as a name or SMILES to label the `Structure`.

  ![Structure Viewer](https://public.coltonhicks.com/assets/qcio/structure_viewer.png)

  Seamless visualizations for `ProgramOutput` objects make results analysis easy!

  ![Optimization Viewer](https://public.coltonhicks.com/assets/qcio/optimization_viewer.png)

  Single point calculations display their results in a table.

  ![Single Point Viewer](https://public.coltonhicks.com/assets/qcio/single_point_viewer.png)

  If you want to use the HTML generated by the viewer to build your own dashboards use the functions inside of `qcio.view.py` that begin with the word `generate_` to create HTML you can insert into any dashboard.



  If you have any issues with `chemcloud` or would like to request a feature, please open an [issue](https://github.com/mtzgroup/chemcloud-client/issues).


pkgId: 0962e43870a64bf0338d9b6f5c34a2ed7ea81fe3e27ae6554bae6b0814408fc8
name: python-chemcomp-loader
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: Load disc and planet data from chemcomp simulations.
url: https://pypi.org/project/chemcomp-loader/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemcomp-loader-0.4.5-1.src.rpm
checksum_type: sha256
description:
  Python package to load disc data from simulations from the semi-analytical viscous disc code "chemcomp" by Schneider & Bitsch 2021.


pkgId: 94e818230e97eaf612d79dc9660a7b2699d2d04698c1229c3ed3eb57e06aab3f
name: python-chemcrow
arch: src
version: 0.3.24
epoch: 0
release: 1
summary: Accurate solution of reasoning-intensive chemical tasks, powered by LLMs.
url: https://github.com/ur-whitelab/chemcrow-public
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemcrow-0.3.24-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/ur-whitelab/chemcrow-public/actions/workflows/tests.yml/badge.svg)](https://github.com/ur-whitelab/chemcrow-public)
  [![PyPI](https://img.shields.io/pypi/v/chemcrow)](https://img.shields.io/pypi/v/chemcrow)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chemcrow)](https://img.shields.io/pypi/pyversions/chemcrow)
  [![DOI:10.1101/2020.07.15.204701](https://zenodo.org/badge/DOI/10.48550/arXiv.2304.05376.svg)](https://doi.org/10.48550/arXiv.2304.05376)


  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="assets/chemcrow_dark_bold.png" width='100%'>
    <source media="(prefers-color-scheme: light)" srcset="assets/chemcrow_light_bold.png" width='100%'>
    <img alt="ChemCrow logo" src="/assets/" width="100%">
  </picture>


  <br></br>


  ChemCrow is an open source package for the accurate solution of reasoning-intensive chemical tasks.

  Built with Langchain, it uses a collection of chemical tools including RDKit, paper-qa, as well as some relevant databases in chemistry, like Pubchem and chem-space.



  [![ChemCrow Demo](assets/hf-demo.png)](https://huggingface.co/spaces/doncamilom/ChemCrow)




  This package does not contain all the tools described in the [ChemCrow paper](https://arxiv.org/abs/2304.05376) because
  of API usage restrictions. This repo will not give the same results as that paper.

  All the experiments have been released under [ChemCrow runs](https://github.com/ur-whitelab/chemcrow-runs).




  ```
  pip install chemcrow
  ```


  First set up your API keys in your environment.
  ```
  export OPENAI_API_KEY=your-openai-api-key
  ```

  You can optionally use Serp API:

  ```
  export SERP_API_KEY=your-serpapi-api-key
  ```

  In a Python session:
  ```python
  from chemcrow.agents import ChemCrow

  chem_model = ChemCrow(model="gpt-4-0613", temp=0.1, streaming=False)
  chem_model.run("What is the molecular weight of tylenol?")
  ```


  Bran, Andres M., et al. "ChemCrow: Augmenting large-language models with chemistry tools." arXiv preprint arXiv:2304.05376 (2023).

  ```bibtex
  @article{bran2023chemcrow,
        title={ChemCrow: Augmenting large-language models with chemistry tools},
        author={Andres M Bran and Sam Cox and Oliver Schilter and Carlo Baldassari and Andrew D White and Philippe Schwaller},
        year={2023},
        eprint={2304.05376},
        archivePrefix={arXiv},
        primaryClass={physics.chem-ph},
        publisher={arXiv}
  }
  ```


pkgId: 13dd3c172c57d3cb1791b8e546185d779a5e79c8c896b72c8e7fc02f66bfaaea
name: python-chemformula
arch: src
version: 1.3.1
epoch: 0
release: 1
url: https://github.com/molshape/ChemFormula
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemformula-1.3.1-1.src.rpm
checksum_type: sha256
summary:
  ChemFormula is a Python class for working with chemical formulas. It allows parsing chemical formulas, generating formatted output strings and calculating formula weights.

description:
   Print instance: ((CH3)3N)(C6H11O2)
   Original:       ((CH3)3N)(C6H11O2)
   Text formula:   ((CH3)3N)(C6H11O2) +
   HTML:           <span class='ChemFormula'>((CH<sub>3</sub>)<sub>3</sub>N)(C<sub>6</sub>H<sub>11</sub>O<sub>2</sub>)<sup>+</sup></span>
   LaTeX:          \(\(\textnormal{C}\textnormal{H}_{3}\)_{3}\textnormal{N}\)\(\textnormal{C}_{6}\textnormal{H}_{11}\textnormal{O}_{2}\)^{+}
   Unicode:        ((CH₃)₃N)(C₆H₁₁O₂)⁺
   Charge (int):   1
   Charge (str):   +
   Sum formula:    C9H20NO2
   Sum (HTML):     <span class='ChemFormula'>C<sub>9</sub>H<sub>20</sub>NO<sub>2</sub><sup>+</sup></span>
   Sum (Unicode):  C₉H₂₀NO₂⁺
   Hill formula:   C9H20NO2


pkgId: 7e96ec815dbe622b8200920fcced568102defd22e4bbad89b89d912584f69e61
name: python-chemfunc
arch: src
version: 1.0.10
epoch: 0
release: 1
summary: Useful functions and scripts for working with small molecules.
url: https://github.com/swansonk14/chemfunc
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemfunc-1.0.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chemfunc)](https://badge.fury.io/py/chemfunc)
  [![PyPI version](https://badge.fury.io/py/chemfunc.svg)](https://badge.fury.io/py/chemfunc)
  [![Downloads](https://pepy.tech/badge/chemfunc)](https://pepy.tech/project/chemfunc)
  [![license](https://img.shields.io/github/license/swansonk14/chemfunc.svg)](https://github.com/swansonk14/chemfunc/blob/main/src/LICENSE.txt)

  Useful functions and scripts for working with small molecules.



  Optionally, create a conda environment.
  ```bash
  conda create -y -n chemfunc python=3.12
  conda activate chemfunc
  ```

  Install the latest version of Chem Func using pip.
  ```
  pip install chemfunc
  ```

  Alternatively, clone the repository and install the local version of the package.
  ```
  git clone https://github.com/swansonk14/chemfunc.git
  cd chemfunc
  pip install -e .
  ```

  **Note:** If you get the issue `ImportError: libXrender.so.1: cannot open shared object file: No such file or directory`, run `conda install -c conda-forge xorg-libxrender`.




  Chem Func contains a variety of useful functions and scripts for working with small molecules.

  Functions can be imported from the `chemfunc` package. For example:
  ```python
  from pathlib import Path
  from chemfunc.sdf_to_smiles import sdf_to_smiles

  sdf_to_smiles(
      data_path=Path('molecules.sdf'),
      save_path=Path('molecules.csv')
  )
  ```

  Most modules can also be run as scripts from the command line using the `chemfunc` command along with the appropriate function name. For example:
  ```bash
  chemfunc sdf_to_smiles \
      --data_path molecules.sdf \
      --save_path molecules.csv
  ```

  To see a list of available scripts, run `chemfunc -h`.

  For each script, run `chemfunc <script_name> -h` to see a description of the arguments for that script.




  Below is a list of the contents of the package.

  [`canonicalize_smiles.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/canonicalize_smiles.py) (function, script)

  Canonicalizes SMILES using RDKit canonicalization and optionally strips salts.

  [`chemical_diversity.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/chemical_diversity.py) (function, script)

  Computes the chemical diversity of a set of molecules in terms of Tanimoto distances.

  [`cluster_molecules.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/cluster_molecules.py) (function, script)

  Performs k-means clustering to cluster molecules based on Morgan fingerprints.

  [`compute_properties.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/compute_properties.py) (function, script)

  Computes one or more molecular properties for a set of molecules.

  [`convert_sdf.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/convert_sdf.py) (functions)

  Functions to convert SDF files to SMILES or SMARTS. Used by `sdf_to_smiles` and `sdf_to_smarts`.

  [`deduplicate_smiles.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/deduplicate_smiles.py) (function, script)

  Deduplicate a CSV files by SMILES.

  [`filter_molecules.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/filter_molecules.py) (function, script)

  Filters molecules to those with values in a certain range.

  [`measure_experimental_reproducibility.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/measure_experimental_reproducibility.py) (function, script)

  Measures the experimental reproducibility of two biological replicates by using one replicate to predict the other.

  [`molecular_fingerprints.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/molecular_fingerprints.py) (functions, script)

  Contains functions to compute fingerprints for molecules. Parallelized for speed. The function `save_fingerprints` can be used as a script to compute fingerprints from a CSV file and save them as an NPZ file.

  [`molecular_properties.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/molecular_properties.py) (functions)

  Contains functions to compute molecular properties. Parallelized for speed.

  [`molecular_similarities.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/molecular_similarities.py) (functions)

  Contains functions to compute similarities between molecules. Parallelized for speed.

  [`nearest_neighbor.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/nearest_neighbor.py) (function, script)

  Given a dataset of molecules, computes the nearest neighbor molecule in a second dataset using one of several similarity metrics.

  [`plot_property_distribution.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/plot_property_distribution.py) (function, script)

  Plots the distribution of molecular properties of a set of molecules.

  [`plot_tsne.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/plot_tsne.py) (function, script)

  Runs a t-SNE on molecular fingerprints from one or more chemical libraries.

  [`regression_to_classification.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/regression_to_classification.py) (function, script)

  Converts regression data to classification data using given thresholds.

  [`sample_molecules.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/sample_molecules.py) (function, script)

  Samples molecules from a CSV file, either uniformly at random across the entire dataset or uniformly at random from each cluster within the data.

  [`sdf_to_smarts.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/sdf_to_smarts.py) (function, script)

  Converts an SDF file to a CSV file with SMARTS.

  [`sdf_to_smiles.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/sdf_to_smiles.py) (function, script)

  Converts an SDF file to a CSV file with SMILES.

  [`select_from_clusters.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/select_from_clusters.py) (function, script)

  Selects the best molecule from each cluster.

  [`smiles_to_svg.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/smiles_to_svg.py) (function, script)

  Converts a SMILES string to an SVG image of the molecule.

  [`visualize_molecules.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/visualize_molecules.py)(function, script)

  Converts a file of SMILES to images of molecular structures.

  [`visualize_reactions.py`](https://github.com/swansonk14/chemfunc/blob/main/src/chemfunc/visualize_reactions.py) (function, script)

  Converts a file of reaction SMARTS to images of chemical reactions.

rpm_license:
  MIT License  Copyright (c) 2024 Kyle Swanson  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: 6c41cca4460d5af3c1674c5bcb3d617e8a4e791519f238b0cc67b39baaeb1886
name: python-chemfusekit
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: A minimal Python / Jupyter Notebook / Colab library for data fusion and chemometrical analysis.
url: https://pypi.org/project/chemfusekit/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemfusekit-3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint)
  [![Pylint](https://github.com/f-aguzzi/tesi/actions/workflows/pylint.yml/badge.svg)](https://github.com/f-aguzzi/tesi/)
  [![Unittest](https://github.com/f-aguzzi/tesi/actions/workflows/unittest.yml/badge.svg)](https://github.com/f-aguzzi/tesi/)
  [![](https://img.shields.io/badge/Read_the_docs-GitHub_Pages-darkorange)](https://f-aguzzi.github.io/tesi/)
  [![Try It In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/pca_lda_example_notebook.ipynb)
  <p align="center">
    <img src="https://raw.githubusercontent.com/f-aguzzi/tesi/main/docs/static/img/logo.svg" alt="Library Logo" style="width: 20%;">
  </p>

  A minimal Python / Jupyter Notebook / Colab library for data fusion and
  chemometrical analysis.

  Developed as Federico Aguzzi's Computer Engineering undergraduate thesis
  project, under the supervision of Software Engineering Professor
  [Angelo Michele Gargantini](https://cs.unibg.it/gargantini/),
  based on the scripts made by Dr
  [Giorgio Felizzato](https://www.unibg.it/ugov/person/139887)
  and the research of Professor
  [Francesco Saverio Romolo](https://unibg.unifind.cineca.it/individual?uri=http%3A%2F%2Firises.unibg.it%2Fresource%2Fperson%2F80828)
  of the Law Department of the University of Bergamo. Further info on the project
  [here](https://f-aguzzi.github.io/tesi/project).

  <br />

  Get it on `pip`:
  ```bash
  pip install chemfusekit
  ```

  <br />

  You can also try this demo:

  [![Try It In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/pca_lda_notebook.ipynb)

  and find instructions [here](https://f-aguzzi.github.io/tesi/docs/tutorial).

  <br />



  - **data fusion**: join data from different sensors to increase the quality and
    precision of your chemometrical analysis
  - **model training**: train, save and load statistical models
  - **data classification**: use your models to classify and predict

  Here's a list of the currently available modules:
  - **LLDF**: *Low-Level Data Fusion*
  - **PCA**: *Principal Component Analysis*
  - **LDA**: *Linear Discriminant Analysis* ([demo](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/pca_lda_notebook.ipynb))
  - **SVM**: *Support Vector Machine* ([demo](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/svm_notebook.ipynb))
  - **LR**: *Logistic Regression* ([demo](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/pca_lr_notebook.ipynb))
  - **KNN**: *k_Neighbors Analysis* ([demo](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/knn_notebook.ipynb))
  - **PLSDA**: *Partial Least Squres Discriminant Analysis* ([demo](https://colab.research.google.com/github/f-aguzzi/tesi/blob/main/examples/plsda_notebook.ipynb))


pkgId: 1d6d1147185d4788fbaa9c62c24bab10dd7410b9fe6818a223a666d43f9072e4
name: python-chemics
arch: src
version: 24.1
epoch: 0
release: 1
summary: A Python package for chemical engineering
url: https://github.com/wigging/chemics
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemics-24.1-1.src.rpm
checksum_type: sha256
description:
  Chemics is a Python package for chemistry and chemical engineering applications. It is open-source and contributions from the scientific community are encouraged.



  If you don't have Python installed on your computer, the [Anaconda](https://www.anaconda.com) or [Miniconda](https://conda.io/miniconda.html) distribution of Python is recommended for scientific computing. After setting up Python, the Chemics package can be downloaded and installed using the pip package manager.

  ```bash
  $ pip install chemics
  ```



  The example below imports the Chemics package and uses the `Gas` class to calculate the density and viscosity of nitrogen gas at a temperature of 773 K and pressure of 101,325 Pa.

  ```python
  import chemics as cm

  gas = cm.Gas("N2", 773)
  rho = gas.density()
  mu = gas.viscosity()

  print("Nitrogen gas properties at 773 K and 101,325 Pa")
  print(f"density    {rho:.4f} kg/m³")
  print(f"viscosity  {mu:.2f} μP")
  ```

  This prints the following:

  ```
  Nitrogen gas properties at 773 K and 101,325 Pa
  density    0.4416 kg/m³
  viscosity  363.82 μP
  ```

  This example uses the `ChemicalEquation` class to get properties of the reactants and products from a given chemical equation.

  ```python
  import chemics as cm

  ce = cm.ChemicalEquation("2 HCl + 2 Na -> 2 NaCl + H2")
  ce.is_balanced()


  ce.rct_properties








  ```

  More examples are available in the documentation.



  Documentation for the Chemics package is available at [chemics.readthedocs.io](https://chemics.readthedocs.io).



  See the [CONTRIBUTING.md](CONTRIBUTING.md) document for guidelines on contributing to the Chemics package.



  Chemics is available under the MIT License - see the [LICENSE](LICENSE) file for more information.


pkgId: f9ff410f7812f6a35c11a3194b95a7e25c39af3856de7bd0ef0d77330766b1d7
name: python-cheminfopy
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Python SDK for interacting with the cheminfo ELN
url: https://github.com/cheminfo-py/cheminfopy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheminfopy-0.9.0-1.src.rpm
checksum_type: sha256
description:
  <!--
  <p align="center">
    <img src="https://github.com/cheminfo-py/cheminfopy/raw/main/docs/source/logo.png" height="150">
  </p>
  -->

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

  <p align="center">
      <a href="https://github.com/cheminfo-py/cheminfopy/actions?query=workflow%3ATests">
          <img alt="Tests" src="https://github.com/cheminfo-py/cheminfopy/workflows/Tests/badge.svg" />
      </a>
      <a href="https://github.com/cthoyt/cookiecutter-python-package">
          <img alt="Cookiecutter template from @cthoyt" src="https://img.shields.io/badge/Cookiecutter-python--package-yellow" />
      </a>
      <a href="https://pypi.org/project/cheminfopy">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/cheminfopy" />
      </a>
      <a href="https://pypi.org/project/cheminfopy">
          <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/cheminfopy" />
      </a>
      <a href="https://github.com/cheminfo-py/cheminfopy/blob/main/LICENSE">
          <img alt="PyPI - License" src="https://img.shields.io/pypi/l/cheminfopy" />
      </a>
      <a href='https://cheminfopy.readthedocs.io/en/latest/?badge=latest'>
          <img src='https://readthedocs.org/projects/cheminfopy/badge/?version=latest' alt='Documentation Status' />
      </a>
      <a href='https://github.com/psf/black'>
          <img src='https://img.shields.io/badge/code%20style-black-000000.svg' alt='Code style: black' />
      </a>
  </p>

  Python SDK for interacting with the cheminfo ELN



  > TODO show in a very small amount of space the **MOST** useful thing your package can do.
  Make it as short as possible! You have an entire set of docs for later.



  The cheminfopy command line tool is automatically installed. It can
  be used from the shell with the `--help` flag to show all subcommands:

  ```shell
  $ cheminfopy --help
  ```

  > TODO show the most useful thing the CLI does! The CLI will have documentation auto-generated
  by `sphinx`.



  <!-- Uncomment this section after your first ``tox -e finish``
  The most recent release can be installed from
  [PyPI](https://pypi.org/project/cheminfopy/) with:

  ```bash
  $ pip install cheminfopy
  ```
  -->

  The most recent code and data can be installed directly from GitHub with:

  ```bash
  $ pip install git+https://github.com/cheminfo-py/cheminfopy.git
  ```

  To install in development mode, use the following:

  ```bash
  $ git clone git+https://github.com/cheminfo-py/cheminfopy.git
  $ cd cheminfopy
  $ pip install -e .
  ```



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





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

  <!--


  Citation goes here!
  -->

  <!--


  This project has been supported by the following organizations (in alphabetical order):

  - [Harvard Program in Therapeutic Science - Laboratory of Systems Pharmacology](https://hits.harvard.edu/the-program/laboratory-of-systems-pharmacology/)

  -->

  <!--


  This project has been supported by the following grants:

  | Funding Body                                             | Program                                                                                                                       | Grant           |
  |----------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|-----------------|
  | DARPA                                                    | [Automating Scientific Knowledge Extraction (ASKE)](https://www.darpa.mil/program/automating-scientific-knowledge-extraction) | HR00111990009   |
  -->



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



  <details>
    <summary>See developer instrutions</summary>


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



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

  ```shell
  $ tox
  ```

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



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

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

  This script does the following:

  1. Uses BumpVersion to switch the version number in the `setup.cfg` and
     `src/cheminfopy/version.py` to not have the `-dev` suffix
  2. Packages the code in both a tar archive and a wheel
  3. Uploads to PyPI using `twine`. Be sure to have a `.pypirc` file configured to avoid the need for manual input at this
     step
  4. Push to GitHub. You'll need to make a release going with the commit where the version was bumped.
  5. Bump the version to the next patch. If you made big changes and want to bump the version by minor, you can
     use `tox -e bumpversion minor` after.
  </details>


pkgId: afc8dbdddd924f99747fad5b3a61d3f9165e6b16eff725ef843d6e99253e990f
name: python-chemlib
arch: src
version: 2.2.4
epoch: 0
release: 1
summary: An easy-to-use library that quickly performs chemistry calculations.
url: https://github.com/harirakul/chemlib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemlib-2.2.4-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">chemlib</h1>

  <div align="center">
    ⚗️🔬👨‍🔬🧪
  </div>
  <div align="center">
    <strong>Chemistry Library</strong>
  </div>

  <p align="center">
  A pure Python package that supports a variety of functions pertaining to the vast field of chemistry.
    </p>
  <br>
  <div align="center">
    <!-- PyPI -->
    <a href="https://badge.fury.io/py/chemlib">
      <img src="https://badge.fury.io/py/chemlib.svg"/>
    </a>
    <!-- License -->
    <a href="https://github.com/harirakul/chemlib/blob/master/LICENSE.txt">
      <img src="https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000" />
    </a>
    <!-- Documentation Status -->
    <a href="https://chemlib.readthedocs.io/en/latest/">
      <img src="https://readthedocs.org/projects/chemlib/badge/?version=latest"
   />
    </a>

  <!-- Build Status -->

  <a href="https://github.com/harirakul/chemlib/workflows/build/badge.svg">
      <img src="https://github.com/harirakul/chemlib/workflows/build/badge.svg" />
    </a>

  <!-- Downloads -->

  <a href="https://pepy.tech/project/chemlib">
      <img src="https://pepy.tech/badge/chemlib" />
    </a>
  </div>
  <div align="center">
    <h3>
      <a href="https://chemlib.readthedocs.io/en/latest/">
        Documentation
      </a>
      <span> | </span>
      <a href="https://github.com/harirakul/chemlib/issues">
        Report a Bug
      </a>
      <span> | </span>
      <a href="https://github.com/harirakul/chemlib/pulls">
        Submit a Pull Request
  </a>
    </h3>
  </div>
  <br>






  Use the Python Package Installer (PyPI):

  ```sh
  $ pip install -U chemlib
  ```



  - [Properties of all Elements](https://chemlib.readthedocs.io/en/latest/core.html#elements)
  - [Compounds](https://chemlib.readthedocs.io/en/latest/compounds.html)
    * Formula
    * Molar Mass
    * Percentage Composition by Mass
    * Stoichiometric Amounts
    * Oxidation States/Numbers
  - [Empirical Formulae](https://chemlib.readthedocs.io/en/latest/formulae.html)
    * Empirical Formula by Percentage Composition
    * Combustion Analysis of Hydrocarbons
  - [Aqueous Solutions](https://chemlib.readthedocs.io/en/latest/solution.html)
    * Solute
    * Molarity (mol/L)
    * Stoichiometric Amounts
    * Dilutions
  - [Chemical Reactions](https://chemlib.readthedocs.io/en/latest/reactions.html)
    * Formula
    * Balancing the Equation
    * Combustion Reactions
    * Stoichiometric Amounts
    * Limiting Reagent
  - [Electrochemistry](https://chemlib.readthedocs.io/en/latest/electrochemistry.html)
    * Galvanic (Voltaic) Cells
      * Anode, Cathode, Cell Potential, Diagram
    * Electrolysis
  - [Quantum Mechanics](https://chemlib.readthedocs.io/en/latest/quantum.html)
    * Electromagnetic Waves
      * Frequency, Wavelength, Energy per photon
    * Energy in nth Hydrogen Orbital
    * Rydberg Equation

  <!-- ### Periodic Table GUI
  ![PTable](https://github.com/harirakul/chemlib/blob/master/chemlib/screenshots/PTable.png) -->



  ![Zn-Cu Galvanic Cell](https://github.com/harirakul/chemlib/blob/master/chemlib/screenshots/GCell.jpg)



  ```python
  >>> from chemlib import Element

  >>> boron = Element('B')   #Declare Element from its symbol

  >>> boron.properties
  {'AtomicNumber': 5.0, 'Element': 'Boron', 'Symbol': 'B', 'AtomicMass': 10.811, 'Neutrons': 6.0, 'Protons': 5.0, 'Electrons': 5.0, 'Period': 2.0, 'Group': 13.0, 'Phase': 'solid', 'Radioactive': False, 'Natural': True, 'Metal': False, 'Nonmetal': False, 'Metalloid': True, 'Type': 'Metalloid', 'AtomicRadius': '1.2', 'Electronegativity': 2.04, 'FirstIonization': '8.298', 'Density': '2.34', 'MeltingPoint': '2573.15', 'BoilingPoint': '4200', 'Isotopes': 6.0, 'Discoverer': 'Gay-Lussac', 'Year': '1808', 'SpecificHeat': '1.026', 'Shells': 2.0, 'Valence': 3.0, 'Config': '[He] 2s2 2p1', 'MassNumber': 11.0}

  >>> boron.AtomicMass
  10.811
  ```



  ```python
  >>> from chemlib import Compound

  >>> nitric_acid = Compound("HNO3")

  >>> nitric_acid.occurences
  {'H': 1, 'N': 1, 'O': 3}

  >>> nitric_acid.molar_mass()
  63.01

  >>> nitric_acid.percentage_by_mass('O')  #Get percentage composition by mass of a constituent element of choice
  76.174

  ```



  Accepted inputs: grams, moles, and molecules

  ```python
  >>> from chemlib import Compound

  >>> water = Compound('H2O')

  >>> water.formula
  'H₂O₁'

  >>> water.get_amounts(grams = 2)
  {'Compound': 'H₂O₁', 'Grams': 2, 'Moles': 0.111, 'Molecules': 6.685e+22}

  >>> water.get_amounts(moles = 1)
  {'Compound': 'H₂O₁', 'Grams': 18.01, 'Moles': 1, 'Molecules': 6.02e+23}

  >>> water.get_amounts(molecules = 1.0e+24)
  {'Compound': 'H₂O₁', 'Grams': 29.917, 'Moles': 1.6611, 'Molecules': 1e+24}

  ```



  ```python

  >>> from chemlib import Compound, Reaction

  >>> H2 = Compound('H2')
  >>> O2 = Compound('O2')
  >>> H2O = Compound('H2O')
  >>> r = Reaction(reactants = [H2, O2], products = [H2O])

  >>> r.formula
  '1H₂ + 1O₂ --> 1H₂O₁'

  >>> r.is_balanced
  False

  >>> r.balance()

  >>> r.formula
  '2H₂ + 1O₂ --> 2H₂O₁'

  >>> r.is_balanced
  True
  ```



  If you use [chemlib](https://chemlib.readthedocs.io/en/latest/index.html) in your scientific work, please consider citing:

  |     H. R. Ambethkar, *chemlib* - A Python chemistry library , 2020\-- . Available at:
  [https://github.com/harirakul/chemlib](https://github.com/harirakul/chemlib).

  The reference in the [BibLaTeX](https://www.ctan.org/pkg/biblatex?lang=en) format:

  ```{.sourceCode .latex}
  @software{chemlib2020,
     author = {Ambethkar, Hari},
     title = {{chemlib} -- A Python chemistry library},
     url = {https://github.com/harirakul/chemlib},
     version = {2.1.9},
     date = {2020--},
  }
  ```


pkgId: 5673f8f61932b072147b30e4eeb25655aa6847c68d1670a688c83e40b992f005
name: python-chemoecology-tools
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Chemoecology Tools
url: https://github.com/wolfffff/chemoecology-tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemoecology-tools-0.1.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/chemoecology-tools.svg)
  ![Status](https://img.shields.io/pypi/status/chemoecology-tools.svg)
  ![Python Version](https://img.shields.io/pypi/pyversions/chemoecology-tools)
  ![License](https://img.shields.io/pypi/l/chemoecology-tools)

  [![Read the documentation at https://chemoecology-tools.readthedocs.io/](https://img.shields.io/readthedocs/chemoecology-tools/latest.svg?label=Read%20the%20Docs)][read the docs]
  [![Tests](https://github.com/wolfffff/chemoecology-tools/workflows/Tests/badge.svg)][tests]
  [![Codecov](https://codecov.io/gh/wolfffff/chemoecology-tools/branch/main/graph/badge.svg)][codecov]

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)][pre-commit]
  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]

  [pypi_]: https://pypi.org/project/chemoecology-tools/
  [status]: https://pypi.org/project/chemoecology-tools/
  [python version]: https://pypi.org/project/chemoecology-tools
  [read the docs]: https://chemoecology-tools.readthedocs.io/
  [tests]: https://github.com/wolfffff/chemoecology-tools/actions?workflow=Tests
  [codecov]: https://app.codecov.io/gh/wolfffff/chemoecology-tools
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [black]: https://github.com/psf/black



  - Load and process GC-MS abundance data
  - Calculate chemical enrichment statistics
  - Perform multivariate analyses (NMDS, PCA)
  - Generate publication-ready visualizations
  - Integrate with PubChem for chemical metadata



  You can install _Chemoecology Tools_ via [pip](https://pip.pypa.io/) from [PyPI](https://pypi.org/project/chemoecology-tools/) or from source.

  ```console
  $ pip install chemoecology-tools
  ```

  ```console
  $ pip install git+https://github.com/wolfffff/chemoecology-tools.git
  ```



  Full documentation is available at [Read the Docs](https://chemoecology-tools.readthedocs.io/).

  - See also the example notebook at [example notebook](https://github.com/wolfffff/chemoecology-tools/blob/main/docs/notebooks/example.ipynb).



  Contributions are very welcome.
  To learn more, see the [Contributor Guide](https://github.com/wolfffff/chemoecology-tools/blob/main/CONTRIBUTING.md).



  Distributed under the terms of the [MIT license](https://github.com/wolfffff/chemoecology-tools/blob/main/LICENSE),
  _Chemoecology Tools_ is free and open source software.



  If you encounter any problems,
  please [file an issue](https://github.com/wolfffff/chemoecology-tools/issues) along with a detailed description.

  <!-- github-only -->


pkgId: 5ac8c05e7d9790ca1f89c1af46fdb52a32d5cd7d43eca2e23981a5d2683e5705
name: python-chemotion-api
arch: src
version: 0.3.42
epoch: 0
release: 1
summary: A Chemotion python API
url: https://pypi.org/project/chemotion-api/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemotion-api-0.3.42-1.src.rpm
checksum_type: sha256
description:
  A python api for [Chemotion](https://chemotion.net/). Chemotion is a Electronic Laboratory Notebook (ELN) developed at
  the KIT is a web-based platform designed to help researchers manage and organize their experimental data in a secure and
  efficient manner.

  The ChemotionApi Python package is a wrapper for the RESTful API built on top of the Ruby on Rails
  framework that allows users to interact with Chemotion ELN. The package provides a simple and intuitive
  interface for creating, retrieving, updating, and deleting data stored in the ELN using Python. With
  its RESTful architecture and comprehensive documentation, the ChemotionApi allows users to build custom applications and
  workflows that leverage the ELN's capabilities and streamline their research processes.



  Detaild documentation can be found [here](https://chemotionapi.readthedocs.io/en/main/)



  Contributions to ChemotionApi are welcome! If you have any bug reports, feature requests, or suggestions, please
  open an issue on the GitHub repository. You can also submit
  pull requests with your proposed changes.



  ChemotionApi is licensed under the MIT License.

  **Let me know if there's anything else I can help you with!**


pkgId: 5295408cbb0d6bb54999608906f3bd1545d0afd02ee0122d717b50ec3d287830
name: python-chemotools
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Package to integrate chemometrics in scikit-learn pipelines
url: https://github.com/paucablop/chemotools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemotools-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ![chemotools](assets/images/logo_pixel.png)


  [![pypi](https://img.shields.io/pypi/v/chemotools)](https://pypi.org/project/chemotools)
  [![pypi](https://img.shields.io/pypi/pyversions/chemotools)](https://pypi.org/project/chemotools)
  [![pypi](https://img.shields.io/pypi/l/chemotools)](https://github.com/paucablop/chemotools/blob/main/LICENSE)
  [![codecov](https://codecov.io/github/paucablop/chemotools/branch/main/graph/badge.svg?token=D7JUJM89LN)](https://codecov.io/github/paucablop/chemotools)
  [![Downloads](https://static.pepy.tech/badge/chemotools)](https://pepy.tech/project/chemotools)



  Welcome to Chemotools, a Python package that integrates chemometrics with Scikit-learn.



  Since I released Chemotools, I have received a fantastic response from the community. I am really happy for the interest in the project 🤗. This also means that I have received a lot of good feedback and suggestions for improvements. I have been intensively working on releasing new versions of Chemotools to address the feedback and suggestions. If you use Chemotools, __make sure you are using the latest version__ (see installation), which will be aligned with the documentation.

  👉👉 Check the [latest version](https://pypi.org/project/chemotools/) and make sure you don't miss out on cool new features.

  👉👉 Check the [documentation](https://paucablop.github.io/chemotools/) for a full description on how to use chemotools.



  Chemotools is a Python package that provides a collection of preprocessing tools and utilities for working with spectral data. It is built on top of popular scientific libraries and is designed to be highly modular, easy to use, and compatible with Scikit-learn transformers.

  If you are interested in learning more about chemotools, please visit the [documentation](https://paucablop.github.io/chemotools/) page.

  Benefits:
  - Provides a collection of preprocessing tools and utilities for working with spectral data
  - Highly modular and compatible with Scikit-learn transformers
  - Can perform popular preprocessing tasks such as baseline correction, smoothing, scaling, derivatization, and scattering correction
  - Open source and available on PyPI

  Applications:
  - Analyzing and processing spectral data in chemistry, biology, and other fields
  - Developing machine learning models for predicting properties or classifying samples based on spectral data
  - Teaching and learning about chemometrics and data preprocessing in Python



  Chemotools is distributed via PyPI and can be easily installed using pip:

  ```bash
  pip install chemotools
  ```

  Upgrading to the latest version is as simple as:

  ```bash
  pip install chemotools --upgrade
  ```



  Chemotools is designed to be used in conjunction with Scikit-learn. It follows the same API as other Scikit-learn transformers, so you can easily integrate it into your existing workflow. For example, you can use chemotools to build pipelines that include transformers from chemotools and Scikit-learn:

  ```python
  from sklearn.preprocessing import StandardScaler
  from sklearn.pipeline import make_pipeline

  from chemotools.baseline import AirPls
  from chemotools.scatter import MultiplicativeScatterCorrection

  preprocessing = make_pipeline(AirPls(), MultiplicativeScatterCorrection(), StandardScaler(with_std=False))
  spectra_transformed = preprocessing.fit_transform(spectra)
  ```

  Check the [documentation](https://paucablop.github.io/chemotools/) for more information on how to use chemotools.




  We welcome contributions to Chemotools from anyone interested in improving the package. Whether you have ideas for new features, bug reports, or just want to help improve the code, we appreciate your contributions! You are also welcome to see the [Project Board](https://github.com/users/paucablop/projects/4) to see what we are currently working on.

  To contribute to Chemotools, please follow the [contributing guidelines](CONTRIBUTING.md).



  This package is distributed under the MIT license. See the [LICENSE](LICENSE) file for more information.



  AirPLS baseline correction is based on the implementation by [Zhang et al.](https://pubs.rsc.org/is/content/articlelanding/2010/an/b922045c). The current implementation is based on the Python implementation by [zmzhang](https://github.com/zmzhang/airPLS).


pkgId: 31502b81537b7c3661f9e7d5b38fb2df4166d779c88797d48e28389db8c3dd99
name: python-chemparse
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Chemical formula parser
url: https://pypi.org/project/chemparse/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemparse-0.3.1-1.src.rpm
checksum_type: sha256
description:
  **Authors:** Grayson Boyer and Victor Ignatenko

  A lightweight package for parsing chemical formula strings into python dictionaries.



  * Convert a chemical formula string into a python dictionary.
      - example: `"CH4"` returns `{"C":1.0, "H":4.0}`
  * Handles fractional stoichiometry.
      - example: `"C1.5O3"` returns `{"C":1.5, "O":3.0}`
      - example: `"H2e-1O1e-1"` returns `{"H":0.2, "O":0.1}`
  * Handles groups with parentheses.
      - example: `"(CH3)2(CH2)4"` returns `{"C":6.0, "H":14.0}`
  * **New in 2024:** Chemparse now handles nested paretheses!
      - example: `"((CH3)2)3"` returns `{'C': 6, 'H': 18}`
  * **New in 2024:** Chemparse now handles square brackets
      - example: `"K4[Fe(SCN)6]"` returns `{'Fe': 1.0, 'K': 4.0, 'N': 6.0, 'S': 6.0, 'C': 6.0}`



  Install `chemparse` with pip:

  ```
  $ pip install chemparse
  ```



  Import chemparse in python and use the parse_formula function:

  ```
  import chemparse

  print(chemparse.parse_formula("C6H12O6"))
  ```



  Install python

  Clone `chemparse` using git: \
  `git clone https://github.com/gmboyer/chemparse.git`

  Go to the `chemparse` directory: \
  `cd chemparse`

  Install requirements: \
  `pip install -r requirements.txt`

  Now you are ready to contribute!


pkgId: 3ba2f93eedb23347308afc1044f37b5b2f5cad2b7c8c9f503e6eb1413c151336
name: python-chemplot
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: A python library for chemical space visualization.
url: https://github.com/mcsorkun/ChemPlot
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemplot-1.2.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width="600" src="https://raw.githubusercontent.com/mcsorkun/ChemPlot/main/docs/logo_chemplot.png">
  </p>
  <br />

  [![PyPI version](https://badge.fury.io/py/chemplot.svg)](https://badge.fury.io/py/chemplot)  [![Downloads](https://pepy.tech/badge/chemplot/month)](https://pepy.tech/project/chemplot)

  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/chemplot/badges/version.svg)](https://anaconda.org/conda-forge/chemplot) [![Anaconda-Server Badge](https://anaconda.org/conda-forge/chemplot/badges/downloads.svg)](https://anaconda.org/conda-forge/chemplot)

  [![PyPI - License](https://img.shields.io/pypi/l/chemplot?color=yellow)](https://github.com/mcsorkun/ChemPlot/blob/main/LICENSE) [![Documentation Status](https://readthedocs.org/projects/chemplot/badge/?version=latest)](https://chemplot.readthedocs.io/en/latest/?badge=latest)

  [![Tests](https://github.com/mcsorkun/ChemPlot/actions/workflows/tests.yml/badge.svg)](https://github.com/mcsorkun/ChemPlot/actions/workflows/tests.yml)
  [![Coverage Status](https://coveralls.io/repos/github/mcsorkun/ChemPlot/badge.svg)](https://coveralls.io/github/mcsorkun/ChemPlot)



  Chemplot is a python library for chemical space visualization that allows users to plot the chemical space of their molecular datasets. Chemplot contains both structural and tailored similarity algorithms to plot similar molecules together based on the needs of users. Moreover, it is easy to use even for non-experts.





  You can find the detailed features and examples in the following link: [User Manual](https://chemplot.readthedocs.io/en/latest/).



  ChemPlot is also available as a web application. You can use it at the following link: [Web Application](https://share.streamlit.io/mcsorkun/chemplot-web/main/web_app_chemplot.py).



  You can find the details for the background on ChemPlot in our paper. You can download our paper at: [Paper](https://chemistry-europe.onlinelibrary.wiley.com/doi/full/10.1002/cmtd.202200005).



  There are two different options to install ChemPlot:



  To install ChemPlot using conda, run the following from the command line:

      conda install -c conda-forge chemplot



  ChemPlot requires RDKit, which cannot be installed using pip. The
  official RDKit installation documentation can be found
  [here](http://www.rdkit.org/docs/Install.html).

  After having installed RDKit, ChemPlot can be installed using pip by
  running:

      pip install chemplot



  ChemPlot is a cheminformatics tool whose purpose is to visualize subsets
  of the chemical space in two dimensions. It uses the [RDKit chemistry
  framework](http://www.rdkit.org), the
  [scikit-learn](http://scikit-learn.org/stable/index.html) API and the
  [umap-learn](https://github.com/lmcinnes/umap) API.



  To demonstrate how to use the functions the library offers we use
  [BBBP](https://github.com/mcsorkun/ChemPlot/blob/main/tests/test_data/C_2039_BBBP_2.csv) (blood-brain barrier penetration) [1] molecular dataset. BBBP is a
  set of molecules encoded as SMILES, which have been assigned a binary
  label according to their permeability properties. This dataset can be retrieved
  from the library as a [pandas](https://pandas.pydata.org/pandas-docs/stable/index.html)
  DataFrame object.

  ``` {.sourceCode .python3}
  import chemplot as cp
  data_BBBP = cp.load_data("BBBP")
  ```

  To visualize the molecules in 2D according to their similarity it is
  first needed to construct a `Plotter` object. This is the class
  containing all the functions ChemPlot uses to produce the desired
  visualizations. A `Plotter` object can be constructed using
  classmethods, which differentiate between the type of input that is feed
  to the object. In our example we need to use the method from\_smiles. We
  pass three parameters: the list of SMILES from the BBBP dataset, their
  target values (the binary labels) and the target type (in this case “C”,
  which stands for “Classification”).

  ``` {.sourceCode .python3}
  plotter = cp.Plotter.from_smiles(data_BBBP["smiles"], target=data_BBBP["target"], target_type="C")
  ```



  When the `Plotter` object was constructed descriptors for each SMILES
  were calculated, using the library
  [mordred](http://mordred-descriptor.github.io/documentation/v0.1.0/introduction.html),
  and then selected based on the target values. We reduce the number of
  dimensions for each molecule from the number of descriptors selected to only 2.
  ChemPlot uses three different algorithms in order to achieve this.
  In this example we will first use t-SNE [2].

  ``` {.sourceCode .python3}
  plotter.tsne()
  ```

  The output will be a dataframe containg the reduced dimensions and the target values.

  | t-SNE-1          | t-SNE-2          | target           |
  |------------------|------------------|------------------|
  | -41.056122       | 0.355575         | 1                |
  | -35.535915       | 21.648867        | 1                |
  | 23.771597        | -14.438373       | 1                |

  To now visualize the chemical space of the dataset we use `visualize_plot()`.

  ``` {.sourceCode .python3}
  plotter.visualize_plot()
  ```

  ![image](https://raw.githubusercontent.com/mcsorkun/ChemPlot/main/docs/user_manual/images/gs_tsne.png)

  The second figure shows the results obtained by reducing the dimensions
  of features Principal Component Analysis (PCA) [3].

  ``` {.sourceCode .python3}
  plotter.pca()
  plotter.visualize_plot()
  ```

  ![image](https://raw.githubusercontent.com/mcsorkun/ChemPlot/main/docs/user_manual/images/gs_pca.png)

  The third figure shows the results obtained by reducing the dimensions
  of features by UMAP [4].

  ``` {.sourceCode .python3}
  plotter.umap()
  plotter.visualize_plot()
  ```

  ![image](https://raw.githubusercontent.com/mcsorkun/ChemPlot/main/docs/user_manual/images/gs_umap.png)

  In each figure the molecules are coloured by class value.

  * * * * *

  <h3>
  References:

  </h3>

  [1]: **Martins, Ines Filipa, et al.** (2012). [A Bayesian approach to
      in silico blood-brain barrier penetration
      modeling.](https://pubmed.ncbi.nlm.nih.gov/22612593/) Journal of
      chemical information and modeling 52.6, 1686-1697

  [2]: **van der Maaten, Laurens, Hinton, Geoffrey.** (2008).
      [Viualizingdata using
      t-SNE.](https://www.jmlr.org/papers/volume9/vandermaaten08a/vandermaaten08a.pdf?fbclid=IwAR0Bgg1eA5TFmqOZeCQXsIoL6PKrVXUFaskUKtg6yBhVXAFFvZA6yQiYx-M)
      Journal of Machine Learning Research. 9. 2579-2605.

  [3]: **Wold, S., Esbensen, K., Geladi, P.** (1987). [Principal
      component
      analysis.](https://www.sciencedirect.com/science/article/abs/pii/0169743987800849)
      Chemometrics and intelligent laboratory systems. 2(1-3). 37-52.

  [4]: **McInnes, L., Healy, J., Melville, J.** (2018). [Umap: Uniform
      manifold approximation and projection for dimension
      reduction.](https://arxiv.org/abs/1802.03426) arXivpreprint
      arXiv:1802.03426.



  For any question you can contact us through email:

  - [Murat Cihan Sorkun](mailto:mcsorkun@gmail.com)
  - [Dajt Mullaj](mailto:dajt.mullai@gmail.com)


pkgId: 87ebe0d407474bef2ef0771f581a61fd47c2da5ae1f0efaea00265d78b152b09
name: python-chemprop
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Molecular Property Prediction with Message Passing Neural Networks
url: https://pypi.org/project/chemprop/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemprop-2.1.0-1.src.rpm
checksum_type: sha256
description:
  ![ChemProp Logo](docs/source/_static/images/logo/chemprop_logo.svg)


  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chemprop)](https://badge.fury.io/py/chemprop)
  [![PyPI version](https://badge.fury.io/py/chemprop.svg)](https://badge.fury.io/py/chemprop)
  [![Anaconda-Server Badge](https://anaconda.org/conda-forge/chemprop/badges/version.svg)](https://anaconda.org/conda-forge/chemprop)
  [![Build Status](https://github.com/chemprop/chemprop/workflows/tests/badge.svg)](https://github.com/chemprop/chemprop/actions/workflows/tests.yml)
  [![Documentation Status](https://readthedocs.org/projects/chemprop/badge/?version=main)](https://chemprop.readthedocs.io/en/main/?badge=main)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Downloads](https://static.pepy.tech/badge/chemprop)](https://pepy.tech/project/chemprop)
  [![Downloads](https://static.pepy.tech/badge/chemprop/month)](https://pepy.tech/project/chemprop)
  [![Downloads](https://static.pepy.tech/badge/chemprop/week)](https://pepy.tech/project/chemprop)

  Chemprop is a repository containing message passing neural networks for molecular property prediction.

  Documentation can be found [here](https://chemprop.readthedocs.io/en/main/).

  There are tutorial notebooks in the [`examples/`](https://github.com/chemprop/chemprop/tree/main/examples) directory.

  Chemprop recently underwent a ground-up rewrite and new major release (v2.0.0). A helpful transition guide from Chemprop v1 to v2 can be found [here](https://docs.google.com/spreadsheets/u/3/d/e/2PACX-1vRshySIknVBBsTs5P18jL4WeqisxDAnDE5VRnzxqYEhYrMe4GLS17w5KeKPw9sged6TmmPZ4eEZSTIy/pubhtml). This includes a side-by-side comparison of CLI argument options, a list of which arguments will be implemented in later versions of v2, and a list of changes to default hyperparameters.

  **License:** Chemprop is free to use under the [MIT License](LICENSE.txt). The Chemprop logo is free to use under [CC0 1.0](docs/source/_static/images/logo/LICENSE.txt).

  **References**: Please cite the appropriate papers if Chemprop is helpful to your research.

  - Chemprop was initially described in the papers [Analyzing Learned Molecular Representations for Property Prediction](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.9b00237) for molecules and [Machine Learning of Reaction Properties via Learned Representations of the Condensed Graph of Reaction](https://doi.org/10.1021/acs.jcim.1c00975) for reactions.
  - The interpretation functionality (available in v1, but not yet implemented in v2) is based on the paper [Multi-Objective Molecule Generation using Interpretable Substructures](https://arxiv.org/abs/2002.03244).
  - Chemprop now has its own dedicated manuscript that describes and benchmarks it in more detail: [Chemprop: A Machine Learning Package for Chemical Property Prediction](https://doi.org/10.1021/acs.jcim.3c01250).
  - A paper describing and benchmarking the changes in v2.0.0 is forthcoming.

  **Selected Applications**: Chemprop has been successfully used in the following works.

  - [A Deep Learning Approach to Antibiotic Discovery](https://www.cell.com/cell/fulltext/S0092-8674(20)30102-1) - _Cell_ (2020): Chemprop was used to predict antibiotic activity against _E. coli_, leading to the discovery of [Halicin](https://en.wikipedia.org/wiki/Halicin), a novel antibiotic candidate. Model checkpoints are availabile on [Zenodo](https://doi.org/10.5281/zenodo.6527882).
  - [Discovery of a structural class of antibiotics with explainable deep learning](https://www.nature.com/articles/s41586-023-06887-8) - _Nature_ (2023): Identified a structural class of antibiotics selective against methicillin-resistant _S. aureus_ (MRSA) and vancomycin-resistant enterococci using ensembles of Chemprop models, and explained results using Chemprop's interpret method.
  - [ADMET-AI: A machine learning ADMET platform for evaluation of large-scale chemical libraries](https://academic.oup.com/bioinformatics/advance-article/doi/10.1093/bioinformatics/btae416/7698030?utm_source=authortollfreelink&utm_campaign=bioinformatics&utm_medium=email&guestAccessKey=f4fca1d2-49ec-4b10-b476-5aea3bf37045): Chemprop was trained on 41 absorption, distribution, metabolism, excretion, and toxicity (ADMET) datasets from the [Therapeutics Data Commons](https://tdcommons.ai). The Chemprop models in ADMET-AI are available both as a web server at [admet.ai.greenstonebio.com](https://admet.ai.greenstonebio.com) and as a Python package at [github.com/swansonk14/admet_ai](https://github.com/swansonk14/admet_ai).
  - A more extensive list of successful Chemprop applications is given in our [2023 paper](https://doi.org/10.1021/acs.jcim.3c01250)



  For users who have not yet made the switch to Chemprop v2.0, please reference the following resources.



  - Documentation of Chemprop v1 is available [here](https://chemprop.readthedocs.io/en/v1.7.1/). Note that the content of this site is several versions behind the final v1 release (v1.7.1) and does not cover the full scope of features available in chemprop v1.
  - The v1 [README](https://github.com/chemprop/chemprop/blob/v1.7.1/README.md) is the best source for documentation on more recently-added features.
  - Please also see descriptions of all the possible command line arguments in the v1 [`args.py`](https://github.com/chemprop/chemprop/blob/v1.7.1/chemprop/args.py) file.



  - [Benchmark scripts](https://github.com/chemprop/chemprop_benchmark) - scripts from our 2023 paper, providing examples of many features using Chemprop v1.6.1
  - [ACS Fall 2023 Workshop](https://github.com/chemprop/chemprop-workshop-acs-fall2023) - presentation, interactive demo, exercises on Google Colab with solution key
  - [Google Colab notebook](https://colab.research.google.com/github/chemprop/chemprop/blob/v1.7.1/colab_demo.ipynb) - several examples, intended to be run in Google Colab rather than as a Jupyter notebook on your local machine
  - [nanoHUB tool](https://nanohub.org/resources/chempropdemo/) - a notebook of examples similar to the Colab notebook above, doesn't require any installation
    - [YouTube video](https://www.youtube.com/watch?v=TeOl5E8Wo2M) - lecture accompanying nanoHUB tool
  - These [slides](https://docs.google.com/presentation/d/14pbd9LTXzfPSJHyXYkfLxnK8Q80LhVnjImg8a3WqCRM/edit?usp=sharing) provide a Chemprop tutorial and highlight additions as of April 28th, 2020



  We have discontinued support for v1 since v2 has been released, but we still appreciate v1 bug reports and will tag them as [`v1-wontfix`](https://github.com/chemprop/chemprop/issues?q=label%3Av1-wontfix+) so the community can find them easily.


pkgId: 49208efa63b04934ef83a4c761c02d5bd8ec3d33ac44a1acdb28a27b434db11c
name: python-chemtsv2
arch: src
version: 1.0.7
epoch: 0
release: 1
url: https://github.com/molecule-generator-collection/ChemTSv2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chemtsv2-1.0.7-1.src.rpm
checksum_type: sha256
summary:
  ChemTSv2 is a flexible and versatile molecule generator based on reinforcement learning with natural language processing.

description:
  <div align="center">
    <img src="https://github.com/molecule-generator-collection/ChemTSv2/blob/master/img/logo.png" width="95%">
  </div>

  ChemTSv2[^13] is a refined and extended version of ChemTS[^1] and MPChemTS[^2].
  The original implementations are available at https://github.com/tsudalab/ChemTS and https://github.com/yoshizoe/mp-chemts, respectively.

  ChemTSv2 provides:

  - easy-to-run interface by using only a configuration file
  - easy-to-define framework for users' any reward function, molecular filter, and tree policy
  - various usage examples in the GitHub repository

  [^13]: Ishida, S. and Aasawat, T. and Sumita, M. and Katouda, M. and Yoshizawa, T. and Yoshizoe, K. and Tsuda, K. and Terayama, K. (2023). ChemTSv2: Functional molecular design using de novo molecule generator. <i>WIREs Computational Molecular Science</i> https://wires.onlinelibrary.wiley.com/doi/10.1002/wcms.1680

  [^1]: Yang, X., Zhang, J., Yoshizoe, K., Terayama, K., & Tsuda, K. (2017). ChemTS: an efficient python library for de novo molecular generation. <i>Science and Technology of Advanced Materials</i>, 18(1), 972–976. https://doi.org/10.1080/14686996.2017.1401424

  [^2]: Yang, X., Aasawat, T., & Yoshizoe, K. (2021). Practical Massively Parallel Monte-Carlo Tree Search Applied to Molecular Design. <i>In International Conference on Learning Representations</i>. https://openreview.net/forum?id=6k7VdojAIK





  >[!NOTE]
  >ARM architecture, e.g., Apple Silicon, is not currently supported

  <details>
    <summary>Click to show/hide requirements</summary>

  1. python: 3.11
  2. rdkit: 2023.9.1
  3. tensorflow: 2.14.1
  4. pyyaml
  5. pandas: 2.1.3
  6. joblib
  7. mpi4py: 3.1.5 (for massive parallel mode)

  </details>



  <details>
    <summary>Click to show/hide the instruction</summary>

  ```bash
  cd YOUR_WORKSPACE
  python3.11 -m venv .venv
  source .venv/bin/activate
  pip install --upgrade chemtsv2
  ```

  </details>



  <details>
    <summary>Click to show/hide the instruction</summary>
  NOTE: You need to run ChemTSv2-MP on a server where OpenMPI or MPICH is installed.
  If you can't find `mpiexec` command, please consult your server administrator to install such an MPI library.

  If you can use/prepare a server with MPI environment, please follow the (a) instruction; otherwise, please follow the (b) instruction.



  ```bash
  cd YOUR_WORKSPACE
  python3.11 -m venv .venv
  source .venv/bin/activate
  pip install --upgrade chemtsv2[mp]
  ```



  ```bash
  conda create -n mpchem python=3.11 -c conda-forge

  conda install -c conda-forge openmpi cxx-compiler mpi mpi4py=3.1.5
  pip install --upgrade chemtsv2
  ```

  </details>





  ```bash
  git clone git@github.com:molecule-generator-collection/ChemTSv2.git
  cd ChemTSv2
  ```



  Please refer to `reward/README.md`.
  An example of reward definition for LogP maximization task is as follows.

  ```python
  from rdkit.Chem import Descriptors
  import numpy as np
  from chemtsv2.reward import Reward

  class LogP_reward(Reward):
      def get_objective_functions(conf):
          def LogP(mol):
              return Descriptors.MolLogP(mol)
          return [LogP]

      def calc_reward_from_objective_values(objective_values, conf):
          logp = objective_values[0]
          return np.tanh(logp/10)
  ```



  The explanation of options are described in the [Support option/function](#support-optionfunction-pushpin) section.
  The prepared reward file needs to be specified in `reward_setting`.
  For details, please refer to a sample file ([config/setting.yaml](config/setting.yaml)).
  If you want to pass any value to `calc_reward_from_objective_values` (e.g., weights for each value), add it in the config file.





  ```bash
  chemtsv2 -c config/setting.yaml
  ```



  ```bash
  mpiexec -n 4 chemtsv2-mp --config config/setting_mp.yaml
  ```



  ```bash
  docker build -t chemtsv2:1.0.0 .
  docker run -u $(id -u):$(id -g) \
             --rm \
             --mount type=bind,source=./,target=/app/ \
             chemtsv2:1.0.0 \
             chemtsv2 -c config/setting.yaml
  ```



  |Target|Reward|Config|Additional requirement|Ref.|
  |---|---|---|---|---|
  |LogP|[logP_reward.py](reward/logP_reward.py)|[setting.yaml](config/setting.yaml)|-|-|
  |Jscore|[Jscore_reward.py](reward/Jscore_reward.py)|[setting_jscore.yaml](config/setting_jscore.yaml)|-|[^1]|
  |Absorption wavelength|[chro_reward.py](reward/chro_reward.py)|[setting_chro.yaml](config/setting_chro.yaml)|Gaussian 16[^3]<br> via QCforever[^10]|[^4]|
  |Absorption wavelength|[chro_gamess_reward.py](reward/chro_gamess_reward.py)|[setting_chro_gamess.yaml](config/setting_chro_gamess.yaml)|GAMESS 2022.2[^12] via QCforever[^10]||
  |Upper-absorption & fluorescence<br> wavelength|[fluor_reward.py](reward/fluor_reward.py)|[setting_fluor.yaml](config/setting_fluor.yaml)|Gaussian 16[^3]<br> via QCforever[^10]|[^5]|
  |Kinase inhibitory activities|[dscore_reward.py](reward/dscore_reward.py)|[setting_dscore.yaml](config/setting_dscore.yaml)|LightGBM[^6]|[^7]|
  |Docking score|[Vina_binary_reward.py](reward/Vina_binary_reward.py)|[setting_vina_binary.yaml](config/setting_vina_binary.yaml)|AutoDock Vina[^8]|[^9]|
  |Pharmacophore|[pharmacophore_reward.py](reward/pharmacophore_reward.py)|[setting_pharmacophore.yaml](config/setting_pharmacophore.yaml)|-|[^11]|
  |gnina docking|[gnina_singularity_reward.py](reward/gnina_singularity_reward.py)|[setting_gnina_singularity.yaml](config/setting_gnina_singularity.yaml)|-|-|
  |Linker generation|[Linker_logP_reward.py](reward/Linker_logP_reward.py)|[setting_linker.yaml](config/setting_linker.yaml)|-|-|

  [^3]: Frisch, M. J. et al. Gaussian 16 Revision C.01. 2016; Gaussian Inc. Wallingford CT.
  [^4]: Sumita, M., Yang, X., Ishihara, S., Tamura, R., & Tsuda, K. (2018). Hunting for Organic Molecules with Artificial Intelligence: Molecules Optimized for Desired Excitation Energies. <i>ACS Central Science</i>, 4(9), 1126–1133. https://doi.org/10.1021/acscentsci.8b00213
  [^5]: Sumita, M., Terayama, K., Suzuki, N., Ishihara, S., Tamura, R., Chahal, M. K., Payne, D. T., Yoshizoe, K., & Tsuda, K. (2022). De novo creation of a naked eye–detectable fluorescent molecule based on quantum chemical computation and machine learning. <i>Science Advances</i>, 8(10). https://doi.org/10.1126/sciadv.abj3906
  [^6]: Ke, G., Meng, Q., Finley, T., Wang, T., Chen, W., Ma, W., … Liu, T.-Y. (2017). Lightgbm: A highly efficient gradient boosting decision tree. <i>Advances in Neural Information Processing Systems</i>, 30, 3146–3154.
  [^7]: Yoshizawa, T., Ishida, S., Sato, T., Ohta, M., Honma, T., & Terayama, K. (2022). Selective Inhibitor Design for Kinase Homologs Using Multiobjective Monte Carlo Tree Search. <i>Journal of Chemical Information and Modeling</i>, 62(22), 5351–5360. https://doi.org/10.1021/acs.jcim.2c00787
  [^8]: Eberhardt, J., Santos-Martins, D., Tillack, A. F., & Forli, S. (2021). AutoDock Vina 1.2.0: New Docking Methods, Expanded Force Field, and Python Bindings. <i>Journal of Chemical Information and Modeling</i>, 61(8), 3891–3898. https://doi.org/10.1021/acs.jcim.1c00203
  [^9]: Ma, B., Terayama, K., Matsumoto, S., Isaka, Y., Sasakura, Y., Iwata, H., Araki, M., & Okuno, Y. (2021). Structure-Based de Novo Molecular Generator Combined with Artificial Intelligence and Docking Simulations. <i>Journal of Chemical Information and Modeling</i>, 61(7), 3304–3313. https://doi.org/10.1021/acs.jcim.1c00679
  [^10]: Sumita, M., Terayama, K., Tamura, R., & Tsuda, K. (2022). QCforever: A Quantum Chemistry Wrapper for Everyone to Use in Black-Box Optimization. <i>Journal of Chemical Information and Modeling</i>, 62(18), 4427–4434. https://doi.org/10.1021/acs.jcim.2c00812
  [^11]: 石田祥一, 吉澤竜哉, 寺山慧 (2023). 深層学習と木探索に基づくde novo分子設計, <i>SAR News</i>, 44.
  [^12]: Barca, Giuseppe M. J. et al. (2020). Recent developments in the general atomic and molecular electronic structure system. <i>The Journal of Chemical Physics</i>, 152(15), 154102. https://doi.org/10.1063/5.0005188



  |Option|Single process|Massive parallel|Description|
  |---|---|---|---|
  |`c_val`|:white_check_mark:|:white_check_mark:|Exploration parameter to balance the trade-off between exploration and exploitation. A larger value (e.g., 1.0) prioritizes exploration, and a smaller value (e.g., 0.1) prioritizes exploitation.|
  |`threshold_type`|:white_check_mark:|:heavy_check_mark:|Threshold type to select how long (`hours`) or how many (`generation_num`) molecule generation to perform. Massive parallel mode currently supports only the how long (`hours`) option.|
  |`hours`|:white_check_mark:|:white_check_mark:|Time for molecule generation in hours|
  |`generation_num`|:white_check_mark:|:white_large_square:|Number of molecules to be generated. Please note that the specified number is usually exceeded.|
  |`expansion_threshold`|:white_check_mark:|:white_large_square:|(Advanced) Expansion threshold of the cumulative probability. The default is set to 0.995.|
  |`simulation_num`|:white_check_mark:|:white_large_square:|(Advanced) Number of rollout runs in one cycle of MCTS. The default is set to 3.|
  |`flush_threshold`|:white_check_mark:|:white_large_square:|Threshold for saving the progress of a molecule generation. If the number of generated molecules exceeds the threshold value, the result is saved. The default is set to -1, and this represents no progress is to be saved.|
  |Molecule filter|:white_check_mark:|:white_check_mark:|Molecule filter to skip reward calculation of unfavorable generated molecules. Please refer to filter/README.md for details.|
  |RNN model replacement|:white_check_mark:|:white_check_mark:|Users can switch RNN models used in expansion and rollout steps of ChemTSv2. The model needs to be trained using Tensorflow. `model_json` specifies the JSON file that contains the architecture of the RNN model, and `model_weight` specifies the file in H5 format that contains a set of the values of the weights. `token` specifies the pickle file that contains the token list used when training an RNN model.|
  |Reward replacement|:white_check_mark:|:white_check_mark:|Users can use any reward function as long as they follow the reward base class ([reward/reward.py](reward/reward.py)). Please refer to reward/README.md for details.|
  |Policy replacement|:white_check_mark:|:white_large_square:|(Advanced) Users can use any policy function as long as they follow the policy base class ([policy/policy.py](policy/policy.py)). Please refer to policy/README.md for details.|
  |Restart|:beginner:|:beginner:|Users can save the checkpoint file and restart from the file. If users want to save a checkpoint file, <b>(SP mode)</b> set `save_checkpoint` to True and specify the file name in `checkpoint_file`. If users want to restart from the checkpoint, set `restart` to True and specify the checkpoint file in `checkpoint_file`. <b>(MP mode)</b> under development.|

  - :white_check_mark: indicates that the option/function is supported.
  - :heavy_check_mark: indicates that the option/function is partially supported.
  - :beginner: indicates that the option/function is beta version.
  - :white_large_square: indicates that the option/function is NOT supported.

  Filter functions are described in [filter/README.md](./filter).





  You can extend the SMILES string you input.
  In this case, you need to put the atom you want to extend at the end of the string and run ChemTS with `--input_smiles` argument as follows.

  ```bash
  chemtsv2 -c config/setting.yaml --input_smiles 'C1=C(C)N=CC(N)=C1C'
  ```



  [OpenBabel](https://github.com/openbabel/openbabel) can be used to rearrange a SMILES string so that the specified atom comes last.
  For example, if you want to rearrange `Br` in `NC1=CC(Br)=CC=C1` to the last position, run the following command:

  ```bash



  obabel -:"NC1=CC(Br)=CC=C1" -osmi -xl 5

  ```

  Please refer to the [official documentation](https://openbabel.org/docs/current/FileFormats/SMILES_format.html) for detailed usage.



  If you want to use the RNN models trained on your own datasets, use [train_model/train_RNN.py](train_model/train_RNN.py) and [train_model/model_setting.yaml](train_model/model_setting.yaml) to train the models.
  You need to prepare a dataset that only contains SMILES string and modify the path in `dataset` key in `model_setting.yaml`. And then, run the following command:

  ```bash
  cd train_model/
  python train_RNN.py -c model_setting.yaml
  ```

  Please note that the current version of ChemTSv2 does not support the change for RNN model structures, and users can only change the parameters described in `model_setting.yaml`.

  Once you train the RNN model, specify the path to the checkpoint and token files in `model_setting` and `token` keys in ChemTSv2 config files to run ChemTSv2 with your own RNN model.



  If you want to use GPU, run ChemTS with `--gpu GPU_ID` argument as follows.

  ```bash
  chemtsv2 -c config/setting.yaml --gpu 0
  ```

  If you want to use GPU only for reward calculations, run ChemTSv2 with `--gpu` and `--use_gpu_only_reward` arguments as follows.

  ```bash
  chemtsv2 -c config/setting_gnina_singularity.yaml --gpu 0 --use_gpu_only_reward
  ```



  ```text
  @article{Ishida2023,
    doi = {10.1002/wcms.1680},
    url = {https://doi.org/10.1002/wcms.1680},
    year = {2023},
    month = jul,
    publisher = {Wiley},
    author = {Shoichi Ishida and Tanuj Aasawat and Masato Sumita and Michio Katouda and Tatsuya Yoshizawa and Kazuki Yoshizoe and Koji Tsuda and Kei Terayama},
    title = {ChemTSv2: Functional molecular design using de novo molecule generator},
    journal = {{WIREs} Computational Molecular Science}
  }
  ```



  This package is distributed under the MIT License.



  - Shoichi Ishida (ishida.sho.nm@yokohama-cu.ac.jp)
  - Kei Terayama (terayama@yokohama-cu.ac.jp).


pkgId: df775dfd9a24cf85ec01e4853bd914efa242a2acfd99829c3bad9aea31af0ebe
name: python-chencrafts
arch: src
version: 2.5
epoch: 0
release: 1
summary: A personal toolbox for superconducting qubits and quantum mechanics.
url: https://github.com/Harrinive/chencrafts
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chencrafts-2.5-1.src.rpm
checksum_type: sha256
description:
  There are four main parts in this package: `Toolbox`, `cqed`, `bsqubits`, and `projects`. They serves for different purposes in Danyang's research.

  - `Toolbox` (or `tb`): Toolbox includes functions for optimization, saving and loading data, etc. It is a general toolbox for all the projects.
  - `cqed`: General codes for simulating the cqed systems. It includes simulations for pulse, decoherence, critical photon number, etc. I also define the FlexibleSweep class, inherited from the scqubits.ParameterSweep class, which helps to define swept parameters flexibly. Specifically, it has module `custom_sweeps` for a bunch of pre-defined custom sweeps, which can be used in `scqubits.ParameterSweep` class.
  - `bsqubits` (or `bsq`): A package for simulating and studying some spacific systems, especially for the resonator-qubit systems. The code isn't general enough to be used for other systems. Very high level and practical. Specifically, it has module `QEC_graph` for simulating the cat code using a graph representation.
  - `projects` (or `prj`): A collection for all other projects, including files collected from other collaborators.
  - `fluxonium` (or `fx`): Like `bsqubits`, it's also a code collection for a specific project. It has codes to calculate gate fidelity for FRF system and perform the corresponding analysis.

  ```bash
  pip install chencrafts
  ```

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


pkgId: aa446d73ac3054abe380a0a5a0adddd5d99fac75ef554538d55513216ced7102
name: python-cherab-inversion
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Cherab inversion framework
url: https://cherab-inversion.readthedocs.io/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherab-inversion-0.3.1-1.src.rpm
checksum_type: sha256
description:
  You can quickly try the inversion technique with `Pixi` tool:
  ```bash
  git clone https://github.com/munechika-koyo/cherab_inversion
  cd cherab_inversion
  pixi run lab
  ```
  Then, JupyterLab will be launched and you can try the inversion technique with the example notebook.
  ![JupyterLab window](/docs/source/_static/images/quickstart_jupyterlab.webp)

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


pkgId: 393a2ef4803e47e8ca9a3a7934135b4cbb183d192f9a50dfa489fb7dee3d03ae
name: python-cherche
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: Neural Search
url: https://github.com/raphaelsty/cherche
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherche-2.2.1-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1>Cherche</h1>
    <p>Neural search</p>
  </div>

  <p align="center"><img width=300 src="docs/img/logo.png"/></p>

  <div align="center">
    <!-- Documentation -->
    <a href="https://raphaelsty.github.io/cherche/"><img src="https://img.shields.io/website?label=docs&style=flat-square&url=https%3A%2F%2Fraphaelsty.github.io/cherche/%2F" alt="documentation"></a>
    <!-- Demo -->
    <a href="https://raphaelsty.github.io/knowledge/?query=cherche%20neural%20search"><img src="https://img.shields.io/badge/demo-running-blueviolet?style=flat-square" alt="Demo"></a>
    <!-- License -->
    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square" alt="license"></a>
  </div>


  Cherche enables the development of a neural search pipeline that employs retrievers and pre-trained language models both as retrievers and rankers. The primary advantage of Cherche lies in its capacity to construct end-to-end pipelines. Additionally, Cherche is well-suited for offline semantic search due to its compatibility with batch computation.

  Here are some of the features Cherche offers:

  [Live demo of a NLP search engine powered by Cherche](https://raphaelsty.github.io/knowledge/?query=cherche%20neural%20search)

  ![Alt text](docs/img/explain.png)



  To install Cherche for use with a simple retriever on CPU, such as TfIdf, Flash, Lunr, Fuzz, use the following command:

  ```sh
  pip install cherche
  ```

  To install Cherche for use with any semantic retriever or ranker on CPU, use the following command:

  ```sh
  pip install "cherche[cpu]"
  ```

  Finally, if you plan to use any semantic retriever or ranker on GPU, use the following command:

  ```sh
  pip install "cherche[gpu]"
  ```

  By following these installation instructions, you will be able to use Cherche with the appropriate requirements for your needs.



  Documentation is available [here](https://raphaelsty.github.io/cherche/). It provides details
  about retrievers, rankers, pipelines and examples.





  Cherche allows findings the right document within a list of objects. Here is an example of a corpus.

  ```python
  from cherche import data

  documents = data.load_towns()

  documents[:3]
  [{'id': 0,
    'title': 'Paris',
    'url': 'https://en.wikipedia.org/wiki/Paris',
    'article': 'Paris is the capital and most populous city of France.'},
   {'id': 1,
    'title': 'Paris',
    'url': 'https://en.wikipedia.org/wiki/Paris',
    'article': "Since the 17th century, Paris has been one of Europe's major centres of science, and arts."},
   {'id': 2,
    'title': 'Paris',
    'url': 'https://en.wikipedia.org/wiki/Paris',
    'article': 'The City of Paris is the centre and seat of government of the region and province of Île-de-France.'
    }]
  ```



  Here is an example of a neural search pipeline composed of a TF-IDF that quickly retrieves documents, followed by a ranking model. The ranking model sorts the documents produced by the retriever based on the semantic similarity between the query and the documents. We can call the pipeline using a list of queries and get relevant documents for each query.

  ```python
  from cherche import data, retrieve, rank
  from sentence_transformers import SentenceTransformer
  from lenlp import sparse


  documents = data.load_towns()


  retriever = retrieve.BM25(
    key="id",
    on=["title", "article"],
    documents=documents,
    k=30
  )


  ranker = rank.Encoder(
      key = "id",
      on = ["title", "article"],
      encoder = SentenceTransformer("sentence-transformers/all-mpnet-base-v2").encode,
      k = 3,
  )


  search = retriever + ranker

  search.add(documents=documents)


  search(["Bordeaux", "Paris", "Toulouse"])
  [[{'id': 57, 'similarity': 0.69513524},
    {'id': 63, 'similarity': 0.6214994},
    {'id': 65, 'similarity': 0.61809087}],
   [{'id': 16, 'similarity': 0.59158516},
    {'id': 0, 'similarity': 0.58217555},
    {'id': 1, 'similarity': 0.57944715}],
   [{'id': 26, 'similarity': 0.6925601},
    {'id': 37, 'similarity': 0.63977146},
    {'id': 28, 'similarity': 0.62772334}]]
  ```

  We can map the index to the documents to access their contents using pipelines:

  ```python
  search += documents
  search(["Bordeaux", "Paris", "Toulouse"])
  [[{'id': 57,
     'title': 'Bordeaux',
     'url': 'https://en.wikipedia.org/wiki/Bordeaux',
     'similarity': 0.69513524},
    {'id': 63,
     'title': 'Bordeaux',
     'similarity': 0.6214994},
    {'id': 65,
     'title': 'Bordeaux',
     'url': 'https://en.wikipedia.org/wiki/Bordeaux',
     'similarity': 0.61809087}],
   [{'id': 16,
     'title': 'Paris',
     'url': 'https://en.wikipedia.org/wiki/Paris',
     'article': 'Paris received 12.',
     'similarity': 0.59158516},
    {'id': 0,
     'title': 'Paris',
     'url': 'https://en.wikipedia.org/wiki/Paris',
     'similarity': 0.58217555},
    {'id': 1,
     'title': 'Paris',
     'url': 'https://en.wikipedia.org/wiki/Paris',
     'similarity': 0.57944715}],
   [{'id': 26,
     'title': 'Toulouse',
     'url': 'https://en.wikipedia.org/wiki/Toulouse',
     'similarity': 0.6925601},
    {'id': 37,
     'title': 'Toulouse',
     'url': 'https://en.wikipedia.org/wiki/Toulouse',
     'similarity': 0.63977146},
    {'id': 28,
     'title': 'Toulouse',
     'url': 'https://en.wikipedia.org/wiki/Toulouse',
     'similarity': 0.62772334}]]
  ```



  Cherche provides [retrievers](https://raphaelsty.github.io/cherche/retrieve/retrieve/) that filter input documents based on a query.

  - retrieve.TfIdf
  - retrieve.BM25
  - retrieve.Lunr
  - retrieve.Flash
  - retrieve.Encoder
  - retrieve.DPR
  - retrieve.Fuzz
  - retrieve.Embedding



  Cherche provides [rankers](https://raphaelsty.github.io/cherche/rank/rank/) that filter documents in output of retrievers.

  Cherche rankers are compatible with [SentenceTransformers](https://www.sbert.net/docs/pretrained_models.html) models which are available on [Hugging Face hub](https://huggingface.co/models?pipeline_tag=zero-shot-classification&sort=downloads).

  - rank.Encoder
  - rank.DPR
  - rank.CrossEncoder
  - rank.Embedding



  Cherche provides modules dedicated to question answering. These modules are compatible with Hugging Face's pre-trained models and fully integrated into neural search pipelines.


  Cherche was created for/by Renault and is now available to all.
  We welcome all contributions.

  <p align="center"><img src="docs/img/renault.jpg"/></p>



  Lunr retriever is a wrapper around [Lunr.py](https://github.com/yeraydiazdiaz/lunr.py). Flash retriever is a wrapper around [FlashText](https://github.com/vi3k6i5/flashtext). DPR, Encode and CrossEncoder rankers are wrappers dedicated to the use of the pre-trained models of [SentenceTransformers](https://www.sbert.net/docs/pretrained_models.html) in a neural search pipeline.



  If you use cherche to produce results for your scientific publication, please refer to our SIGIR paper:

  ```bibtex
  @inproceedings{Sourty2022sigir,
      author = {Raphael Sourty and Jose G. Moreno and Lynda Tamine and Francois-Paul Servant},
      title = {CHERCHE: A new tool to rapidly implement pipelines in information retrieval},
      booktitle = {Proceedings of SIGIR 2022},
      year = {2022}
  }
  ```



  The Cherche dev team is made up of [Raphaël Sourty](https://github.com/raphaelsty), [François-Paul Servant](https://github.com/fpservant), [Nicolas Bizzozzero](https://github.com/NicolasBizzozzero), [Jose G Moreno](https://scholar.google.com/citations?user=4BZFUw8AAAAJ&hl=fr). 🥳


pkgId: 002d4f2b5fb6347719ef5187856d698343b865e3d080f33b42c6beafad6c288a
name: python-cherpy
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: A rest api wrapper for the Cherwell Service management platform
url: https://pypi.org/project/cherpy/
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherpy-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Cherpy is an API wrapper library to provide an easy way use the Cherwell rest API. It can be used for new scripts or
  simply used via
  the command line.

  This provides convenience for the following

  * Create and update objects
  * Search for objects
  * Get schema information
  * Delete objects
  * Call a onestep



  To install Cherpy, use:

  ```bash
  pip install cherpy
  ```





  ```python

  from cherpy.auth import config_from_env
  from cherpy.main import search_object


  client = config_from_env("cherwell_dev")


  search_object(client, object_name="Incident", pageSize=10)


  search_object(client, object_name="Incident", fields=["IncidentID", "ownedbyteam"], search_string="desktop",
                pageSize=10)

  ```





  Cherpy is a command-line tool for interacting with the Cherwell API. Here's how to use each command:



  All commands support these common options:

  - `-e, --env`: Environment variable containing config path (default: "cherpy_config")
  - `--object-name`: Name of the Cherwell object





  Search for Cherwell objects.

  ```bash

  csm search --env cherwell_dev --object-name Incident FirstName LastName Status


  csm search --env cherwell_dev --object-name Incident -s "printer issue" -ps 100 -pg 1


  csm search --object-name Incident -o output.csv Status Description
  ```



  Create new Cherwell records.

  ```bash

  csm create --env cherwell_config --object-name Incident -input-path data.csv


  csm create --env cherwell_config --object-name Incident -ask-file


  csm create --env cherwell_config --object-name Incident Description="New Issue" Status="New"
  ```



  Update existing Cherwell records (requires RecId field in input data).

  ```bash

  csm update --object-name Incident --input-path updates.csv


  csm update --object-name Incident -a
  ```



  Delete Cherwell records in batches.

  ```bash

  csm delete --object-name Incident


  csm delete --object-name Incident --chunk-size 500
  ```



  Retrieve schema information for Cherwell objects.

  ```bash

  csm get-schema --object-name Incident


  csm get-schema --object-name Incident -o schema.txt
  ```





  Get information about a OneStep automation.

  ```bash

  csm get-onestep --object-name Incident -on "ProcessIncident" -sc "Global"
  ```



  Execute a OneStep automation.

  ```bash

  csm run-onestep --object-name Incident -on "ProcessIncident" -sc "Global"
  ```



  ```bash

  csm get-schema --object-name Incident -o incident_schema.txt


  csm search --object-name Incident -s "printer" Status Description Owner


  csm create --object-name Incident --input-path new_incidents.csv


  csm update --object-name Incident --input-path incident_updates.csv


  csm run-onestep --object-name Incident -on "ProcessIncident"
  ```

  Note: All commands will prompt for the environment variable and object name if not specified


pkgId: 680e00c06ae7ee36a3c794225cbfe447681a04d8059e37e2d813d6233f8e5a82
name: python-cherpy
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A rest api wrapper for the Cherwell Service management platform
url: https://pypi.org/project/cherpy/
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherpy-0.6.1-1.src.rpm
checksum_type: sha256
description:
  Cherpy is an API wrapper library to provide an easy way use the Cherwell rest API. It can be used for new scripts or
  simply used via the command line.

  You can do the following:

  * Create and update objects
  * Search for objects
  * Delete objects
  * Get schema information
  * Search for a onestep
  * Call a onestep



  To install Cherpy, use:

  ```bash
  pip install cherpy
  ```



  Before you can start interacting with cherwell you will need to setup a config file that contains the necessary info





  ```yaml
      "auth_mode": "LDAP",
      "client_id": "<client id>",
      "grant_type": "password",
      "host": "https://<url>/CherwellAPI",
      "password": "<password>",
      "user": "domain\<userid>"
  ```

  You can save the above file to a any location but a suggested location is %userprofile%/.cherpy/cherpy_config.yaml





  ```bash

  csm search --env cherwell_dev --object-name --output-path "c:\myexports\incidents.csv" Incident IncidentID Status Ownedbyteam


  csm search --env cherwell_dev --object-name Incident -s "printer issue" -page-size 100

  ```



  Create new Cherwell records.

  ```bash

  csm create --env cherwell_config --object-name Incident -input-path data.csv


  csm create --env cherwell_config --object-name Incident -ask-file


  csm create --env cherwell_config --object-name Incident Description="New Issue" Status="New"
  ```



  Update existing Cherwell records (requires RecId field in input data).

  ```bash

  csm update --env cherwell_config --object-name Incident -input-path update_incidents.csv


  csm update --env cherwell_config --object-name Incident -ask-file
  ```



  Delete Cherwell records in batches.

  ```bash

  csm delete --env cherwell_config --object-name Incident --input-path delete_incidents.csv


  csm delete --env cherwell_config --object-name Incident --input-path delete_incidents.csv --chunk-size 100
  ```



  Retrieve schema information for Cherwell objects.

  ```bash

  csm get-schema --object-name Incident


  csm get-schema --object-name Incident --output-path schema.txt
  ```





  Get information about a OneStep automation. More of a helper tool to confirm that you have the correct OneStep before
  running it.

  ```bash
  >>csm get-onestep --env cherpy_dev --object-name configserver -on "Retire Server"
    2024-11-26 12:37:13.939 | INFO     | cherpy.cli:get_onestep_cli:75 - Current Env: cherpy_dev
    2024-11-26 12:37:13.943 | INFO     | cherpy.cli:get_onestep_cli:76 - Searching for Retire Server in Global for Association: configserver
    2024-11-26 12:37:13.948 | INFO     | cherpy.runonestep:get_object_summary:38 - Getting object summary for configserver
    2024-11-26 12:37:14.840 | INFO     | cherpy.runonestep:_recurse_onestep:29 - Found it!
    2024-11-26 12:37:14.844 | INFO     | cherpy.runonestep:get_onestep:76 - Found this onestep Retire Server
    2024-11-26 12:37:14.849 | INFO     | cherpy.runonestep:get_onestep:77 - {'association': '93dada9f640056ce1dc67b4d4bb801f69104894dc8',
     'description': '',
     'displayName': 'Retire Server',
     'galleryImage': '',
     'id': '94b43f85e5ce44034265864b12b22aecd83ebe0f10',
     'links': [],
     'localizedScopeName': 'Global',
     'name': 'Call Delete Duplicate Servers',
     'parentFolder': '',
     'parentIsScopeFolder': True,
     'scope': 'Global',
     'scopeOwner': '(None)',
     'standInKey': 'DefType:OneStepDef#Scope:Global#Id:94b43f85e5ce44034265864b12b22aecd83ebe0f10#Owner:93dada9f640056ce1dc67b4d4bb801f69104894dc8'}
  ```



  Execute a OneStep.

  ```bash



  csm run-onestep --object-name Incident --onestep-name "Create Incident" --scope "Global"
  ```





  ```python

  from cherpy.auth import config_from_env
  from cherpy.main import search_object


  client = config_from_env("cherwell_dev")


  search_object(client, object_name="Incident", pageSize=10)


  search_object(client, object_name="Incident", fields=["IncidentID", "ownedbyteam"], search_string="desktop",
                pageSize=10)

  ```


pkgId: fa7307760a9d001a2a6288ff44e6dd8ef105b5f41c7eeb3427c704a8c0181af7
name: python-cherry-picker
arch: src
version: 2.3.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/python/cherry-picker
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherry-picker-2.3.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/cherry-picker.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/cherry-picker)
  [![Supported Python versions](https://img.shields.io/pypi/pyversions/cherry-picker.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/cherry-picker)
  [![tests](https://github.com/python/cherry-picker/actions/workflows/main.yml/badge.svg)](https://github.com/python/cherry-picker/actions/workflows/main.yml)

  Usage (from a cloned CPython directory):

  ```
  Usage: cherry_picker [OPTIONS] [COMMIT_SHA1] [BRANCHES]...

    cherry-pick COMMIT_SHA1 into target BRANCHES.

  Options:
    --version                  Show the version and exit.
    --dry-run                  Prints out the commands, but not executed.
    --pr-remote REMOTE         git remote to use for PR branches
    --upstream-remote REMOTE   git remote to use for upstream branches
    --abort                    Abort current cherry-pick and clean up branch
    --continue                 Continue cherry-pick, push, and clean up branch
    --status                   Get the status of cherry-pick
    --push / --no-push         Changes won't be pushed to remote
    --auto-pr / --no-auto-pr   If auto PR is enabled, cherry-picker will
                               automatically open a PR through API if GH_AUTH
                               env var is set, or automatically open the PR
                               creation page in the web browser otherwise.
    --config-path CONFIG-PATH  Path to config file, .cherry_picker.toml from
                               project root by default. You can prepend a colon-
                               separated Git 'commitish' reference.
    -h, --help                 Show this message and exit.
  ```



  This tool is used to backport CPython changes from `main` into one or more
  of the maintenance branches (e.g. `3.12`, `3.11`).

  `cherry_picker` can be configured to backport other projects with similar
  workflow as CPython. See the configuration file options below for more details.

  The maintenance branch names should contain some sort of version number (`X.Y`).
  For example: `3.12`, `stable-3.12`, `1.5`, `1.5-lts`, are all supported branch
  names.

  It will prefix the commit message with the branch, e.g. `[3.12]`, and then
  open up the pull request page.

  Write tests using [pytest](https://docs.pytest.org/).




  Requires Python 3.8+.

  ```console
  $ python3 -m venv venv
  $ source venv/bin/activate
  (venv) $ python -m pip install cherry_picker
  ```

  The cherry picking script assumes that if an `upstream` remote is defined, then
  it should be used as the source of upstream changes and as the base for
  cherry-pick branches. Otherwise, `origin` is used for that purpose.
  You can override this behavior with the `--upstream-remote` option
  (e.g. `--upstream-remote python` to use a remote named `python`).

  Verify that an `upstream` remote is set to the CPython repository:

  ```console
  $ git remote -v
  ...
  upstream	https://github.com/python/cpython (fetch)
  upstream	https://github.com/python/cpython (push)
  ```

  If needed, create the `upstream` remote:

  ```console
  $ git remote add upstream https://github.com/python/cpython.git
  ```

  By default, the PR branches used to submit pull requests back to the main
  repository are pushed to `origin`. If this is incorrect, then the correct
  remote will need be specified using the `--pr-remote` option (e.g.
  `--pr-remote pr` to use a remote named `pr`).




  (Setup first! See previous section.)

  From the cloned CPython directory:

  ```console
  (venv) $ cherry_picker [--pr-remote REMOTE] [--upstream-remote REMOTE] [--dry-run] [--config-path CONFIG-PATH] [--abort/--continue] [--status] [--push/--no-push] [--auto-pr/--no-auto-pr] <commit_sha1> <branches>
  ```



  The commit sha1 for cherry-picking is the squashed commit that was merged to
  the `main` branch.  On the merged pull request, scroll to the bottom of the
  page.  Find the event that says something like:

  ```
  <coredeveloper> merged commit <commit_sha1> into python:main <sometime> ago.
  ```

  By following the link to `<commit_sha1>`, you will get the full commit hash.
  Use the full commit hash for `cherry_picker.py`.




  ```
  --dry-run                 Dry Run Mode.  Prints out the commands, but not executed.
  --pr-remote REMOTE        Specify the git remote to push into.  Default is 'origin'.
  --upstream-remote REMOTE  Specify the git remote to use for upstream branches.
                            Default is 'upstream' or 'origin' if the former doesn't exist.
  --status                  Do `git status` in cpython directory.
  ```

  Additional options:

  ```
  --abort        Abort current cherry-pick and clean up branch
  --continue     Continue cherry-pick, push, and clean up branch
  --no-push      Changes won't be pushed to remote
  --no-auto-pr   PR creation page won't be automatically opened in the web browser or
                 if GH_AUTH is set, the PR won't be automatically opened through API.
  --config-path  Path to config file
                 (`.cherry_picker.toml` from project root by default)
  ```

  Configuration file example:

  ```toml
  team = "aio-libs"
  repo = "aiohttp"
  check_sha = "f382b5ffc445e45a110734f5396728da7914aeb6"
  fix_commit_msg = false
  default_branch = "devel"
  ```

  Available config options:

  ```
  team            github organization or individual nick,
                  e.g "aio-libs" for https://github.com/aio-libs/aiohttp
                  ("python" by default)

  repo            github project name,
                  e.g "aiohttp" for https://github.com/aio-libs/aiohttp
                  ("cpython" by default)

  check_sha       A long hash for any commit from the repo,
                  e.g. a sha1 hash from the very first initial commit
                  ("7f777ed95a19224294949e1b4ce56bbffcb1fe9f" by default)

  fix_commit_msg  Replace # with GH- in cherry-picked commit message.
                  It is the default behavior for CPython because of external
                  Roundup bug tracker (https://bugs.python.org) behavior:
                  
                  on pull-request xxxx.
                  For projects using GitHub Issues, this option can be disabled.

  default_branch  Project's default branch name,
                  e.g "devel" for https://github.com/ansible/ansible
                  ("main" by default)
  ```

  To customize the tool for used by other project:

  1. Create a file called `.cherry_picker.toml` in the project's root
     folder (alongside with `.git` folder).

  2. Add `team`, `repo`, `fix_commit_msg`, `check_sha` and
     `default_branch` config values as described above.

  3. Use `git add .cherry_picker.toml` / `git commit` to add the config
     into Git.

  4. Add `cherry_picker` to development dependencies or install it
     by `pip install cherry_picker`

  5. Now everything is ready, use `cherry_picker <commit_sha> <branch1>
     <branch2>` for cherry-picking changes from `<commit_sha>` into
     maintenance branches.
     Branch name should contain at least major and minor version numbers
     and may have some prefix or suffix.
     Only the first version-like substring is matched when the version
     is extracted from branch name.



  - Installation: https://asciinema.org/a/125254

  - Backport: https://asciinema.org/a/125256




  For example, to cherry-pick `6de2b7817f-some-commit-sha1-d064` into
  `3.12` and `3.11`, run the following command from the cloned CPython
  directory:

  ```console
  (venv) $ cherry_picker 6de2b7817f-some-commit-sha1-d064 3.12 3.11
  ```

  What this will do:

  ```console
  (venv) $ git fetch upstream

  (venv) $ git checkout -b backport-6de2b78-3.12 upstream/3.12
  (venv) $ git cherry-pick -x 6de2b7817f-some-commit-sha1-d064
  (venv) $ git push origin backport-6de2b78-3.12
  (venv) $ git checkout main
  (venv) $ git branch -D backport-6de2b78-3.12

  (venv) $ git checkout -b backport-6de2b78-3.11 upstream/3.11
  (venv) $ git cherry-pick -x 6de2b7817f-some-commit-sha1-d064
  (venv) $ git push origin backport-6de2b78-3.11
  (venv) $ git checkout main
  (venv) $ git branch -D backport-6de2b78-3.11
  ```

  In case of merge conflicts or errors, the following message will be displayed:

  ```
  Failed to cherry-pick 554626ada769abf82a5dabe6966afa4265acb6a6 into 2.7 :frowning_face:
  ... Stopping here.

  To continue and resolve the conflict:
      $ cherry_picker --status  # to find out which files need attention
      
      $ cherry_picker --status  # should now say 'all conflict fixed'
      $ cherry_picker --continue

  To abort the cherry-pick and cleanup:
      $ cherry_picker --abort
  ```

  Passing the `--dry-run` option will cause the script to print out all the
  steps it would execute without actually executing any of them. For example:

  ```console
  $ cherry_picker --dry-run --pr-remote pr 1e32a1be4a1705e34011770026cb64ada2d340b5 3.12 3.11
  Dry run requested, listing expected command sequence
  fetching upstream ...
  dry_run: git fetch origin
  Now backporting '1e32a1be4a1705e34011770026cb64ada2d340b5' into '3.12'
  dry_run: git checkout -b backport-1e32a1b-3.12 origin/3.12
  dry_run: git cherry-pick -x 1e32a1be4a1705e34011770026cb64ada2d340b5
  dry_run: git push pr backport-1e32a1b-3.12
  dry_run: Create new PR: https://github.com/python/cpython/compare/3.12...ncoghlan:backport-1e32a1b-3.12?expand=1
  dry_run: git checkout main
  dry_run: git branch -D backport-1e32a1b-3.12
  Now backporting '1e32a1be4a1705e34011770026cb64ada2d340b5' into '3.11'
  dry_run: git checkout -b backport-1e32a1b-3.11 origin/3.11
  dry_run: git cherry-pick -x 1e32a1be4a1705e34011770026cb64ada2d340b5
  dry_run: git push pr backport-1e32a1b-3.11
  dry_run: Create new PR: https://github.com/python/cpython/compare/3.11...ncoghlan:backport-1e32a1b-3.11?expand=1
  dry_run: git checkout main
  dry_run: git branch -D backport-1e32a1b-3.11
  ```



  This will generate pull requests through a remote other than `origin`
  (e.g. `pr`)



  This will generate branches from a remote other than `upstream`/`origin`
  (e.g. `python`)



  This will do `git status` for the CPython directory.



  Cancels the current cherry-pick and cleans up the cherry-pick branch.



  Continues the current cherry-pick, commits, pushes the current branch to
  `origin`, opens the PR page, and cleans up the branch.



  Changes won't be pushed to remote.  This allows you to test and make additional
  changes.  Once you're satisfied with local changes, use `--continue` to complete
  the backport, or `--abort` to cancel and clean up the branch.  You can also
  cherry-pick additional commits, by:

  ```console
  $ git cherry-pick -x <commit_sha1>
  ```



  PR creation page won't be automatically opened in the web browser or
  if GH_AUTH is set, the PR won't be automatically opened through API.
  This can be useful if your terminal is not capable of opening a useful web browser,
  or if you use cherry-picker with a different Git hosting than GitHub.



  Allows to override default config file path
  (`<PROJ-ROOT>/.cherry_picker.toml`) with a custom one. This allows cherry_picker
  to backport projects other than CPython.




  When a cherry-pick was applied successfully, this script will open up a browser
  tab that points to the pull request creation page.

  The url of the pull request page looks similar to the following:

  ```
  https://github.com/python/cpython/compare/3.12...<username>:backport-6de2b78-3.12?expand=1
  ```

  Press the `Create Pull Request` button.

  Bedevere will then remove the `needs backport to ...` label from the original
  pull request against `main`.




  ```console
  $ # Install pytest
  $ pip install -U pytest
  $ # Run tests
  $ pytest
  ```

  Tests require your local version of Git to be 2.28.0+.



  - See the [release checklist](https://github.com/python/cherry-picker/blob/main/RELEASING.md).




  In the directory where `pyproject.toml` exists:

  ```console
  $ pip install
  ```



  See the [changelog](https://github.com/python/cherry-picker/blob/main/CHANGELOG.md).


pkgId: cca21a435d2b6dbf43086019d1a64b1795bb87e07f594c9a01679c4341a591eb
name: python-cherrypicker
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Pluck and flatten complex data.
url: https://cherrypicker.readthedocs.io
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherrypicker-0.4.0-1.src.rpm
checksum_type: sha256
description:
  *Flatten complex data.*
  ``cherrypicker`` aims to make common ETL tasks (filtering data and
  restructuring it into flat tables) easier, by taking inspiration from jQuery
  and applying it in a Pythonic way to generic data objects.
      pip install cherrypicker
  ``cherrypicker`` provides a chainable filter and extraction interface to
  allow you to easily pick out objects from complex structures and place them in
  a flat table. It fills a similar role to jQuery in JavaScript, enabling you to
  navigate complex structures without the need for lots of complex nested for
  loops or list comprehensions.
  Examples
  ++++++++
      >>> from cherrypicker import CherryPicker
      >>> import json
      >>> with open('climate.json', 'r') as fp:
      >>> picker = CherryPicker(data)
      >>> picker['id', 'city'].get()
      [[1, 'Amsterdam'], [2, 'Athens'], [3, 'Atlanta GA'], ...]
      >>> picker(city='B*')['info'](
      [[1568, 8300000], [891, 3700000], [203, 2800000]]
  More complex filtering and flattening of nested structures is possible. Learn
  more in the documentation: https://cherrypicker.readthedocs.io.


pkgId: 7991a80e75e18c2d4e255398fca03eac3b85fb57d206fc984378cb4c289cf8f5
name: python-cherrypy-dynpool
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: A dynamic thread pool tool for CherryPy.
url: https://github.com/tabo/cherrypy-dynpool/
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cherrypy-dynpool-2.4.0-1.src.rpm
checksum_type: sha256
description:
  A dynamic threadpool tool for CherryPy
  Usage::
      from cherrypy_dynpool import ThreadPoolMonitor
      cherrypy.engine.threadpool_monitor = ThreadPoolMonitor(cherrypy.engine)
      cherrypy.engine.threadpool_monitor.subscribe()
      cherrypy.config.update({
          'server.thread_pool': 5,
          'server.thread_pool_max': -1,
          'server.thread_pool_minspare': 5,
          'server.thread_pool_maxspare': 15,
          'server.thread_pool_frequency': 2,
          'server.thread_pool_log_frequency': 1,
          'server.thread_pool_shrink_frequency': 5,
      })
      cherrypy.engine.start()
      cherrypy.engine.threadpool_monitor.configure(
          thread_pool=cherrypy.server.httpserver.requests,
          logger=cherrypy.log
      )


pkgId: b1fca904913fb7039a46623bb355c3d1ddd4175ee5e6fd1ab1e7a294105a3779
name: python-cheshire-no-bleak-limit
arch: src
version: 0.5.7
epoch: 0
release: 1
summary: API for Keepsmile, LuckyStyle, Leeleberd, and related smart lights
url: https://pypi.org/project/cheshire-no-bleak-limit/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheshire-no-bleak-limit-0.5.7-1.src.rpm
checksum_type: sha256
description:
  ![Cheshire Cat](https://raw.githubusercontent.com/themooer1/cheshire/master/docs/assets/img/cheshire.png)


  API for Keepsmile and related Bluetooth LE lights.




  The example below scans for Bluetooth LE devices and tries to control any
  which are supported.

  For more detailed instructions, see the [user guide](https://github.com/themooer1/cheshire/blob/master/docs/user_guide.md).

  ```python
  import asyncio
  from bleak import BleakScanner, BleakClient
  from cheshire.compiler.state import LightState
  from cheshire.generic.command import *
  from cheshire.hal.devices import Connection, connect_to_ble_device

  async def main():
      
      discover = await BleakScanner.discover()
      connections: list[Connection] = []

      
      for bleak_device in discover:
          if bleak_device.name == None:
              continue

          
          if connection := await connect_to_ble_device(bleak_device):
              print(f"Connected to {bleak_device.name}")

              connections.append(connection)

      async def send_all(state: LightState):
          
          for c in connections:
              await c.apply(state)


      
      state = LightState()
      state.update(SwitchCommand(on=True))
      state.update(BrightnessCommand(0x30))
      state.update(RGBCommand(0x0e, 0x0, 0xaa))
      

      await send_all(state)


  asyncio.run(main())
  ```


  | Device | Bluetooth Name | Support |
  |-|-|-|
  | Keepsmile Led Strip Lights | KS03-XXXX | Yes |
  | Keepsmile Led Strip Lights (New) | KS03~XXXX | Yes |
  | Keepsmile Double Side Lighting Led Floor Lamp | ? | Unknown |
  | luckystyle Floor Lamp | KS01-XXXX | Untested |


pkgId: bbc36af88aad237ae989fc5bbb6c06a56911e0b7e7b1e4b84c0944faacebda4b
name: python-chess
arch: src
version: 1.10.0
epoch: 0
release: 1
url: https://github.com/niklasf/python-chess
rpm_license: GPL-3.0+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chess-1.10.0-1.src.rpm
checksum_type: sha256
summary:
  A chess library with move generation and validation, Polyglot opening book probing, PGN reading and writing, Gaviota tablebase probing, Syzygy tablebase probing, and XBoard/UCI engine communication.


pkgId: e8c94ac8af6c48576628e66366bec86a9050993feea892ed2b8f748a1f727db9
name: python-chess-com-api
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: An async Python wrapper for the Chess.com API
url: https://github.com/Stupidoodle/chess-com-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chess-com-api-1.0.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/chess-com-api.svg)](https://badge.fury.io/py/chess-com-api)
  [![Python versions](https://img.shields.io/pypi/pyversions/chess-com-api.svg)](https://pypi.org/project/chess-com-api/)
  [![Documentation Status](https://readthedocs.org/projects/chess-com-api/badge/?version=latest)](https://chess-com-api.readthedocs.io/en/latest/?badge=latest)
  [![GitHub Actions](https://github.com/Stupidoodle/chess-com-api/workflows/CI/badge.svg)](https://github.com/Stupidoodle/chess-com-api/actions)
  [![Coverage](https://codecov.io/gh/Stupidoodle/chess-com-api/branch/main/graph/badge.svg)](https://codecov.io/gh/Stupidoodle/chess-com-api)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  A modern, fully typed, asynchronous Python wrapper for the Chess.com API.



  - 🚀 **Fully Async**: Built with `aiohttp` for high-performance async operations
  - 📦 **Type Safety**: Complete type hints and runtime type checking
  - 🛡️ **Robust Error Handling**: Comprehensive error types and automatic retries
  - 🔄 **Rate Limiting**: Built-in rate limit handling with smart backoff
  - 📚 **Rich Data Models**: Intuitive object-oriented interface to API data
  - ✨ **Modern Python**: Supports Python 3.8+
  - 📈 **Production Ready**: Thoroughly tested and production hardened



  ```bash
  pip install chess-com-api
  ```



  ```python
  import asyncio
  from chess_com_api import ChessComClient

  async def main():
      async with ChessComClient() as client:
          
          player = await client.get_player("hikaru")
          print(f"Title: {player.title}")
          print(f"Rating: {player.rating}")

          
          games = await client.get_player_current_games("hikaru")
          for game in games:
              print(f"Game URL: {game.url}")
              print(f"Time Control: {game.time_control}")

  asyncio.run(main())
  ```





  ```python
  import aiohttp
  from chess_com_api import ChessComClient

  async def main():
      
      timeout = aiohttp.ClientTimeout(total=60)
      session = aiohttp.ClientSession(
          timeout=timeout,
          headers={"User-Agent": "MyApp/1.0"}
      )

      client = ChessComClient(
          session=session,
          max_retries=5,
          rate_limit=100
      )

      try:
          
          pass
      finally:
          await client.close()

  asyncio.run(main())
  ```



  ```python
  from chess_com_api.exceptions import NotFoundError, RateLimitError

  async def get_player_info(username: str):
      try:
          async with ChessComClient() as client:
              player = await client.get_player(username)
              return player
      except NotFoundError:
          print(f"Player {username} not found")
      except RateLimitError:
          print("Rate limit exceeded, please try again later")
      except Exception as e:
          print(f"An error occurred: {e}")
  ```



  For full documentation, please visit [chess-com-api.readthedocs.io](https://chess-com-api.readthedocs.io/).



  Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.

  1. Fork the repository
  2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
  3. Install development dependencies (`pip install -e ".[dev]"`)
  4. Make your changes
  5. Run tests (`pytest`)
  6. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
  7. Push to the branch (`git push origin feature/AmazingFeature`)
  8. Open a Pull Request

  Please make sure to update tests as appropriate and follow the existing code style.



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



  - Chess.com for providing the public API
  - The Python community for valuable feedback and contributions



  If you encounter any problems or have any questions, please [open an issue](https://github.com/Stupidoodle/chess-com-api/issues/new/choose) on GitHub.


pkgId: 72186c46236f41784db5366e347928ae06308a40eaa392b1e43f1a2ccdba39eb
name: python-chess-graph
arch: src
version: 1.7.5
epoch: 0
release: 1
url: https://github.com/Destaq/chess_graph
rpm_license: 'MIT'
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chess-graph-1.7.5-1.src.rpm
checksum_type: sha256
summary:
  A package that can create an interactive multi-level, shaded, piechart visualization of chess games.

description:
  ![Python application](https://github.com/Destaq/chess_graph/workflows/Python%20application/badge.svg)


  <p align="center">
    <img width = "574" height = "400" src = "https://github.com/Destaq/opening_analysis/raw/master/images/main_image.png">
   </p>


  A program that will produce a graphical sunburst chart of chess openings from the PGN that is provided to it.

  You can easily run this with the pip module in one function by simply specifying the path to the PGN database that you would like to have analyzed.

  This package can customize the multi=level pie chart in many ways. It can shade segments based on win percentage, you can click to zoom in, openings are highlighted, and so much more. It's the perfect learning tool for anyone interested in chess or wishing to improve their opening skills!


  - Make graph of games to **any depth**
  - Upload a **custom database** and see how *your* chart looks like
  - **Hover** to see metadata such as **game count and percentage of parent**
  - Easily **find openings** with simple hover tooltip identification
  - **Click to zoom** in on a slice and expand it, making it easy to magnify any slice of the pie chart
  - **Downloadable files**: you can download the chart as an interactive HTML, or as a static PNG/JPEG/SVG/WEBP image with just a few clicks
  - **Win Ratio Shading** means that you will never be in doubt as to what next move is statistically best
  - **Hide small slices** and prevent them from showing up in the graph!
  - **Custom branching** to analyze database from **any position**
  - **Find your player and color** by selecting games from someone based on their color (white or black) and name


  - Runs in Python 3, must have Python 3 installed
  - Requires Plotly and pgnparser

  You can install Plotly and pgnparser using PyPi, as long as you are an admin user on your device. To do so, simply type `pip install plotly` and `pip install pgnparser` into your terminal.


  1. `pip install chess-graph`
  2. Open terminal/interpreter.
  3. `import chess_graph`
  4. `chess_graph.graph(database, depth=5, shade = True, fragmentation_percentage=0.0032, should_defragment=False, custom_branching=False, should_download = False, download_format = 'png', download_name = 'fig1')`
    - Note that the path to the pgn file (the database) must be relative to the current directory python is running in. For example, if you have the pgn downloaded on your Desktop, you could easily solve this issue by navigating to Desktop within terminal (cd Desktop). From there, you can replace the database argument with the simple filename (assuming it is in Desktop). If this is confusing, just type in the full path.


  The `graph()` function takes 11 arguments, and 10 of them are default-set. We'll explore each of them so that you know how to properly use this package to its full potential.

  - The `database` argument: This argument must *always* be inputted. It is the path to the file. Let's look at two examples.

    1. `chess_graph.graph('Users/student/Desktop/pgns/mir_khan.pgn')`. Here, we are running the chess_graph on a pgn from Mir Sultan Khan. We are showing the program what file to read this by providing the full path to the file.

    2. In the example above, you can see that the file is in the `pgns` folder in Desktop. So, we can open our terminal, and then type `cd Desktop`, `cd pgns` to go the folder that has this file. Because we are now in that directory, we can type: `chess_graph.graph('mir_khan.pgn')` as it is in the current directory. If you are unsure, stick with the full file path.

  - The `depth` argument. This is set to 5 by default, and shows the number of rings that the pie chart will have. You can change this by typing `chess_graph.graph(*path to file*, depth = 7)`. Make sure that you type `depth = `, and not just the integer depth.

  - The `shade` argument. This is set to True by default. It is whether you should shade the segments or not based on W/B win percentage. If you set it to False, (`chess_graph.graph(*path to file*, shade = False)`), then a vividly colored chart will be produced instead.

  - The `fragmentation_percentage` argument. Set to 0.0032 by default. You can 'defragment' the graph by hiding very small slices. This argument shows how small the slices have to be (relative to the total number of games, e.g. 2 games/100 games total = 2%) to be deleted. In this example, the percentage is 100*0.0032 = 0.32%. Example: `chess_graph.graph(*path to file*, fragmentation_percentage = 0.05)` - 5% or smaller will be deleted.

  - The `should_defragment` argument. Set to False by default. Setting it to True will allow the graph to hide the slices, keeping it False will show all slices. Even if you change fragmentation_percentage, if this isn't set to True, nothing will change. Example: `chess_graph.graph(*path to file*, fragmentation_percentage = 0.05, should_defragment = True)`

  - The `custom branching` argument. Set to False by default. You can analyze a database from any position if set to True. Example: `chess_graph.graph(*path to file*, custom_branching = True)`. You will be asked for an input for the custom branching. For the sake of this example, let's say you want to analyze only positions from e4 e5. So, type e4 e5. The graph will then show positions only from e4 e5.

  - The `should_download` argument. Set to False be default. You can download the figures in five different formats (see more below). Make sure you have the packages installed before downloading. You can set this to True if you would like to download the figure.

  - The `download_format` argument. Set to the string 'png' by default. Change it to the string of the file type you want the download to be in. `chess_graph.graph(..., download_format = 'jpeg')`

  - The `download_name` argument. The name of the figure that will be downloaded. Set to be fig1 by default, meaning that files downloaded will be downloaded as fig1.png. See above.

  - The `color` argument. This is set to both by default. Valid inputs are 'both', 'white', 'w', 'black' and 'b'. If you change the color argument from both, then the program will only read games that are from the color you chose. Note that you need to also change the player name with the `name` argument if you do so. See below.

  - The `name` argument. This argument will allow the program to pick games from the file it is given, but only games from a certain player. There is an example below:
  Set the color to 'black' or 'white' to pick only games where the player (the name) played as black or white. (i.e. `chess_graph.graph('pgns/Carlsen.pgn', color = 'white', name = 'Magnus Carlsen')` will pick all the games where Carlsen played as white.)

  **Remember to include all variations and parts of a player's name! For example, the player Viktor Korchnoi has his last name spelled as Kortschnoj as well. In that case, for the 'name' field, type: Viktor Korchnoi Kortschnoj**


  Downloading *is* an option, although you need to make sure you have the proper libraries installed.

  Currently, you can uncomment the download interactive HTML file without anything else to download. If you do so, an HTML file of the graph will be saved to your device, which you can open with your browser.

  You can also download the file as: SVG, PDF, JPEG, PNG, and WebP.

  However, if you want to download in *these* formats you need the following installed.

  `npm install -g electron@1.8.4 orca`

  `pip install psutil requests`

  `pip install psutil`


  *All examples are those of Magnus Carlsen's OTB tournament games*

  <p align="center">
    <img width="700" height="450" src="https://github.com/Destaq/opening_analysis/raw/master/images/random.png">
  </p>


  <p align="center">
    <img width = "522" height = "117" src = "https://github.com/Destaq/opening_analysis/raw/master/images/hovering.png">
   </p>


  <p align="center">
    <img width = "528" height = "457" src = "https://github.com/Destaq/opening_analysis/raw/master/images/zoom.png">
   </p>


  I based this chart loosely off of a post that I read on ebemunk's blog - you can find the link here: https://blog.ebemunk.com/a-visual-look-at-2-million-chess-games/. However, that project was written in Java and it didn't have everything that I wanted, such as showing all the games, zooming in, etc.


pkgId: 4d8ea077896967ec2778ee72075d4a983c006aa8d390f1531a24d60046e023ab
name: python-chess-heatmap-qxf2
arch: src
version: 0.0.0.23
epoch: 0
release: 1
summary: Package to generate chess heatmaps from pgn files
url: https://pypi.org/project/chess-heatmap-qxf2/
rpm_license: GNU General Public License (GPL)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chess-heatmap-qxf2-0.0.0.23-1.src.rpm
checksum_type: sha256
description:
  A python project which uses dask and coiled to explore parallelism. The project produces a control heatmap for a chess game.
  HeatMap visualization shows which side controls which sqaures for each ply in the chess board. It can be used to analyze important squares, utilization, capture squares.
  This package contains the files which are packaged as a python package.


pkgId: 94f5335931ff2048130dfd8659b55020a3d82de78d107130b52a02169145e1a6
name: python-chess_features
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Transform chess positions to various encodings
url: https://pypi.org/project/chess_features/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chess_features-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This Python package provides a convenient way to convert chess board representations from the Python Chess library into formats suitable for machine learning algorithms. It offers various representations that can be directly utilized as input for machine learning tasks.



  - Convert Python Chess board representations into machine learning-friendly formats.
  - Supports several common representations used in machine learning tasks.
  - Easy-to-use interface for seamless integration into your projects.



  You can install the package using pip:

  ```bash
  pip install chess_features
  ```



  Here's a basic example demonstrating how to use the package:

  ```python
  from chess import Board
  from chess_features import ChessFeatures


  board = Board()


  converter = ChessFeatures()



  feature_vector = converter.to_stockfish_feature_vector(board)


  bitmap = converter.to_bitmap(board)

  ```



  - Feature Vector: A flattened vector representation of the board.
  - Bitmap: A bitmap representation of the board.



  - This package utilizes the [Python Chess library](https://python-chess.readthedocs.io/en/latest/).
  - The information for Stockfish features are taken from [Stockfish Evaluation Guide](https://hxim.github.io/Stockfish-Evaluation-Guide/).



  Apart from this readme no ChatGPT was used.


pkgId: 09dc72ac91d928440ef2311b677346e77fa9959cbbf4de510d340d7d19ad02db
name: python-chessboard
arch: src
version: 1.5.4
epoch: 0
release: 1
summary: CLI to solve combinatoric chess puzzles.
url: https://github.com/kdeldycke/chessboard
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chessboard-1.5.4-1.src.rpm
checksum_type: sha256
description:
  CLI to solve combinatoric chess puzzles.
  Stable release: |release| |versions| |license| |dependencies|
  Development: |build| |docs| |coverage| |quality|


pkgId: 30a827fd7bc78898bcd02b9e2a3bd5e8b0bec0452ddc6b8d6fdd12947ff9592a
name: python-chesstab
arch: src
version: 8.0
epoch: 0
release: 1
summary: Database for chess games.
url: http://www.solentware.co.uk
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chesstab-8.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Licence for chesstab package Copyright (c) 2009, Roger Marsh All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the owner 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: d33e6dac3ddad03a13e75afb9dda9be5a785c8185c150c7ba7b45c14661b11a6
name: python-chest
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: Simple on-disk dictionary
url: https://github.com/ContinuumIO/chest
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chest-0.2.3-1.src.rpm
checksum_type: sha256
description:
  |Build Status| |Coverage Status| |Version Status| |Downloads|
  A dictionary that spills to disk.
  Chest acts likes a dictionary but it can write its contents to disk.  This is
  useful in the following two occasions:
  1.  Chest can hold datasets that are larger than memory
  2.  Chest persists and so can be saved and loaded for later use


pkgId: 9d26311ec20142517601ae4a23511763813d2debcf6987ae16587c934e184dad
name: python-cheutils
arch: src
version: 2.5.15
epoch: 0
release: 1
url: https://github.com/chewitty/cheutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheutils-2.5.15-1.src.rpm
checksum_type: sha256
summary:
  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.

description:
  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.



  - model_options: methods such as get_estimator to get a handle on a configured estimator with a specified parameter dictionary or get_default_grid to get the configured hyperparameter grid
  - model_builder: methods for building and executing ML pipeline steps e.g., params_optimization etc.
  - project_tree: methods for accessing the project tree - e.g., get_data_dir() for accessing the configured data and get_output_dir() for the output folders, loading and savings Excel and CSV.
  - common_utils: methods to support common programming tasks, such as labeling (e.g., `label(file_name, label='some_label')`) or tagging and date-stamping files (e.g., `datestamp(file_name, fmt='%Y-%m-%d')`).
  - propertiesutil: utility for managing properties files or project configuration, based on jproperties. The application configuration is expected to be available in a file named app-config.properties, which can be placed anywhere in the project root or any subfolder thereafter.
  - decorator_debug, decorator_timer, and decorator_singleton: decorators for enabling logging and method timers; as well as a singleton decorator
  - datasource_utils: utility for managing datasource configuration or properties file (ds-config.properties) and offers a set of generic datasource access methods.

  You import the `cheutils` module as per usual:
  ```
  import cheutils
  ```
  The following provide access to the properties file, usually expected to be named "app-config.properties" and typically found in the project data folder or anywhere either in the project root or any other subfolder
  ```
  APP_PROPS = cheutils.AppProperties() # to load the app-config.properties file
  ```
  Thereafter, you can read any properties using various methods such as:
  ```
  DATA_DIR = APP_PROPS.get('project.data.dir')
  ```
  You can also retrieve the path to the data folder, which is under the project root as follows:
  ```
  cheutils.get_data_dir()  # returns the path to the project data folder, which is always interpreted relative to the project root
  ```
  You can retrieve other properties as follows:
  ```
  VALUES_LIST = APP_PROPS.get_list('some.configured.list') # e.g., some.configured.list=[1, 2, 3] or ['1', '2', '3']
  VALUES_DIC = APP_PROPS.get_dic_properties('some.configured.dict') # e.g., some.configured.dict={'val1': 10, 'val2': 'value'}
  BOL_VAL = APP_PROPS.get_bol('some.configured.bol') # e.g., some.configured.bol=True
  ```
  You also have access to the LOGGER - you can simply call `LOGGER.debug()` in a similar way to you will when using loguru or standard logging
  calling `set_prefix()` on the LOGGER instance ensures the log messages are scoped to that context thereafter,
  which can be helpful when reviewing the generated log file (`app-log.log`) - the default prefix is "app-log".

  You can get a handle to an application logger as follows:
  ```
  LOGGER = cheutils.LOGGER.get_logger()
  ```
  You can set the logger prefix as follows:
  ```
  LOGGER.set_prefix(prefix='my_project')
  ```
  The `model_options` currently supports any configured estimator (see, the xgb_boost example below for how to configure any estimator).
  You can configure any of the models for your project with an entry in the app-config.properties as follows:
  ```
  model.active.model_option=xgb_boost # with default parameters
  ```
  You can get a handle to the corresponding estimator as follows:
  ```
  estimator = cheutils.get_estimator(model_option='xgb_boost')
  ```
  You can also configure the following property for example:
  ```
  model.param_grids.xgb_boost={'learning_rate': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'subsample': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'min_child_weight': {'type': float, 'start': 0.1, 'end': 1.0, 'num': 10}, 'n_estimators': {'type': int, 'start': 10, 'end': 400, 'num': 10}, 'max_depth': {'type': int, 'start': 3, 'end': 17, 'num': 5}, 'colsample_bytree': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'gamma': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'reg_alpha': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, }
  ```
  Thereafter, you can do the following:
  ```
  estimator = cheutils.get_estimator(**get_params(model_option='xgb_boost'))
  ```
  Thereafter, you can simply fit the model as follows per usual:
  ```
  estimator.fit(X_train, y_train)
  ```
  Given a default model parameter configuration (usually in the properties file), you can generate a promising parameter grid using RandomSearchCV as in the following line. Note that, the pipeline can either be an sklearn pipeline or an estimator.
  The general idea is that, to avoid worrying about trying to figure out the optimal set of hyperparameter values for a given estimator, you can do that automatically, by
  adopting a two-step coarse-to-fine search, where you configure a broad hyperparameter space or grid based on the estimator's most important or impactful hyperparameters, and the use a random search to find a set of promising hyperparameters that
  you can use to conduct a finer hyperparameter space search using other algorithms such as bayesean optimization (e.g., hyperopt or Scikit-Optimize, etc.)
  ```
  promising_grid = cheutils.promising_params_grid(pipeline, X_train, y_train, grid_resolution=3, prefix='model_prefix')
  ```
  You can run hyperparameter optimization or tuning as follows (assuming you enabled cross-validation in your configuration or app-conf.properties - e.g., with an entry such as `model.cross_val.num_folds=3`), if using hyperopt; and if you are running Mlflow experiments and logging, you could also pass an optional mlflow_exp={'log': True, 'uri': 'http://<mlflow_tracking_server>:<port>', } in the optimization call:
  ```
  best_estimator, best_score, best_params, cv_results = cheutils.params_optimization(pipeline, X_train, y_train, promising_params_grid=promising_grid, with_narrower_grid=True, fine_search='hyperoptcv', prefix='model_prefix')
  ```
  You can get a handle to the datasource wrapper as follows:
  ```
  ds = DSWrapper() # it is a singleton
  ```
  You can then read a large CSV file, leveraging `dask` as follows:
  ```
  data_df = ds.read_large_csv(path_to_data_file=os.path.join(get_data_dir(), 'some_file.csv'))
  ```
  Assuming you previously defined a datasource configuration in ds-config.properties, containing:
  `project.ds.supported={'mysql_local': {'db_driver': 'MySQL ODBC 8.1 ANSI Driver', 'drivername': 'mysql+pyodbc', 'db_server': 'localhost', 'db_port': 3306, 'db_name': 'test_db', 'username': 'test_user', 'password': 'test_password', 'direct_conn': 0, 'timeout': 0, 'verbose': True}, }`
  You could read from a configured datasource as follows:
  ```
  ds_config = {'db_key': 'mysql_local', 'ds_namespace': 'test', 'db_table': 'some_table', 'data_file': None}
  data_df = ds.read_from_datasource(ds_config=ds_config, chunksize=5000)
  ```
  Note that, if you call `read_from_datasource()` with `data_file` set in the `ds_config` as either an Excel or CSV then it is equivalent to calling a read CSV or Excel.
  There are transformers for dropping clipping data based on catagorical aggregate statistics such as mean or median values.
  You can add a clipping transformer to your pipeline as follows:
  ```
  num_cols = ['rental_rate', 'release_year', 'length', 'replacement_cost']
  filter_by = 'R_rated'
  clip_outliers_tf = ClipDataTransformer(rel_cols=num_cols, filterby=filter_by)
  standard_pipeline_steps.append(('clip_outlier_step', clip_outliers_tf))
  ```
  You can also include feature selection by adding the following to the pipeline:
  ```
  feat_sel_tf = FeatureSelectionTransformer(estimator=get_estimator(model_option='xgboost'), random_state=100)

  standard_pipeline_steps.append(('feat_selection_step', feat_sel_tf))
  ```


pkgId: 0dc250105ee9a98610e64c39458f094c1c05395c1acf8c490ce19cde9644b255
name: python-cheutils
arch: src
version: 2.5.8
epoch: 0
release: 1
url: https://github.com/chewitty/cheutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheutils-2.5.8-1.src.rpm
checksum_type: sha256
summary:
  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.

description:
  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.



  - model_options: methods such as get_estimator to get a handle on a configured estimator with a specified parameter dictionary or get_default_grid to get the configured hyperparameter grid
  - model_builder: methods for building and executing ML pipeline steps e.g., params_optimization etc.
  - project_tree: methods for accessing the project tree - e.g., get_data_dir() for accessing the configured data and get_output_dir() for the output folders, loading and savings Excel and CSV.
  - common_utils: methods to support common programming tasks, such as labeling (e.g., `label(file_name, label='some_label')`) or tagging and date-stamping files (e.g., `datestamp(file_name, fmt='%Y-%m-%d')`).
  - propertiesutil: utility for managing properties files or project configuration, based on jproperties. The application configuration is expected to be available in a file named app-config.properties, which can be placed anywhere in the project root or any subfolder thereafter.
  - decorator_debug, decorator_timer, and decorator_singleton: decorators for enabling logging and method timers; as well as a singleton decorator
  - datasource_utils: utility for managing datasource configuration or properties file (ds-config.properties) and offers a set of generic datasource access methods.

  You import the `cheutils` module as per usual:
  ```
  import cheutils
  ```
  The following provide access to the properties file, usually expected to be named "app-config.properties" and typically found in the project data folder or anywhere either in the project root or any other subfolder
  ```
  APP_PROPS = cheutils.AppProperties() # to load the app-config.properties file
  ```
  Thereafter, you can read any properties using various methods such as:
  ```
  DATA_DIR = APP_PROPS.get('project.data.dir')
  ```
  You can also retrieve the path to the data folder, which is under the project root as follows:
  ```
  cheutils.get_data_dir()  # returns the path to the project data folder, which is always interpreted relative to the project root
  ```
  You can retrieve other properties as follows:
  ```
  VALUES_LIST = APP_PROPS.get_list('some.configured.list') # e.g., some.configured.list=[1, 2, 3] or ['1', '2', '3']
  VALUES_DIC = APP_PROPS.get_dic_properties('some.configured.dict') # e.g., some.configured.dict={'val1': 10, 'val2': 'value'}
  BOL_VAL = APP_PROPS.get_bol('some.configured.bol') # e.g., some.configured.bol=True
  ```
  You also have access to the LOGGER - you can simply call `LOGGER.debug()` in a similar way to you will when using loguru or standard logging
  calling `set_prefix()` on the LOGGER instance ensures the log messages are scoped to that context thereafter,
  which can be helpful when reviewing the generated log file (`app-log.log`) - the default prefix is "app-log".

  You can get a handle to an application logger as follows:
  ```
  LOGGER = cheutils.LOGGER.get_logger()
  ```
  You can set the logger prefix as follows:
  ```
  LOGGER.set_prefix(prefix='my_project')
  ```
  The `model_options` currently supports any configured estimator (see, the xgb_boost example below for how to configure any estimator).
  You can configure any of the models for your project with an entry in the app-config.properties as follows:
  ```
  model.active.model_option=xgb_boost # with default parameters
  ```
  You can get a handle to the corresponding estimator as follows:
  ```
  estimator = cheutils.get_estimator(model_option='xgb_boost')
  ```
  You can also configure the following property for example:
  ```
  model.param_grids.xgb_boost={'learning_rate': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'subsample': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'min_child_weight': {'type': float, 'start': 0.1, 'end': 1.0, 'num': 10}, 'n_estimators': {'type': int, 'start': 10, 'end': 400, 'num': 10}, 'max_depth': {'type': int, 'start': 3, 'end': 17, 'num': 5}, 'colsample_bytree': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'gamma': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'reg_alpha': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, }
  ```
  Thereafter, you can do the following:
  ```
  estimator = cheutils.get_estimator(**get_params(model_option='xgb_boost'))
  ```
  Thereafter, you can simply fit the model as follows per usual:
  ```
  estimator.fit(X_train, y_train)
  ```
  Given a default model parameter configuration (usually in the properties file), you can generate a promising parameter grid using RandomSearchCV as in the following line. Note that, the pipeline can either be an sklearn pipeline or an estimator.
  The general idea is that, to avoid worrying about trying to figure out the optimal set of hyperparameter values for a given estimator, you can do that automatically, by
  adopting a two-step coarse-to-fine search, where you configure a broad hyperparameter space or grid based on the estimator's most important or impactful hyperparameters, and the use a random search to find a set of promising hyperparameters that
  you can use to conduct a finer hyperparameter space search using other algorithms such as bayesean optimization (e.g., hyperopt or Scikit-Optimize, etc.)
  ```
  promising_grid = cheutils.promising_params_grid(pipeline, X_train, y_train, grid_resolution=3, prefix='model_prefix')
  ```
  You can run hyperparameter optimization or tuning as follows (assuming you enabled cross-validation in your configuration or app-conf.properties - e.g., with an entry such as `model.cross_val.num_folds=3`), if using hyperopt; and if you are running Mlflow experiments and logging, you could also pass an optional mlflow_exp={'log': True, 'uri': 'http://<mlflow_tracking_server>:<port>', } in the optimization call:
  ```
  best_estimator, best_score, best_params, cv_results = cheutils.params_optimization(pipeline, X_train, y_train, promising_params_grid=promising_grid, with_narrower_grid=True, fine_search='hyperoptcv', prefix='model_prefix')
  ```
  You can get a handle to the datasource wrapper as follows:
  ```
  ds = DSWrapper() # it is a singleton
  ```
  You can then read a large CSV file, leveraging `dask` as follows:
  ```
  data_df = ds.read_large_csv(path_to_data_file=os.path.join(get_data_dir(), 'some_file.csv'))
  ```
  Assuming you previously defined a datasource configuration in ds-config.properties, containing:
  `project.ds.supported={'mysql_local': {'db_driver': 'MySQL ODBC 8.1 ANSI Driver', 'drivername': 'mysql+pyodbc', 'db_server': 'localhost', 'db_port': 3306, 'db_name': 'test_db', 'username': 'test_user', 'password': 'test_password', 'direct_conn': 0, 'timeout': 0, 'verbose': True}, }`
  You could read from a configured datasource as follows:
  ```
  ds_config = {'db_key': 'mysql_local', 'ds_namespace': 'test', 'db_table': 'some_table', 'data_file': None}
  data_df = ds.read_from_datasource(ds_config=ds_config, chunksize=5000)
  ```
  Note that, if you call `read_from_datasource()` with `data_file` set in the `ds_config` as either an Excel or CSV then it is equivalent to calling a read CSV or Excel.


pkgId: 469d64673739438f3535ccf9960b34b628c0f1070693543e94159c711e252f23
name: python-cheutils
arch: src
version: 2.6.13
epoch: 0
release: 1
url: https://github.com/chewitty/cheutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheutils-2.6.13-1.src.rpm
checksum_type: sha256
summary:
  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.

description:
  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.



  - model_options: methods such as get_estimator to get a handle on a configured estimator with a specified parameter dictionary or get_default_grid to get the configured hyperparameter grid
  - model_builder: methods for building and executing ML pipeline steps e.g., params_optimization etc.
  - project_tree: methods for accessing the project tree - e.g., get_data_dir() for accessing the configured data and get_output_dir() for the output folders, loading and savings Excel and CSV.
  - common_utils: methods to support common programming tasks, such as labeling (e.g., `label(file_name, label='some_label')`) or tagging and date-stamping files (e.g., `datestamp(file_name, fmt='%Y-%m-%d')`).
  - propertiesutil: utility for managing properties files or project configuration, based on jproperties. The application configuration is expected to be available in a file named app-config.properties, which can be placed anywhere in the project root or any subfolder thereafter.
  - decorator_debug, decorator_timer, and decorator_singleton: decorators for enabling logging and method timers; as well as a singleton decorator
  - datasource_utils: utility for managing datasource configuration or properties file (ds-config.properties) and offers a set of generic datasource access methods.

  You import the `cheutils` module as per usual:
  ```
  import cheutils
  ```
  The following provide access to the properties file, usually expected to be named "app-config.properties" and typically found in the project data folder or anywhere either in the project root or any other subfolder
  ```
  APP_PROPS = cheutils.AppProperties() # to load the app-config.properties file
  ```
  Thereafter, you can read any properties using various methods such as:
  ```
  DATA_DIR = APP_PROPS.get('project.data.dir')
  ```
  You can also retrieve the path to the data folder, which is under the project root as follows:
  ```
  cheutils.get_data_dir()  # returns the path to the project data folder, which is always interpreted relative to the project root
  ```
  You can retrieve other properties as follows:
  ```
  VALUES_LIST = APP_PROPS.get_list('some.configured.list') # e.g., some.configured.list=[1, 2, 3] or ['1', '2', '3']
  VALUES_DIC = APP_PROPS.get_dic_properties('some.configured.dict') # e.g., some.configured.dict={'val1': 10, 'val2': 'value'}
  BOL_VAL = APP_PROPS.get_bol('some.configured.bol') # e.g., some.configured.bol=True
  ```
  You also have access to the LOGGER - you can simply call `LOGGER.debug()` in a similar way to you will when using loguru or standard logging
  calling `set_prefix()` on the LOGGER instance ensures the log messages are scoped to that context thereafter,
  which can be helpful when reviewing the generated log file (`app-log.log`) - the default prefix is "app-log".

  You can get a handle to an application logger as follows:
  ```
  LOGGER = cheutils.LOGGER.get_logger()
  ```
  You can set the logger prefix as follows:
  ```
  LOGGER.set_prefix(prefix='my_project')
  ```
  The `model_options` currently supports any configured estimator (see, the xgb_boost example below for how to configure any estimator).
  You can configure any of the models for your project with an entry in the app-config.properties as follows:
  ```
  model.active.model_option=xgb_boost # with default parameters
  ```
  You can get a handle to the corresponding estimator as follows:
  ```
  estimator = cheutils.get_estimator(model_option='xgb_boost')
  ```
  You can also configure the following property for example:
  ```
  model.param_grids.xgb_boost={'learning_rate': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'subsample': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'min_child_weight': {'type': float, 'start': 0.1, 'end': 1.0, 'num': 10}, 'n_estimators': {'type': int, 'start': 10, 'end': 400, 'num': 10}, 'max_depth': {'type': int, 'start': 3, 'end': 17, 'num': 5}, 'colsample_bytree': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'gamma': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'reg_alpha': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, }
  ```
  Thereafter, you can do the following:
  ```
  estimator = cheutils.get_estimator(**get_params(model_option='xgb_boost'))
  ```
  Thereafter, you can simply fit the model as follows per usual:
  ```
  estimator.fit(X_train, y_train)
  ```
  Given a default model parameter configuration (usually in the properties file), you can generate a promising parameter grid using RandomSearchCV as in the following line. Note that, the pipeline can either be an sklearn pipeline or an estimator.
  The general idea is that, to avoid worrying about trying to figure out the optimal set of hyperparameter values for a given estimator, you can do that automatically, by
  adopting a two-step coarse-to-fine search, where you configure a broad hyperparameter space or grid based on the estimator's most important or impactful hyperparameters, and the use a random search to find a set of promising hyperparameters that
  you can use to conduct a finer hyperparameter space search using other algorithms such as bayesean optimization (e.g., hyperopt or Scikit-Optimize, etc.)
  ```
  promising_grid = cheutils.promising_params_grid(pipeline, X_train, y_train, grid_resolution=3, prefix='model_prefix')
  ```
  You can run hyperparameter optimization or tuning as follows (assuming you enabled cross-validation in your configuration or app-conf.properties - e.g., with an entry such as `model.cross_val.num_folds=3`), if using hyperopt; and if you are running Mlflow experiments and logging, you could also pass an optional mlflow_exp={'log': True, 'uri': 'http://<mlflow_tracking_server>:<port>', } in the optimization call:
  ```
  best_estimator, best_score, best_params, cv_results = cheutils.params_optimization(pipeline, X_train, y_train, promising_params_grid=promising_grid, with_narrower_grid=True, fine_search='hyperoptcv', prefix='model_prefix')
  ```
  You can get a handle to the datasource wrapper as follows:
  ```
  ds = DSWrapper() # it is a singleton
  ```
  You can then read a large CSV file, leveraging `dask` as follows:
  ```
  data_df = ds.read_large_csv(path_to_data_file=os.path.join(get_data_dir(), 'some_file.csv'))
  ```
  Assuming you previously defined a datasource configuration in ds-config.properties, containing:
  `project.ds.supported={'mysql_local': {'db_driver': 'MySQL ODBC 8.1 ANSI Driver', 'drivername': 'mysql+pyodbc', 'db_server': 'localhost', 'db_port': 3306, 'db_name': 'test_db', 'username': 'test_user', 'password': 'test_password', 'direct_conn': 0, 'timeout': 0, 'verbose': True}, }`
  You could read from a configured datasource as follows:
  ```
  ds_config = {'db_key': 'mysql_local', 'ds_namespace': 'test', 'db_table': 'some_table', 'data_file': None}
  data_df = ds.read_from_datasource(ds_config=ds_config, chunksize=5000)
  ```
  Note that, if you call `read_from_datasource()` with `data_file` set in the `ds_config` as either an Excel or CSV then it is equivalent to calling a read CSV or Excel.
  There are transformers for dropping clipping data based on catagorical aggregate statistics such as mean or median values.
  You can add a clipping transformer to your pipeline as follows:
  ```
  num_cols = ['rental_rate', 'release_year', 'length', 'replacement_cost']
  filter_by = 'R_rated'
  clip_outliers_tf = ClipDataTransformer(rel_cols=num_cols, filterby=filter_by)
  standard_pipeline_steps.append(('clip_outlier_step', clip_outliers_tf))
  ```
  You can also include feature selection by adding the following to the pipeline:
  ```
  feat_sel_tf = FeatureSelectionTransformer(estimator=get_estimator(model_option='xgboost'), random_state=100)

  standard_pipeline_steps.append(('feat_selection_step', feat_sel_tf))
  ```
  You can also use a configured column transformer called `SelectiveColumnTransformer`. For example, if you already have configured a column transformer in the `app-config.properties` such as:
  ```
  model.selectivescaler.transformers={{'name': 'scaler_tf', 'transformer_name': 'StandardScaler', 'transformer_package': 'sklearn.preprocessing', 'transformer_params': {}, 'columns': ['col1_label', 'col2_label']}, }
  ```
  Then you can add it to the pipeline as below. The `SelectiveColumnTransformer` uses the configured property to determine the transformer(s) to add to the pipeline.
  ```
  scaler_tf = SelectiveColumnTransformer()
  standard_pipeline_steps.append(('scale_feats_step', scaler_tf))
  ```


pkgId: 233ff21651675ed927d4edbd8f890e8bfc1d1468026e19164257a89880c780b6
name: python-cheutils
arch: src
version: 2.7.15
epoch: 0
release: 1
url: https://github.com/chewitty/cheutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheutils-2.7.15-1.src.rpm
checksum_type: sha256
summary:
[cell repeats an earlier one in this file: 119 characters]

description:
  from movierental.notebook import model_option



  A set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.


  - Managing properties files or project configuration, based on jproperties. The application configuration is expected to be available in a properties file named `app-config.properties`, which can be placed anywhere in the project root or any project subfolder.
  - Convenience methods such as `get_estimator()` to get a handle on any configured estimator with a specified hyperparameters dictionary, `get_params_grid()` or `get_param_defaults()` relating to obtaining model hyperparameters in the `app-config.properties` file.
  - Convenience methods for conducting hyperparameter optimization such as `params_optimization()`, `promising_params_grid()` for obtaining a set of promising hyperparameters using RandomSearchCV and a set of broadly specified or configured hyperparameters in the `app-config.properties`; a combination of `promising_params_grid()` followed by `params_optimization()` constitutes a coarse-to-fine search.
  - Convenience methods for accessing the project tree folders - e.g., `get_data_dir()` for accessing the configured data and `get_output_dir()` for the output folders, `load_dataset()` for loading, `save_excel()` and `save_csv()` for savings Excel in the project output folder and CSV respectively; you can also save any plotted figure using `save_current_fig()` (note that this must be called before `plt.show()`.
  - Convenience methods to support common programming tasks, such as renaming or tagging file names- e.g., `label(file_name, label='some_label')`) or tagging and date-stamping files (e.g., `datestamp(file_name, fmt='%Y-%m-%d')`).
  - A debug or logging, timer, and singleton decorators - for enabling logging and method timing, as well as creating singleton instances.
  - Convenience methods available via the `DSWrapper` for managing datasource configuration or properties files - e.g. `ds-config.properties` - offering a set of generic datasource access methods such as `apply_to_datasource()` to persist data to any configured datasource or `read_from_datasource()` to read data from any configured datasources.
  - A set of custom `scikit-learn` transformers for preprocessing data such as `DataPrepTransformer` which can be added to a data pipeline for pre-process dataset - e.g., handling date conversions, type casting of columns, clipping data, generating special features from rows of text strings, generating calculated features, masking columns, dropping correlated or potential data leakage columns, and generating target variables from other features as needed (separet from target encoding). A `GeospatialTransformer` for generating geohash features from latitude and longitudes; a `SelectiveFunctionTransformer` and `SelectiveColumnTransformer` for selectively transforming dataframe columns; a `DateFeaturesTransformer` for generating date-related features for feature engineering, and `FeatureSelectionTransformer` for feature selection using configured estimators such as `Lasso` or `LinearRegression`
  - A set of ther generic or common utilities for summarizing dataframes - e.g., using `summarize()` or to winsorize using `winsorize_it()`
  - A set of convenience properties handlers to accessing generic configured properties relating to the project tree, data preparation, or model development and execution such as `ProjectTreeProperties`, `DataPrepProperties`, and `ModelProperties`. These handlers offer a convenient feature for reloading properties as needed, thereby refreshing properties without having to re-start the running VM (really only useful in development). However you may access any configured properties in the usual way via the `AppProperties` object.


  The module expects that you may wish to use a project configuration file - the default expected is `app-config.properties`. A sample such properties file may contain entries such as the following:
  ```



  project.namespace=cheutils
  project.root.dir=./
  project.data.dir=./data/
  project.output.dir=./output/

  project.properties.prop_handler={'module_name': 'ProjectTreeProperties', 'module_package': 'cheutils', }
  project.properties.data_handler={'module_name': 'DataPrepProperties', 'module_package': 'cheutils', }
  project.properties.model_handler={'module_name': 'ModelProperties', 'module_package': 'cheutils', }

  project.sqlite3.db=cheutils_sqlite.db
  project.dataset.list=[X_train.csv, X_test.csv, y_train.csv, y_test.csv]
  project.models.supported={'xgb_boost': {'module_name': 'XGBRegressor', 'module_package': 'xgboost'}, \
  'random_forest': {'module_name': 'RandomForestRegressor', 'module_package': 'sklearn.ensemble'}, \
  'lasso': {'module_name': 'Lasso', 'module_package': 'sklearn.linear_model'}, }
  model.baseline.model_option=lasso
  model.active.model_option=xgb_boost
  model.active.n_iters=200
  model.active.n_trials=10
  model.narrow_grid.scaling_factor=0.20
  model.narrow_grid.scaling_factors={'start': 0.1, 'end': 1.0, 'steps': 10}
  model.find_optimal.grid_resolution=False
  model.find_optimal.grid_resolution.with_cv=False
  model.grid_resolutions.sample={'start': 1, 'end': 21, 'step': 1}
  model.active.grid_resolution=7
  model.cross_val.num_folds=3
  model.active.n_jobs=-1
  model.cross_val.scoring=neg_mean_squared_error
  model.metric.target.objective=3.0
  model.active.random_seed=100
  model.active.trial_timeout=60
  model.hyperopt.algos={'rand.suggest': 0.05, 'tpe.suggest': 0.75, 'anneal.suggest': 0.20, }
  model.params_grid.xgb_boost={'learning_rate': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'subsample': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'min_child_weight': {'type': float, 'start': 0.1, 'end': 1.0, 'num': 10}, 'n_estimators': {'type': int, 'start': 10, 'end': 400, 'num': 10}, 'max_depth': {'type': int, 'start': 3, 'end': 17, 'num': 5}, 'colsample_bytree': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'gamma': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'reg_alpha': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, }
  model.params_grid.random_forest={'min_samples_leaf': {'type': int, 'start': 1, 'end': 60, 'num': 5}, 'max_features': {'type': int, 'start': 5, 'end': 1001, 'num': 10}, 'max_depth': {'type': int, 'start': 5, 'end': 31, 'num': 6}, 'n_estimators': {'type': int, 'start': 5, 'end': 201, 'num': 10}, 'min_samples_split': {'type': int, 'start': 2, 'end': 21, 'num': 5}, 'max_leaf_nodes': {'type': int, 'start': 5, 'end': 401, 'num': 10}, }

  model.selective_column.transformers=[{'name': 'scaler_tf', 'transformer_name': 'StandardScaler', 'transformer_package': 'sklearn.preprocessing', 'transformer_params': {}, 'columns': ['col1_label', 'col2_label']}, ]
  ```
  You import the `cheutils` module as per usual:
  ```python
  import cheutils
  ```
  The following provide access to the properties file, usually expected to be named "app-config.properties" and typically found in the project data folder or anywhere either in the project root or any other subfolder
  ```python
  APP_PROPS = cheutils.AppProperties() # this automatically search for the app-config.properties file and loads it
  ```
  During development, you may find it convenient to reload properties file changes without re-starting the VM. You can achieve that by adding the following somewhere at the top of your Jupyter notebook, for example.
  ```python
  APP_PROPS.reload() # this automatically notifies and registered properties handlers to be reloaded
  ```
  You can access any properties using various methods such as:
  ```python
  DATA_DIR = APP_PROPS.get('project.data.dir')
  ```
  You can also retrieve the path to the data folder, which is under the project root as follows:

  ```python
  cheutils.get_data_dir()  # returns the path to the project data folder, which is always interpreted relative to the project root
  APP_PROPS.get_subscriber('prop_handler').get_data_dir()  # does the same as above
  ```
  You can retrieve other properties as follows:
  ```python
  VALUES_LIST = APP_PROPS.get_list('project.dataset.list') # e.g., some.configured.list=[1, 2, 3] or ['1', '2', '3']
  VALUES_DIC = APP_PROPS.get_dic_properties('model.hyperopt.algos') # e.g., some.configured.dict={'val1': 10, 'val2': 'value'}
  LIST_OF_DICTS = APP_PROPS.get_list_properties('model.selective_column.transformers') # e.g., configured transformers in the sample properties file above
  BOL_VAL = APP_PROPS.get_bol('model.find_optimal.grid_resolution') # e.g., some.configured.bol=True
  ```
  You access the LOGGER instance by simply calling `LOGGER.debug()` in a similar way to you will when using loguru or standard logging
  ```python
  LOGGER = cheutils.LOGGER.get_logger()
  LOGGER.info('Some info you wish to log') # or debug() etc.
  ```
  You may also wish to change the logging context from the default, which is usually set to the configured project namespace property, by calling `set_prefix()` on the LOGGER instance ensures the log messages are scoped to that context thereafter - which can be helpful when reviewing the generated log file (`app-log.log`) - the default prefix is "app-log". You can set the logger prefix as follows:
  ```python
  LOGGER.set_prefix(prefix='my_project')
  ```
  The `cheutils` module currently supports any configured estimator (see, the xgb_boost example in the sample properties file for how to configure any estimator).
  You can configure the active or main estimators for your project with an entry in the app-config.properties as below, but you add your own properties as well, provided the estimator has been fully configured as in the sample properties file:
  ```
  model.active.model_option=xgb_boost # the named estimator here has already been configured with a broad set of default hyperparameters
  ```
  You can get a handle to the corresponding estimator in your code as follows:
  ```python
  estimator = cheutils.get_estimator(model_option='xgb_boost')
  ```
  Thereafter, you can do the following as well, to get a non-default instance:
  ```python
  estimator = cheutils.get_estimator(**get_params(model_option='xgb_boost'))
  ```
  You can simply fit the model as follows per usual:
  ```python
  estimator.fit(X_train, y_train)
  ```
  Given a default broad estimator hyperparameter configuration (usually in the properties file), you can generate a promising parameter grid using RandomSearchCV as in the following line. Note that, the pipeline can either be an sklearn pipeline or an estimator.
  The general idea is that, to avoid worrying about trying to figure out the optimal set of hyperparameter values for a given estimator, you can do that automatically, by
  adopting a two-step coarse-to-fine search, where you configure a broad hyperparameter space or grid based on the estimator's most important or impactful hyperparameters, and the use a random search to find a set of promising hyperparameters that
  you can use to conduct a finer hyperparameter space search using other algorithms such as bayesean optimization (e.g., hyperopt or Scikit-Optimize, etc.)
  ```python
  promising_grid = cheutils.promising_params_grid(pipeline, X_train, y_train, grid_resolution=3, prefix='baseline_model') # the prefix is not needed if not part of a model pipeline
  ```
  You can run hyperparameter optimization or tuning as follows (assuming you enabled cross-validation in your configuration or app-conf.properties - e.g., with an entry such as `model.cross_val.num_folds=3`), if using hyperopt; and if you are running Mlflow experiments and logging, you could also pass an optional mlflow_exp={'log': True, 'uri': 'http://<mlflow_tracking_server>:<port>', } in the optimization call:
  ```python
  best_estimator, best_score, best_params, cv_results = cheutils.params_optimization(pipeline, X_train, y_train, promising_params_grid=promising_grid, with_narrower_grid=True, fine_search='hyperoptcv', prefix='model_prefix')
  ```
  You can get a handle to the datasource wrapper as follows:
  ```python
  ds = DSWrapper() # it is a singleton
  ```
  You can then read a large CSV file, leveraging `dask` as follows:
  ```python
  data_df = ds.read_large_csv(path_to_data_file=os.path.join(cheutils.get_data_dir(), 'some_file.csv')) # where the data file is expected to be in the data sub folder of the project tree
  ```
  Assuming you previously defined a datasource configuration such as `ds-config.properties` somewhere in the project tree or sub folder, containing:
  `project.ds.supported={'mysql_local': {'db_driver': 'MySQL ODBC 8.1 ANSI Driver', 'drivername': 'mysql+pyodbc', 'db_server': 'localhost', 'db_port': 3306, 'db_name': 'test_db', 'username': 'test_user', 'password': 'test_password', 'direct_conn': 0, 'timeout': 0, 'verbose': True}, }`
  You could read from a configured datasource (DB) as follows:
  ```python
  ds_config = {'db_key': 'mysql_local', 'ds_namespace': 'test', 'db_table': 'some_table', 'data_file': None} # the data_file property is this dictionary MUST be set to None or left unset, if you wish to read a configured DB resource
  data_df = ds.read_from_datasource(ds_config=ds_config, chunksize=5000)
  ```
  Note that, if you call `read_from_datasource()` with `data_file` set in the `ds_config` as either an Excel or CSV then it is equivalent to calling a read CSV or Excel - where the data file is expected to be in the data sub folder of the project.
  There are transformers for dropping clipping data based on catagorical aggregate statistics such as mean or median values.
  You can add a data preprocessing transformer to your pipeline as follows:
  ```python
  date_cols = ['rental_date']
  int_cols = ['release_year', 'length', 'NC-17', 'PG', 'PG-13', 'R',
              'trailers', 'deleted_scenes', 'behind_scenes', 'commentaries', 'extra_fees']
  correlated_cols = ['rental_rate_2', 'length_2', 'amount_2']
  drop_missing = True
  clip_data = None
  exp_tf = cheutils.DataPrepTransformer(date_cols=date_cols, int_cols=int_cols, drop_missing=drop_missing, clip_data=clip_data,
                               correlated_cols=correlated_cols,
                               include_target=False,)
  data_prep_pipeline_steps = [('data_prep_step', exp_tf)]
  ```
  You can also include feature selection by adding the following to the pipeline:

  ```python
  feat_sel_tf = cheutils.FeatureSelectionTransformer(estimator=cheutils.get_estimator(model_option='xgboost'),
                                                     cheutils.AppProperties().get_subscriber(
                                                         'model_handler').get_random_seed())

  standard_pipeline_steps.append(('feat_selection_step', feat_sel_tf))
  ```
  You can also use a configured column transformer called `SelectiveColumnTransformer`. For example, if you already have configured a list of column transformers in the `app-config.properties` such as in the sample properties file above. Then you can add it to the pipeline as below.
  The `SelectiveColumnTransformer` uses the configured property to determine the transformer(s) to add to the pipeline. The above should apply any transformations to the specified columns only.
  ```python
  scaler_tf = cheutils.SelectiveColumnTransformer()
  standard_pipeline_steps.append(('scale_feats_step', scaler_tf))
  ```
  Ultimately, you may create a model pipeline and excute using steps similar to the following:

  ```python
  from cheutils import get_estimator, winsorize_it
  from sklearn.pipeline import Pipeline
  from sklearn.metrics import mean_squared_error, r2_score
  from sklearn.compose import TransformedTargetRegressor


  baseline_model = get_estimator(model_option=APP_PROPS.get('model.baseline.model_option'))
  baseline_pipeline_steps = standard_pipeline_steps.copy()
  baseline_pipeline_steps.append(('baseline_mdl', baseline_model))
  baseline_pipeline = Pipeline(steps=baseline_pipeline_steps, verbose=True)

  baseline_est = TransformedTargetRegressor(regressor=baseline_pipeline, func=winsorize_it, inverse_func=winsorize_it,
                                            check_inverse=False, )
  baseline_est.fit(X_train, y_train)
  y_train_pred = baseline_est.predict(X_train)
  mse_score = mean_squared_error(y_train, y_train_pred)
  r_squared = r2_score(y_train, y_train_pred)
  LOGGER.debug('Training baseline mse = {:.2f}'.format(mse_score))
  LOGGER.debug('Training baseline r_squared = {:.2f}'.format(r_squared))
  ```


pkgId: 9c84effa794d90bdc9c8a213258583d17e7d2d319e499225acdc5451a06789d9
name: python-cheutils
arch: src
version: 2.7.23
epoch: 0
release: 1
url: https://github.com/chewitty/cheutils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cheutils-2.7.23-1.src.rpm
checksum_type: sha256
summary:
[cell repeats an earlier one in this file: 119 characters]

description:
  A package with a set of basic reusable utilities and tools to facilitate quickly getting up and going on any machine learning project.


  - Managing properties files or project configuration, based on jproperties. The application configuration is expected to be available in a properties file named `app-config.properties`, which can be placed anywhere in the project root or any project subfolder.
  - Convenience methods such as `get_estimator()` to get a handle on any configured estimator with a specified hyperparameters dictionary, `get_params_grid()` or `get_param_defaults()` relating to obtaining model hyperparameters in the `app-config.properties` file.
  - Convenience methods for conducting hyperparameter optimization such as `params_optimization()`, `promising_params_grid()` for obtaining a set of promising hyperparameters using RandomSearchCV and a set of broadly specified or configured hyperparameters in the `app-config.properties`; a combination of `promising_params_grid()` followed by `params_optimization()` constitutes a coarse-to-fine search.
  - Convenience methods for accessing the project tree folders - e.g., `get_data_dir()` for accessing the configured data and `get_output_dir()` for the output folders, `load_dataset()` for loading, `save_excel()` and `save_csv()` for savings Excel in the project output folder and CSV respectively; you can also save any plotted figure using `save_current_fig()` (note that this must be called before `plt.show()`.
  - Convenience methods to support common programming tasks, such as renaming or tagging file names- e.g., `label(file_name, label='some_label')`) or tagging and date-stamping files (e.g., `datestamp(file_name, fmt='%Y-%m-%d')`).
  - A debug or logging, timer, and singleton decorators - for enabling logging and method timing, as well as creating singleton instances.
  - Convenience methods available via the `DSWrapper` for managing datasource configuration or properties files - e.g. `ds-config.properties` - offering a set of generic datasource access methods such as `apply_to_datasource()` to persist data to any configured datasource or `read_from_datasource()` to read data from any configured datasources.
  - A set of custom `scikit-learn` transformers for preprocessing data such as `DataPrepTransformer` which can be added to a data pipeline for pre-process dataset - e.g., handling date conversions, type casting of columns, clipping data, generating special features from rows of text strings, generating calculated features, masking columns, dropping correlated or potential data leakage columns, and generating target variables from other features as needed (separet from target encoding). A `GeospatialTransformer` for generating geohash features from latitude and longitudes; a `SelectiveFunctionTransformer` and `SelectiveColumnTransformer` for selectively transforming dataframe columns; a `DateFeaturesTransformer` for generating date-related features for feature engineering, and `FeatureSelectionTransformer` for feature selection using configured estimators such as `Lasso` or `LinearRegression`
  - A set of generic or common utilities for summarizing dataframes and others - e.g., using `summarize()` or to winsorize using `winsorize_it()`
  - A set of convenience properties handlers to accessing generic configured properties relating to the project tree, data preparation, or model development and execution such as `ProjectTreeProperties`, `DataPrepProperties`, and `ModelProperties`. These handlers offer a convenient feature for reloading properties as needed, thereby refreshing properties without having to re-start the running VM (really only useful in development). However you may access any configured properties in the usual way via the `AppProperties` object.


  You can install this module as follows:
  ```commandline
  pip install cheutils
  ```
  OPTIONAL: if you want the latest release:
  ```commandline
  pip install --upgrade cheutils
  ```

  The module supports application configuration via a properties file. As such, you can include a project configuration file - the default properties file expected is `app-config.properties`, which you can place anywhere in your project root or any project sub folder. You can also include a special properties file called `ds-config.properties` with the configuration of your data sources; this is also automatically loaded. A sample application properties file may contain entries such as the following:
  ```properties



  project.namespace=proj_namespace
  project.root.dir=./
  project.data.dir=./data/
  project.output.dir=./output/

  project.properties.prop_handler={'name': 'ProjectTreeProperties', 'package': 'cheutils', }
  project.properties.data_handler={'name': 'DataPrepProperties', 'package': 'cheutils', }
  project.properties.model_handler={'name': 'ModelProperties', 'package': 'cheutils', }

  project.sqlite3.db=proj_sqlite.db
  project.dataset.list=[X_train.csv, X_test.csv, y_train.csv, y_test.csv]



  project.models.supported={'xgb_boost': {'name': 'XGBRegressor', 'package': 'xgboost'}, \
  'random_forest': {'name': 'RandomForestRegressor', 'package': 'sklearn.ensemble'}, \
  'lasso': {'name': 'Lasso', 'package': 'sklearn.linear_model'}, }

  model.params_grid.xgb_boost={'learning_rate': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'subsample': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 10}, 'min_child_weight': {'type': float, 'start': 0.1, 'end': 1.0, 'num': 10}, 'n_estimators': {'type': int, 'start': 10, 'end': 400, 'num': 10}, 'max_depth': {'type': int, 'start': 3, 'end': 17, 'num': 5}, 'colsample_bytree': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'gamma': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, 'reg_alpha': {'type': float, 'start': 0.0, 'end': 1.0, 'num': 5}, }
  model.params_grid.random_forest={'min_samples_leaf': {'type': int, 'start': 1, 'end': 60, 'num': 5}, 'max_features': {'type': int, 'start': 5, 'end': 1001, 'num': 10}, 'max_depth': {'type': int, 'start': 5, 'end': 31, 'num': 6}, 'n_estimators': {'type': int, 'start': 5, 'end': 201, 'num': 10}, 'min_samples_split': {'type': int, 'start': 2, 'end': 21, 'num': 5}, 'max_leaf_nodes': {'type': int, 'start': 5, 'end': 401, 'num': 10}, }
  model.baseline.model_option=lasso
  model.active.model_option=xgb_boost

  project.hyperparam.searches=['hyperoptcv', 'skoptimize']
  model.active.n_iters=200
  model.active.n_trials=10
  model.narrow_grid.scaling_factor=0.20
  model.narrow_grid.scaling_factors={'start': 0.1, 'end': 1.0, 'steps': 10}
  model.find_optimal.grid_resolution=False
  model.find_optimal.grid_resolution.with_cv=False
  model.grid_resolutions.sample={'start': 1, 'end': 21, 'step': 1}
  model.active.grid_resolution=7
  model.cross_val.num_folds=3
  model.active.n_jobs=-1
  model.cross_val.scoring=neg_mean_squared_error
  model.active.random_seed=100
  model.active.trial_timeout=60
  model.hyperopt.algos={'rand.suggest': 0.05, 'tpe.suggest': 0.75, 'anneal.suggest': 0.20, }


  model.selective_column.transformers=[{'pipeline_name': 'scalers_pipeline', 'transformers': [{'name': 'scaler_tf', 'module': 'StandardScaler', 'package': 'sklearn.preprocessing', 'params': None, }, ], 'columns': ['col1_label', 'col2_label']}, ]
  ```
  A sample datasource configuration properties file may contain something like the following:
  ```properties




  project.ds.supported=[{'mysql_local': {'db_driver': 'MySQL ODBC 8.1 ANSI Driver', 'drivername': 'mysql+pyodbc', 'db_server': 'host.domain.com', 'db_port': 3306, 'db_name': 'mysql_db_name', 'username': 'db_username', 'password': 'db_user_passwd', 'direct_conn': 0, 'timeout': 0, 'verbose': True, 'encoding': 'utf8', }, }, ]

  db.rel_cols.db_namespace.some_table_name=['some_prim_key', 'name', 'iso_2code', 'iso_3code', 'gps_lat', 'gps_lon', 'is_active']
  db.unique_key.db_namespace.some_table_name=['some_prim_key']
  db.to_tables.replace.db_namespace=[some_table_name=False, ]
  db.to_table.delete.db_namespace.some_table_name=[some_prim_key=120]
  ```
  You import the `cheutils` module as per usual:
  ```python
  from cheutils import AppProperties, get_data_dir



  APP_PROPS = AppProperties() # this automatically search for the app-config.properties file and loads it



  APP_PROPS.reload() # this automatically notifies and registered properties handlers to be reloaded


  data_dir = APP_PROPS.get('project.data.dir')


  data_dir = get_data_dir()  # also returns the path to the project data folder, which is always interpreted relative to the project root


  datasets = APP_PROPS.get_list('project.dataset.list') # e.g., some.configured.list=[1, 2, 3] or ['1', '2', '3']; see dataset configured in app-config.properties
  hyperopt_algos = APP_PROPS.get_dic_properties('model.hyperopt.algos') # e.g., some.configured.dict={'val1': 10, 'val2': 'value'}
  sel_transformers = APP_PROPS.get_list_properties('model.selective_column.transformers') # e.g., configured pipelines of transformers in the sample properties file above
  find_opt_grid_res = APP_PROPS.get_bol('model.find_optimal.grid_resolution') # e.g., some.configured.bol=True
  ```
  You access the LOGGER instance and use it in a similar way to you will when using a logging module like `loguru` or standard logging
  ```python
  from cheutils import LoguruWrapper

  LOGGER = LoguruWrapper().get_logger()



  LoguruWrapper().set_prefix(prefix='some_namespace')
  some_val = 100
  LOGGER.info('Some info you wish to log some value: {}', some_val) # or debug() etc.
  ```

  The `cheutils` module currently supports any configured estimator (see, the xgb_boost example in the sample properties file for how to configure any estimator).
  You can configure the active or main estimators for your project with an entry in the app-config.properties as below, but you add your own properties as well,
  provided the estimator has been fully configured as in the sample application properties file:
  ```python
  from cheutils import get_estimator, get_params_grid, AppProperties, load_dataset


  estimator = get_estimator(model_option='xgb_boost') # the appropriate porperty can be seen in the sample app-config.properties


  estimator = get_estimator(**get_params_grid(model_option='xgb_boost'))

  datasets = AppProperties().get_list('project.dataset.list')
  X_train, y_train, X_val, y_val, X_test, y_test = [load_dataset(file_name=file_name, is_csv=True) for file_name in datasets]
  estimator.fit(X_train, y_train)
  ```
  Given a default broad estimator hyperparameter configuration (usually in the properties file), you can generate a promising parameter
  grid using RandomSearchCV as in the following line. Note that, the pipeline can either be an sklearn pipeline or an estimator.
  The general idea is that, to avoid worrying about trying to figure out the optimal set of hyperparameter values for a given estimator, you can do that automatically, by
  adopting a two-step coarse-to-fine search, where you configure a broad hyperparameter space or grid based on the estimator's most important or impactful hyperparameters, and the use a random search to find a set of promising hyperparameters that
  you can use to conduct a finer hyperparameter space search using other algorithms such as Bayesian optimization (e.g., hyperopt or Scikit-Optimize, etc.)
  ```python
  from cheutils import promising_params_grid, params_optimization, AppProperties, load_dataset
  from sklearn.pipeline import Pipeline
  datasets = AppProperties().get_list('project.dataset.list') # AppProperties is a singleton
  X_train, y_train, X_val, y_val, X_test, y_test = [load_dataset(file_name=file_name, is_csv=False) for file_name in datasets]
  pipeline = Pipeline(steps=['some previously defined pipeline steps'])
  promising_grid = promising_params_grid(pipeline, X_train, y_train, grid_resolution=3, prefix='baseline_model') # the prefix is not needed if not part of a model pipeline


  best_estimator, best_score, best_params, cv_results = params_optimization(pipeline, X_train, y_train, promising_params_grid=promising_grid, with_narrower_grid=True, fine_search='hyperoptcv', prefix='model_prefix')

  mlflow_exp={'log': True, 'uri': 'http://<mlflow_tracking_server>:<port>', } # ensures mlflow logging is done as well and you should also have the appropriate mlflow server instance running
  best_estimator, best_score, best_params, cv_results = params_optimization(pipeline, X_train, y_train, promising_params_grid=promising_grid, with_narrower_grid=True, fine_search='hyperoptcv', prefix='model_prefix', mlflow_exp=mlflow_exp)
  ```
  If you have also configured some datasources (i.e., using the `ds-config.properties`), you can get a handle to the datasource wrapper as follows:
  ```python
  import os
  from cheutils import DSWrapper, get_data_dir
  ds = DSWrapper() # it is a singleton

  data_df = ds.read_large_csv(path_to_data_file=os.path.join(get_data_dir(), 'some_large_file.csv')) # where the data file is expected to be in the data sub folder of the project tree







  ds_params = {'db_key': 'mysql_local', 'ds_namespace': 'test', 'db_table': 'some_table', 'data_file': None}
  data_df = ds.read_from_datasource(ds_config=ds_params, chunksize=5000)
  ```
  The `cheutils` module comes with custom transformers for some preprocessing - e.g., some basic data cleaning and formatting, handling date conversions, type casting of columns, clipping data, generating special features, calculating new features, masking columns, dropping correlated and potential leakage columns, and generating target variables if needed.

  You can add a data preprocessing transformer to your pipeline as follows:
  ```python
  from cheutils import DataPrepTransformer
  date_cols = ['rental_date']
  int_cols = ['release_year', 'length', 'NC-17', 'PG', 'PG-13', 'R',
              'trailers', 'deleted_scenes', 'behind_scenes', 'commentaries', 'extra_fees']
  correlated_cols = ['rental_rate_2', 'length_2', 'amount_2']
  drop_missing = True # drop rows with missing data
  clip_data = None # no data clipping; but you could clip outliers based on category aggregates with something like clip_data = {'rel_cols': ['col1', 'col2'], 'filterby': 'cat_col', }
  exp_tf = DataPrepTransformer(date_cols=date_cols,
                               int_cols=int_cols,
                               drop_missing=drop_missing,
                               clip_data=clip_data,
                               correlated_cols=correlated_cols,)
  data_prep_pipeline_steps = [('data_prep_step', exp_tf)] # this can be added to a model pipeline
  ```
  You can also include feature selection by adding the following to the pipeline:
  ```python
  from cheutils import FeatureSelectionTransformer, get_estimator, AppProperties, ModelProperties, SelectiveColumnTransformer

  standard_pipeline_steps = ['some previously defined pipeline steps']
  model_handler: ModelProperties = AppProperties().get_subscriber('model_handler')
  feat_sel_tf = FeatureSelectionTransformer(estimator=get_estimator(model_option='xgboost'),
                                            random_state=model_handler.get_random_seed())

  standard_pipeline_steps.append(('feat_selection_step', feat_sel_tf))





  scaler_tf = SelectiveColumnTransformer()
  standard_pipeline_steps.append(('scale_feats_step', scaler_tf))
  ```
  Ultimately, you may create a model pipeline and execute using steps similar to the following:

  ```python
  from sklearn.pipeline import Pipeline
  from sklearn.metrics import mean_squared_error, r2_score
  from sklearn.compose import TransformedTargetRegressor
  from cheutils import get_estimator, winsorize_it, AppProperties, LoguruWrapper

  LOGGER = LoguruWrapper().get_logger()

  standard_pipeline_steps = ['some previosly defined pipeline steps']

  baseline_model = get_estimator(model_option=AppProperties().get('model.baseline.model_option'))
  baseline_pipeline_steps = standard_pipeline_steps.copy()
  baseline_pipeline_steps.append(('baseline_mdl', baseline_model))
  baseline_pipeline = Pipeline(steps=baseline_pipeline_steps, verbose=True)


  baseline_est = TransformedTargetRegressor(regressor=baseline_pipeline,
                                            func=winsorize_it,
                                            inverse_func=winsorize_it,
                                            check_inverse=False, )
  X_train = None # ignore the None value - assume previously defined and gone through an appropriate train_test_split
  y_train = None # ditto what is said on X_train above
  baseline_est.fit(X_train, y_train)
  y_train_pred = baseline_est.predict(X_train)
  mse_score = mean_squared_error(y_train, y_train_pred)
  r_squared = r2_score(y_train, y_train_pred)
  LOGGER.debug('Training baseline mse = {:.2f}'.format(mse_score))
  LOGGER.debug('Training baseline r_squared = {:.2f}'.format(r_squared))
  ```



  Contributions are welcomed from contributors, all experience levels, anyone looking to collaborate to improve the package or to be helpful.
  We rely on a scikit-learn's [`Development Guide`](https://scikit-learn.org/stable/developers/index.html), which contains lots of best practices and detailed information about contributing code, documentation, tests, and more.


  You can check the latest sources with the command:
  ```commandline
  git clone https://github.com/chewitty/cheutils.git
  ```

  - Author email: ferdinand.che@gmail.com



  If you use `cheutils` in a media/research publication, we would appreciate citations to this repository.


pkgId: 5e6c56327a62c01de48563e88cf677b2449b5ca57af684618096c21fe1c95290
name: python-chevron
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Mustache templating language renderer
url: https://github.com/noahmorrison/chevron
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chevron-0.14.0-1.src.rpm
checksum_type: sha256
description:
  I'm glad you asked!

  Chevron runs in less than half the time of [pystache](http://github.com/defunkt/pystache) (Which is not even up to date on the spec).
  And in about 70% the time of [Stache](https://github.com/hyperturtle/Stache) (A 'trimmed' version of mustache, also not spec compliant).

  The flake8 command is run by [travis](https://travis-ci.org/noahmorrison/chevron) to ensure consistency.

  Chevron passes all the unittests provided by the [spec](https://github.com/mustache/spec) (in every version listed below).
  If you find a test that chevron does not pass, please [report it.](https://github.com/noahmorrison/chevron/issues/new)

  Python 2.6, 2.7, 3.2, 3.3, 3.4, 3.5, and 3.6 are all tested by travis.


pkgId: c128c33fe74b3f455bf322a682ae7c3e72051140f23e68481c7791c332c061d3
name: python-chevron-blue
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A Python implementation of the mustache template language
url: https://pypi.org/project/chevron-blue/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chevron-blue-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A Python implementation of the [mustache templating language](http://mustache.github.io).



  This library is a fork of [chevron](https://github.com/noahmorrison/chevron) authored by [Noah Morrison](https://github.com/noahmorrison).

  The following changes have been made:

  - Switched to a modern build system (`poetry`)
  - Switched to GitHub Actions for CI
  - Used Ruff for linting and formatting
  - Dropped support for Python 2
  - Verified support for Python 3.7 - 3.12
  - Fixed bug where variables could be incorrectly resolved from other scopes (see [#3](https://github.com/zanieb/chevron-blue/pull/3))
  - Added global `--no-escape` option to disable HTML escaping (see [#4](https://github.com/zanieb/chevron-blue/pull/4))


pkgId: b4aa160aa69e2bec29cc31cbd254878cc5fed4fbd6e634a26cebfc5b091d0e2d
name: python-chevron2021
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: Mustache templating language renderer
url: https://github.com/noahmorrison/chevron
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chevron2021-0.0.2-1.src.rpm
checksum_type: sha256
description:
  [Clone](https://github.com/alexberazouski/chevron) of [original chevron](https://github.com/noahmorrison/chevron) (all credits go there).
  Clone was created for a single purpose of releasing a package with the latest merged changes in the original repo.
  And to let other people know how to install it.


  See the [original repo](https://github.com/noahmorrison/chevron)


pkgId: 46d5d679f5a492a21987fec73c6b950b8d07588d96ba80311c34e36342701437
name: python-chewBBACA
arch: src
version: 3.3.10
epoch: 0
release: 1
summary: A complete suite for gene-by-gene schema creation and strain identification.
url: https://pypi.org/project/chewBBACA/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chewBBACA-3.3.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/badge/Install%20with-PyPI-blue)](https://pypi.org/project/chewBBACA/#description)
  [![Bioconda](https://img.shields.io/badge/Install%20with-bioconda-green)](https://anaconda.org/bioconda/chewbbaca)
  [![Conda](https://img.shields.io/conda/dn/bioconda/chewbbaca?color=green)](https://anaconda.org/bioconda/chewbbaca)
  [![chewBBACA](https://github.com/B-UMMI/chewBBACA/workflows/chewbbaca/badge.svg)](https://github.com/B-UMMI/chewBBACA/actions?query=workflow%3Achewbbaca)
  [![Documentation Status](https://readthedocs.org/projects/chewbbaca/badge/?version=latest)](https://chewbbaca.readthedocs.io/en/latest/?badge=latest)
  [![License: GPL v3](https://img.shields.io/github/license/B-UMMI/chewBBACA)](https://www.gnu.org/licenses/gpl-3.0)
  [![DOI:10.1099/mgen.0.000166](https://img.shields.io/badge/DOI-10.1099%2Fmgen.0.000166-blue)](http://mgen.microbiologyresearch.org/content/journal/mgen/10.1099/mgen.0.000166)



  **chewBBACA** is a software suite for the creation and evaluation of core genome and whole genome MultiLocus Sequence
  Typing (cg/wgMLST) schemas and results. The "BBACA" stands for "BSR-Based Allele Calling Algorithm". BSR stands for
  BLAST Score Ratio as proposed by [Rasko DA et al.](http://bmcbioinformatics.biomedcentral.com/articles/10.1186/1471-2105-6-2). The "chew" part adds extra coolness to the name and could be thought of as "Comprehensive and Highly Efficient Workflow". chewBBACA allows to define the target loci in a schema based on multiple genomes (e.g. define target loci based on the distinct loci identified in a dataset of high-quality genomes for a species or lineage of interest) and performs allele calling to determine the allelic profiles of bacterial strains, easily scaling to thousands of genomes with modest computational resources. chewBBACA includes functionalities to annotate the schema loci, compute the set of loci that constitute the core genome for a given dataset, and generate interactive reports for schema and allele calling results evaluation to enable an intuitive analysis of the results in surveillance and outbreak detection settings or population studies. Pre-defined cg/wgMLST schemas can be downloaded from [Chewie-NS ](https://chewbbaca.online/) or adapted from other cg/wgMLST platforms.







  - Fixed issue in the UniprotFinder module related to TrEMBL and Swiss-Prot IDs being parsed by BLAST when the `qacc` and `sacc` format specifiers were used with `-outfmt 6`. Switched back to the `qseqid` and `sseqid` format specifiers.

  Check our [Changelog](https://github.com/B-UMMI/chewBBACA/blob/master/CHANGELOG.md) to learn about the latest changes.



  When using chewBBACA, please use the following citation:

  > Silva M, Machado MP, Silva DN, Rossi M, Moran-Gilad J, Santos S, Ramirez M, Carriço JA. 2018. chewBBACA: A complete suite for gene-by-gene schema creation and strain identification. Microb Genom 4:000166. [doi:10.1099/mgen.0.000166](doi:10.1099/mgen.0.000166)

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


pkgId: 275f64029dc3a7b46f4771740b6533a44e932c14eb2862b36577f432c832c7b4
name: python-chex
arch: src
version: 0.1.86
epoch: 0
release: 1
summary: Chex: Testing made fun, in JAX!
url: https://github.com/deepmind/chex
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chex-0.1.86-1.src.rpm
checksum_type: sha256
description:
  ![CI status](https://github.com/deepmind/chex/workflows/ci/badge.svg)
  ![docs](https://readthedocs.org/projects/chex/badge/?version=latest)
  ![pypi](https://img.shields.io/pypi/v/chex)

  Chex is a library of utilities for helping to write reliable JAX code.

  This includes utils to help:

  * Instrument your code (e.g. assertions, warnings)
  * Debug (e.g. transforming `pmaps` in `vmaps` within a context manager).
  * Test JAX code across many `variants` (e.g. jitted vs non-jitted).



  You can install the latest released version of Chex from PyPI via:

  ```sh
  pip install chex
  ```

  or you can install the latest development version from GitHub:

  ```sh
  pip install git+https://github.com/deepmind/chex.git
  ```





  Dataclasses are a popular construct introduced by Python 3.7 to allow to
  easily specify typed data structures with minimal boilerplate code. They are
  not, however, compatible with JAX and
  [dm-tree](https://github.com/deepmind/tree) out of the box.

  In Chex we provide a JAX-friendly dataclass implementation reusing python [dataclasses](https://docs.python.org/3/library/dataclasses.html#module-dataclasses).

  Chex implementation of `dataclass` registers dataclasses as internal [_PyTree_
  nodes](https://jax.readthedocs.io/en/latest/pytrees.html) to ensure
  compatibility with JAX data structures.

  In addition, we provide a class wrapper that exposes dataclasses as
  `collections.Mapping` descendants which allows to process them
  (e.g. (un-)flatten) in `dm-tree` methods as usual Python dictionaries.
  See [`@mappable_dataclass`](https://github.com/deepmind/chex/blob/master/chex/_src/dataclass.py#L27)
  docstring for more details.

  Example:

  ```python
  @chex.dataclass
  class Parameters:
    x: chex.ArrayDevice
    y: chex.ArrayDevice

  parameters = Parameters(
      x=jnp.ones((2, 2)),
      y=jnp.ones((1, 2)),
  )


  jax.tree_util.tree_map(lambda x: 2.0 * x, parameters)


  tree.flatten(parameters)
  ```

  **NOTE**: Unlike standard Python 3.7 dataclasses, Chex
  dataclasses cannot be constructed using positional arguments. They support
  construction arguments provided in the same format as the Python dict
  constructor. Dataclasses can be converted to tuples with the `from_tuple` and
  `to_tuple` methods if necessary.

  ```python
  parameters = Parameters(
      jnp.ones((2, 2)),
      jnp.ones((1, 2)),
  )

  ```



  One limitation of PyType annotations for JAX is that they do not support the
  specification of `DeviceArray` ranks, shapes or dtypes. Chex includes a number
  of functions that allow flexible and concise specification of these properties.

  E.g. suppose you want to ensure that all tensors `t1`, `t2`, `t3` have the same
  shape, and that tensors `t4`, `t5` have rank `2` and (`3` or `4`), respectively.

  ```python
  chex.assert_equal_shape([t1, t2, t3])
  chex.assert_rank([t4, t5], [2, {3, 4}])
  ```

  More examples:

  ```python
  from chex import assert_shape, assert_rank, ...

  assert_shape(x, (2, 3))                # x has shape (2, 3)
  assert_shape([x, y], [(), (2,3)])      # x is scalar and y has shape (2, 3)

  assert_rank(x, 0)                      # x is scalar
  assert_rank([x, y], [0, 2])            # x is scalar and y is a rank-2 array
  assert_rank([x, y], {0, 2})            # x and y are scalar OR rank-2 arrays

  assert_type(x, int)                    # x has type `int` (x can be an array)
  assert_type([x, y], [int, float])      # x has type `int` and y has type `float`

  assert_equal_shape([x, y, z])          # x, y, and z have equal shapes

  assert_trees_all_close(tree_x, tree_y) # values and structure of trees match
  assert_tree_all_finite(tree_x)         # all tree_x leaves are finite

  assert_devices_available(2, 'gpu')     # 2 GPUs available
  assert_tpu_available()                 # at least 1 TPU available

  assert_numerical_grads(f, (x, y), j)   # f^{(j)}(x, y) matches numerical grads
  ```

  See `asserts.py`
  [documentation](https://chex.readthedocs.io/en/latest/api.html#assertions) to
  find all supported assertions.

  If you cannot find a specific assertion, please consider making a pull request
  or openning an issue on
  [the bug tracker](https://github.com/deepmind/chex/issues).



  All chex assertions support the following optional kwargs for manipulating the
  emitted exception messages:

  * `custom_message`: A string to include into the emitted exception messages.
  * `include_default_message`: Whether to include the default Chex message into
    the emitted exception messages.
  * `exception_type`: An exception type to use. `AssertionError` by default.

  For example, the following code:

  ```python
  dataset = load_dataset()
  params = init_params()
  for i in range(num_steps):
    params = update_params(params, dataset.sample())
    chex.assert_tree_all_finite(params,
                                custom_message=f'Failed at iteration {i}.',
                                exception_type=ValueError)
  ```

  will raise a `ValueError` that includes a step number when `params` get polluted
  with `NaNs` or `None`s.



  Chex divides all assertions into 2 classes: ***static*** and ***value***
  assertions.

  1.  ***static*** assertions use anything except concrete values of tensors.
      Examples: `assert_shape`, `assert_trees_all_equal_dtypes`,
      `assert_max_traces`.

  2.  ***value*** assertions require access to tensor values, which are not
      available during JAX tracing (see
      [HowJAX primitives work](https://jax.readthedocs.io/en/latest/notebooks/How_JAX_primitives_work.html)),
      thus such assertion need special treatment in a *jitted* code.

  To enable value assertions in a jitted function, it can be decorated with
  `chex.chexify()` wrapper. Example:

  ```python
    @chex.chexify
    @jax.jit
    def logp1_abs_safe(x: chex.Array) -> chex.Array:
      chex.assert_tree_all_finite(x)
      return jnp.log(jnp.abs(x) + 1)

    logp1_abs_safe(jnp.ones(2))  # OK
    logp1_abs_safe(jnp.array([jnp.nan, 3]))  # FAILS (in async mode)

    
    
    logp1_abs_safe.wait_checks()  # Wait for the (async) computation to complete.
  ```

  See
  [this docstring](https://chex.readthedocs.io/en/latest/api.html#chex.chexify)
  for more detail on `chex.chexify()`.



  JAX re-traces JIT'ted function every time the structure of passed arguments
  changes. Often this behavior is inadvertent and leads to a significant
  performance drop which is hard to debug. [@chex.assert_max_traces](https://github.com/deepmind/chex/blob/master/chex/_src/asserts.py#L44)
  decorator asserts that the function is not re-traced more than `n` times during
  program execution.

  Global trace counter can be cleared by calling
  `chex.clear_trace_counter()`. This function be used to isolate unittests relying
  on `@chex.assert_max_traces`.

  Examples:

  ```python
    @jax.jit
    @chex.assert_max_traces(n=1)
    def fn_sum_jitted(x, y):
      return x + y

    fn_sum_jitted(jnp.zeros(3), jnp.zeros(3))  # tracing for the 1st time - OK
    fn_sum_jitted(jnp.zeros([6, 7]), jnp.zeros([6, 7]))  # AssertionError!
  ```

  Can be used with `jax.pmap()` as well:

  ```python
    def fn_sub(x, y):
      return x - y

    fn_sub_pmapped = jax.pmap(chex.assert_max_traces(fn_sub, n=10))
  ```

  See
  [HowJAX primitives work](https://jax.readthedocs.io/en/latest/notebooks/How_JAX_primitives_work.html)
  section for more information about tracing.



  In addition to hard assertions Chex also offers utilities to add common
  warnings, such as specific types of deprecation warnings.



  JAX relies extensively on code transformation and compilation, meaning that it
  can be hard to ensure that code is properly tested. For instance, just testing a
  python function using JAX code will not cover the actual code path that is
  executed when jitted, and that path will also differ whether the code is jitted
  for CPU, GPU, or TPU. This has been a source of obscure and hard to catch bugs
  where XLA changes would lead to undesirable behaviours that however only
  manifest in one specific code transformation.

  Variants make it easy to ensure that unit tests cover different ‘variations’ of
  a function, by providing a simple decorator that can be used to repeat any test
  under all (or a subset) of the relevant code transformations.

  E.g. suppose you want to test the output of a function `fn` with or without jit.
  You can use `chex.variants` to run the test with both the jitted and non-jitted
  version of the function by simply decorating a test method with
  `@chex.variants`, and then using `self.variant(fn)` in place of `fn` in the body
  of the test.

  ```python
  def fn(x, y):
    return x + y
  ...

  class ExampleTest(chex.TestCase):

    @chex.variants(with_jit=True, without_jit=True)
    def test(self):
      var_fn = self.variant(fn)
      self.assertEqual(fn(1, 2), 3)
      self.assertEqual(var_fn(1, 2), fn(1, 2))
  ```

  If you define the function in the test method, you may also use `self.variant`
  as a decorator in the function definition. For example:

  ```python
  class ExampleTest(chex.TestCase):

    @chex.variants(with_jit=True, without_jit=True)
    def test(self):
      @self.variant
      def var_fn(x, y):
         return x + y

      self.assertEqual(var_fn(1, 2), 3)
  ```

  Example of parameterized test:

  ```python
  from absl.testing import parameterized




  class ExampleParameterizedTest(parameterized.TestCase):

    @chex.variants(with_jit=True, without_jit=True)
    @parameterized.named_parameters(
        ('case_positive', 1, 2, 3),
        ('case_negative', -1, -2, -3),
    )
    def test(self, arg_1, arg_2, expected):
      @self.variant
      def var_fn(x, y):
         return x + y

      self.assertEqual(var_fn(arg_1, arg_2), expected)
  ```

  Chex currently supports the following variants:

  * `with_jit` -- applies `jax.jit()` transformation to the function.
  * `without_jit` -- uses the function as is, i.e. identity transformation.
  * `with_device` -- places all arguments (except specified in `ignore_argnums`
     argument) into device memory before applying the function.
  * `without_device` -- places all arguments in RAM before applying the function.
  * `with_pmap` -- applies `jax.pmap()` transformation to the function (see notes below).

  See documentation in [variants.py](https://github.com/deepmind/chex/blob/master/chex/_src/variants.py) for more details on the supported variants.
  More examples can be found in [variants_test.py](https://github.com/deepmind/chex/blob/master/chex/_src/variants_test.py).



  * Test classes that use `@chex.variants` must inherit from
  `chex.TestCase` (or any other base class that unrolls tests generators
  within `TestCase`, e.g. `absl.testing.parameterized.TestCase`).

  * **[`jax.vmap`]** All variants can be applied to a vmapped function;
  please see an example in [variants_test.py](https://github.com/deepmind/chex/blob/master/chex/_src/variants_test.py) (`test_vmapped_fn_named_params` and
  `test_pmap_vmapped_fn`).

  * **[`@chex.all_variants`]** You can get all supported variants
  by using the decorator `@chex.all_variants`.

  * **[`with_pmap` variant]** `jax.pmap(fn)`
  ([doc](https://jax.readthedocs.io/en/latest/jax.html#jax.pmap)) performs
  parallel map of `fn` onto multiple devices. Since most tests run in a
  single-device environment (i.e. having access to a single CPU or GPU), in which
  case `jax.pmap` is a functional equivalent to `jax.jit`, ` with_pmap` variant is
  skipped by default (although it works fine with a single device). Below we
  describe  a way to properly test `fn` if it is supposed to be used in
  multi-device environments (TPUs or multiple CPUs/GPUs). To disable skipping
  `with_pmap` variants in case of a single device, add
  `--chex_skip_pmap_variant_if_single_device=false` to your test command.



  Debugging in JAX is made more difficult by code transformations such as `jit`
  and `pmap`, which introduce optimizations that make code hard to inspect and
  trace. It can also be difficult to disable those transformations during
  debugging as they can be called at several places in the underlying
  code. Chex provides tools to globally replace `jax.jit` with a no-op
  transformation and `jax.pmap` with a (non-parallel) `jax.vmap`, in order to more
  easily debug code in a single-device context.

  For example, you can use Chex to fake `pmap` and have it replaced with a `vmap`.
  This can be achieved by wrapping your code with a context manager:

  ```python
  with chex.fake_pmap():
    @jax.pmap
    def fn(inputs):
      ...

    
    fn(inputs)
  ```

  The same functionality can also be invoked with `start` and `stop`:

  ```python
  fake_pmap = chex.fake_pmap()
  fake_pmap.start()
  ... your jax code ...
  fake_pmap.stop()
  ```

  In addition, you can fake a real multi-device test environment with a
  multi-threaded CPU. See section **Faking multi-device test environments** for
  more details.

  See documentation in [fake.py](https://github.com/deepmind/chex/blob/master/chex/_src/fake.py) and examples in [fake_test.py](https://github.com/deepmind/chex/blob/master/chex/_src/fake_test.py) for more details.



  In situations where you do not have easy access to multiple devices, you can
  still test parallel computation using single-device multi-threading.

  In particular, one can force XLA to use a single CPU's threads as separate
  devices, i.e. to fake a real multi-device environment with a multi-threaded one.
  These two options are theoretically equivalent from XLA perspective because they
  expose the same interface and use identical abstractions.

  Chex has a flag `chex_n_cpu_devices` that specifies a number of CPU threads to
  use as XLA devices.

  To set up a multi-threaded XLA environment for `absl` tests, define
  `setUpModule` function in your test module:

  ```python
  def setUpModule():
    chex.set_n_cpu_devices()
  ```

  Now you can launch your test with `python test.py --chex_n_cpu_devices=N` to run
  it in multi-device regime. Note that **all** tests within a module will have an
  access to `N` devices.

  More examples can be found in [variants_test.py](https://github.com/deepmind/chex/blob/master/chex/_src/variants_test.py), [fake_test.py](https://github.com/deepmind/chex/blob/master/chex/_src/fake_test.py) and [fake_set_n_cpu_devices_test.py](https://github.com/deepmind/chex/blob/master/chex/_src/fake_set_n_cpu_devices_test.py).



  Chex comes with a small utility that allows you to package a collection of
  dimension sizes into a single object. The basic idea is:

  ```python
  dims = chex.Dimensions(B=batch_size, T=sequence_len, E=embedding_dim)
  ...
  chex.assert_shape(arr, dims['BTE'])
  ```

  String lookups are translated integer tuples. For instance, let's say
  `batch_size == 3`, `sequence_len = 5` and `embedding_dim = 7`, then

  ```python
  dims['BTE'] == (3, 5, 7)
  dims['B'] == (3,)
  dims['TTBEE'] == (5, 5, 3, 7, 7)
  ...
  ```

  You can also assign dimension sizes dynamically as follows:

  ```python
  dims['XY'] = some_matrix.shape
  dims.Z = 13
  ```

  For more examples, see [chex.Dimensions](https://chex.readthedocs.io/en/latest/api.html#chex.Dimensions)
  documentation.



  This repository is part of the [DeepMind JAX Ecosystem], to cite Chex please use
  the [DeepMind JAX Ecosystem citation].

  [DeepMind JAX Ecosystem]: https://deepmind.com/blog/article/using-jax-to-accelerate-our-research "DeepMind JAX Ecosystem"
  [DeepMind JAX Ecosystem citation]: https://github.com/deepmind/jax/blob/main/deepmind2020jax.txt "Citation"


pkgId: e1b77c809b7748fe8d12b4a36c6ca6b89c935601167a1b48bac347b5b1f227c9
name: python-chia
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: Concept Hierarchies for Incremental and Active Learning
url: https://github.com/cabrust/chia
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chia-2.5.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/chia)
  ![PyPI - License](https://img.shields.io/pypi/l/chia)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chia)
  ![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/cabrust/chia)
  ![codecov](https://codecov.io/gh/cabrust/chia/branch/main/graph/badge.svg)

  CHIA implements methods centered around hierarchical classification in a lifelong learning environment.
  It forms the basis for some of the experiments and tools developed at [Computer Vision Group Jena](http://www.inf-cv.uni-jena.de/).
  Development is continued at the [DLR Institute of Data Science](https://www.dlr.de/dw/en/desktopdefault.aspx/tabid-12192/21400_read-49437/)

  **Methods**\
  CHIA implements:
   * **One-Hot Softmax Classifier** as a baseline.
   * **Probabilistic Hierarchical Classifier** Brust, C. A., & Denzler, J. (2019). *Integrating domain knowledge: using hierarchies to improve deep classifiers*. In Asian Conference on Pattern Recognition (ACPR)
   * **CHILLAX** Brust, C. A., Barz, B., & Denzler, J. (2021). *Making Every Label Count: Handling Semantic Imprecision by Integrating Domain Knowledge*. In International Conference on Pattern Recognition (ICPR).
   * **Self-Supervised CHILLAX** Brust, C. A., Barz, B., & Denzler, J. (2022). *Self-Supervised Learning from Semantically Imprecise Data*. In Computer Vision Theory and Applications (VISAPP)
   * **Semantic Label Sharing** Fergus, R., Bernal, H., Weiss, Y., & Torralba, A. (2010). *Semantic label sharing for learning with many categories*. In European Conference on Computer Vision (ECCV).

  **Datasets**\
  CHIA has integrated support including hierarchies for a number of popular datasets. See [here](docs/architecture.md#dataset) for a complete list.



  CHIA is available on PyPI. To install, simply run:
  ```bash
  pip install chia
  ```
  or clone this repository, and run:
  ```bash
  pip install -e .
  ```

  To run the [example experiment](examples/experiment.py) which makes sure that everything works, use the following command:
  ```bash
  python examples/experiment.py examples/configuration.json
  ```
  After a few minutes, the last lines of output should look like this:
  ```text
  [SHUTDOWN] [Experiment] Successful: True
  ```


  The following articles explain more about CHIA:
   * [Architecture](docs/architecture.md) explains the overall construction. It also includes reference descriptions of most classes.
   * [Configuration](docs/configuration.md) describes how experiments and CHIA itself are configured.
   * [Using your own dataset](docs/dataset.md) explains our JSON format for adding your own data.


  If you use CHIA for your research, kindly cite:
  > Brust, C. A., & Denzler, J. (2019). Integrating domain knowledge: using hierarchies to improve deep classifiers. In Asian Conference on Pattern Recognition. Springer, Cham.

  You can refer to the following BibTeX:
  ```bibtex
  @inproceedings{Brust2019IDK,
  author = {Clemens-Alexander Brust and Joachim Denzler},
  booktitle = {Asian Conference on Pattern Recognition (ACPR)},
  title = {Integrating Domain Knowledge: Using Hierarchies to Improve Deep Classifiers},
  year = {2019},
  doi = {10.1007/978-3-030-41404-7_1}
  }
  ```


pkgId: f045f253f3c91cb8827b5c4d9e4e37e1a48191f6a0f62109bfe00b3186f25c3f
name: python-chia-blockchain
arch: src
version: 2.4.4
epoch: 0
release: 1
summary: Chia blockchain full node, farmer, timelord, and wallet.
url: https://chia.net/
rpm_license: Apache License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chia-blockchain-2.4.4-1.src.rpm
checksum_type: sha256
description:
  [![Chia Network logo][logo-chia]][link-chia]

  | Releases                                                                                                                                        | Repo Stats                                                                                                                                                                                                           | Socials                                                                                                                                                                                   |
  | ----------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | [![Latest Release][badge-release]][link-latest] <br /> [![Latest RC][badge-rc]][link-release] <br /> [![Latest Beta][badge-beta]][link-release] | [![Coverage][badge-coverage]][link-coverage] <br /> [![Downloads][badge-downloads]][link-downloads] <br /> [![Commits][badge-commits]][link-commits] <br /> [![Contributers][badge-contributers]][link-contributers] | [![Discord][badge-discord]][link-discord] <br /> [![YouTube][badge-youtube]][link-youtube] <br /> [![Reddit][badge-reddit]][link-reddit] <br /> [![Twitter][badge-twitter]][link-twitter] |

  Chia is a modern cryptocurrency built from scratch, designed to be efficient, decentralized, and secure. Here are some of the features and benefits:

  - [Proof of space and time][link-consensus] based consensus which allows anyone to farm with commodity hardware
  - Very easy to use full node and farmer GUI and cli (thousands of nodes active on mainnet)
  - [Chia seeder][link-seeder], which maintains a list of reliable nodes within the Chia network via a built-in DNS server.
  - Simplified UTXO based transaction model, with small on-chain state
  - Lisp-style Turing-complete functional [programming language][link-chialisp] for money related use cases
  - BLS keys and aggregate signatures (only one signature per block)
  - [Pooling protocol][link-pool] that allows farmers to have control of making blocks
  - Support for light clients with fast, objective syncing
  - A growing community of farmers and developers around the world

  Please check out the [Chia website][link-chia], the [Intro to Chia][link-intro], and [FAQ][link-faq] for information on this project.

  Python 3.8.1+ is required. Make sure your default python version is >=3.8.1 by typing `python3`.

  If you are behind a NAT, it can be difficult for peers outside your subnet to reach you when they start up. You can enable [UPnP][link-upnp]
  on your router or add a NAT (for IPv4 but not IPv6) and firewall rules to allow TCP port 8444 access to your peer.
  These methods tend to be router make/model specific.

  Most users should only install harvesters, farmers, plotter, full nodes, and wallets.
  Setting up a seeder is best left to more advanced users.
  Building Timelords and VDFs is for sophisticated users, in most environments.
  Chia Network and additional volunteers are running sufficient Timelords for consensus.



  Install instructions are available in the [Installation Details][link-install] section of the [Chia Docs][link-docs].



  Once installed, an [Intro to Chia][link-intro] guide is available in the [Chia Docs][link-docs].

  [badge-beta]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data-beta.json&query=%24.message&logo=chianetwork&logoColor=black&label=Latest%20Beta&labelColor=%23e9fbbc&color=%231e2b2e
  [badge-beta2]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data-beta.json&query=%24.message&logo=chianetwork&logoColor=%23e9fbbc&label=Latest%20Beta&labelColor=%23474748&color=%231e2b2e&link=https%3A%2F%2Fgithub.com%2FChia-Network%2Fchia-blockchain%2Freleases&link=https%3A%2F%2Fgithub.com%2FChia-Network%2Fchia-blockchain%2Freleases
  [badge-commits]: https://img.shields.io/github/commit-activity/w/Chia-Network/chia-blockchain?logo=GitHub
  [badge-contributers]: https://img.shields.io/github/contributors/Chia-Network/chia-blockchain?logo=GitHub
  [badge-coverage]: https://img.shields.io/coverallsCoverage/github/Chia-Network/chia-blockchain?logo=Coveralls&logoColor=red&labelColor=%23212F39
  [badge-discord]: https://dcbadge.vercel.app/api/server/chia?style=flat-square&theme=full-presence
  [badge-discord2]: https://img.shields.io/discord/1034523881404370984.svg?label=Discord&logo=discord&colorB=1e2b2f
  [badge-downloads]: https://img.shields.io/github/downloads/Chia-Network/chia-blockchain/total?logo=GitHub
  [badge-rc]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data-rc.json&query=%24.message&logo=chianetwork&logoColor=white&label=Latest%20RC&labelColor=%230d3349&color=%23474748
  [badge-reddit]: https://img.shields.io/reddit/subreddit-subscribers/chia?style=flat-square&logo=reddit&labelColor=%230b1416&color=%23222222
  [badge-release]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdownload.chia.net%2Flatest%2Fbadge-data.json&query=%24.message&logo=chianetwork&label=Latest%20Release&labelColor=%231e2b2e&color=%230d3349
  [badge-twitter]: https://img.shields.io/twitter/follow/chia_project?style=flat-square&logo=x.org&logoColor=white&labelColor=black
  [badge-youtube]: https://img.shields.io/youtube/channel/subscribers/UChFkJ3OAUvnHZdiQISWdWPA?style=flat-square&logo=youtube&logoColor=%23ff0000&labelColor=%230f0f0f&color=%23272727
  [link-chia]: https://www.chia.net/
  [link-chialisp]: https://chialisp.com/
  [link-commits]: https://github.com/Chia-Network/chia-blockchain/commits/main/
  [link-consensus]: https://docs.chia.net/consensus-intro/
  [link-contributers]: https://github.com/Chia-Network/chia-blockchain/graphs/contributors
  [link-coverage]: https://coveralls.io/github/Chia-Network/chia-blockchain
  [link-discord]: https://discord.gg/chia
  [link-docs]: https://docs.chia.net/docs-home/
  [link-downloads]: https://www.chia.net/downloads/
  [link-faq]: https://docs.chia.net/faq/
  [link-install]: https://docs.chia.net/installation/
  [link-intro]: https://docs.chia.net/introduction/
  [link-latest]: https://github.com/Chia-Network/chia-blockchain/releases/latest
  [link-pool]: https://docs.chia.net/pool-farming/
  [link-reddit]: https://www.reddit.com/r/chia/
  [link-release]: https://github.com/Chia-Network/chia-blockchain/releases
  [link-seeder]: https://docs.chia.net/guides/seeder-user-guide/
  [link-twitter]: https://twitter.com/chia_project
  [link-upnp]: https://www.homenethowto.com/ports-and-nat/upnp-automatic-port-forward/
  [link-youtube]: https://www.youtube.com/chianetwork
  [logo-chia]: https://www.chia.net/wp-content/uploads/2022/09/chia-logo.svg "Chia logo"


pkgId: b644fa4e28db72a2707d2626da91dda86d749c26a60ccff21c8f0841d84e149a
name: python-chia-internal-custody
arch: src
version: 0.2.10
epoch: 0
release: 1
summary: Custody puzzles and CLI tailored to Chia Network's business and security requirements
url: https://github.com/Chia-Network/internal-custody
rpm_license: https://opensource.org/licenses/Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chia-internal-custody-0.2.10-1.src.rpm
checksum_type: sha256
description:
  You need a running full node and wallet for most commands to work.  You don't need anything if you are just a signer. Here are the instructions for this piece:
  ```
  py -m venv venv
  . ./venv/bin/activate  # ./venv/Scripts/activate for Windows users
  pip install --extra-index-url https://pypi.chia.net/simple/ chia-internal-custody
  ```
  If you're on Windows, you need one extra package:
  `pip install pyreadline`

  ```
  hsmgen > 1.se
  hsmgen > 2.se
  hsmgen > 3.se
  hsmpk $(cat 1.se) > 1.pk
  hsmpk $(cat 2.se) > 2.pk
  hsmpk $(cat 3.se) > 3.pk
  ```
  _Note: If you're on windows powershell 5 or lower, `>` does not work properly._
  _Either upgrade your shell or find some other way to put the output into a file as UTF-8._

  ```
  cic init --withdrawal-timelock 60 --payment-clawback 120 --rekey-cancel 120 --rekey-timelock 120 --slow-penalty 120
  cic derive_root -pks "1.pk,2.pk,3.pk" -m 2 -n 3
  ```

  ```
  cic launch_singleton --fee 100000000
  cic sync -c './Configuration (<your 6 hex digits>).txt'
  cic p2_address --prefix txch
  <send money to that address and wait for confirmation>
  cic sync
  ```

  ```
  cic payment -f initial_absorb.unsigned -pks "1.pk,2.pk" -a 100 -t <own address> -ap -at 0
  cat ./initial_absorb.unsigned | hsms -y --nochunks 1.se
  echo <sig here> > initial_absorb.1.sig
  cat ./initial_absorb.unsigned | hsms -y --nochunks 2.se
  echo <sig here> > initial_absorb.2.sig
  hsmmerge ./initial_absorb.unsigned ./initial_absorb.1.sig ./initial_absorb.2.sig > initial_absorb.signed
  cic push_tx -b ./initial_absorb.signed -m 100000000
  cic sync
  ```

  ````
  cic clawback -f clawback.unsigned -pks "1.pk,2.pk"
  cat ./clawback.unsigned | hsms -y --nochunks 1.se
  echo <sig here> > clawback.1.sig
  cat ./clawback.unsigned | hsms -y --nochunks 2.se
  echo <sig here> > clawback.2.sig
  hsmmerge ./clawback.unsigned ./clawback.1.sig ./clawback.2.sig > clawback.signed
  cic push_tx -b ./clawback.signed -m 100000000
  cic sync
  ````

  ```
  cic derive_root --db-path './sync (<your hex digits>).sqlite' -c './Configuration (new).txt' -pks "1.pk,2.pk" -m 1 -n 2
  ```

  ```
  cic start_rekey -f rekey.unsigned -pks "1.pk,2.pk" -new './Configuration (new).txt'
  cat ./rekey.unsigned | hsms -y --nochunks 1.se
  echo <sig here> > rekey.1.sig
  cat ./rekey.unsigned | hsms -y --nochunks 2.se
  echo <sig here> > rekey.2.sig
  hsmmerge ./rekey.unsigned ./rekey.1.sig ./rekey.2.sig > rekey.signed
  cic push_tx -b ./rekey.signed -m 100000000
  cic sync
  ```

  ```
  cic complete -f complete.signed
  cic push_tx -b ./complete.signed -m 100000000
  cic sync
  ```

  ```
  cic update_config -c './Configuration (new).txt'
  ```

  ```
  cic increase_security_level -f lock.unsigned -pks "1.pk,2.pk"
  cat ./lock.unsigned | hsms -y --nochunks 1.se
  echo <sig here> > lock.1.sig
  cat ./lock.unsigned | hsms -y --nochunks 2.se
  echo <sig here> > lock.2.sig
  hsmmerge ./lock.unsigned ./lock.1.sig ./lock.2.sig > lock.signed
  cic push_tx -b ./lock.signed -m 100000000
  cic sync
  ```


pkgId: aa7b7a5d60388e1de347d8d2cb86571ae118f65cd43d8cbd0e8b4ebb60646fb2
name: python-chialisp-builder
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Allow on-demand builds of chialisp with recursive dependency checking.
url: https://pypi.org/project/chialisp-builder/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chialisp-builder-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Use this wheel in conjunction with `runtime_builder` to manage building of chialisp at build time or during development.



  Add `chialisp_builder` as a buildtime dependency and a development-time dependency. Don't add it as a runtime dependency, as the clvm `.hex` files should be built and included with the wheel. The source does not need to be.

  Add `chialisp_loader` as a runtime dependency to get the `load_program` function, which will call the building function if present (as it should be at development time.)



  Why isn't this included as part of `runtime_builder`?

  The `runtime_builder` wheel is intended to provide a general solution for non-python artifacts. Although Chialisp build was the inspiration for `runtime_builder`, it's just one potential use. This wheel is the specific implementation of chialisp builds for use with `runtime_builder`.

rpm_license:
  Copyright 2023 by Richard Kiss  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 05642184a78b11f8f31228c5d80c0cbaea235133f5346e51d1acb7f7523138a8
name: python-chialisp-loader
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Provides `load_puzzle` which dynamic rebuilds if `chialisp_builder` is available.
url: https://pypi.org/project/chialisp-loader/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chialisp-loader-0.1.2-1.src.rpm
checksum_type: sha256
description:
  This tiny wheel exports `load_program`, which is used to load [chialisp](https://chialisp.com/) programs from resources included with python wheels.

  Chialisp `.clsp` files are compiled into `.hex` output. Only `.hex` output files need to be included in binary wheels

  When `load_program` is called, it tries to import `chialisp_builder`. If it fails, it assumes this is running at deploy time: any `.clsp` files are ignored, and the corresponding program is loaded from the `.hex` file.

rpm_license:
  Copyright 2023 by Richard Kiss  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 919cdd0cc77d5a3ce6b30efa7538d012a95a0ac293a9c922e509ea8052d25cee
name: python-chialisp-stdlib
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Chialisp `.clib` standard library files
url: https://pypi.org/project/chialisp-stdlib/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chialisp-stdlib-0.1.1-1.src.rpm
checksum_type: sha256
description:
  Use:

  `pip install chialisp_stdlib`

  To get the path to the include files, use

  ```python
  from chialisp_stdlib import NIGHTLY_INCLUDE_DIRECTORY
  from chialisp_stdlib import STABLE_INCLUDE_DIRECTORY
  ```

  Note that `*_INCLUDE_DIRECTORY` is a `pathlib.Path` and not a `str`, so if your API expects `str`-based paths, use `str(path)` to convert.

  And upgrade your API: see [PEP519](https://peps.python.org/pep-0519/). C'mon, it's 2023 (as of this writing).

rpm_license:
  Copyright 2023 by Richard Kiss  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  http://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 99de394eaa52362ee41751d2f0940cd27f9a44b6f0f88fb61dea694c00bcb258
name: python-chiasmodon
arch: src
version: 3.0.2
epoch: 0
release: 1
url: https://github.com/chiasmod0n/chiasmodon
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chiasmodon-3.0.2-1.src.rpm
checksum_type: sha256
summary:
  Chiasmodon is an OSINT tool that allows users to gather information from various sources and conduct targeted searches based on domains, Google Play applications, email addresses, IP addresses, organizations, URLs, and more. It provides comprehensive scanning capabilities, customizable output formats, and additional options for enhanced data analysis and customization.

description:
  [![asciicast](https://asciinema.org/a/QrEtBLFMQrjU1sjRjcgTdo41m.svg)](https://asciinema.org/a/QrEtBLFMQrjU1sjRjcgTdo41m)
  <p align="center">
  <img src="https://badge.fury.io/py/chiasmodon.svg" />
  </p>
  Chiasmodon is an OSINT tool that allows users to gather information from various sources and conduct targeted searches based on domains, Google Play applications, email addresses, IP addresses, organizations, URLs, and more. It provides comprehensive scanning capabilities, customizable output formats, and additional options for enhanced data analysis and customization.




  - [x] **🌐Domain**: Conduct targeted searches by specifying a domain name to gather relevant information related to the domain.
  - [x] **🎮Google Play Application**: Search for information related to a specific application on the Google Play Store by providing the application ID.
  - [x] **✉️Email, 👤Username, 🔒Password**: Conduct searches based on email, username, or password to identify potential security risks or compromised credentials.
  - [x] **🔍 IP Address**: Perform searches using an IP address to gather information such as geolocation, associated domain names, and historical data.
  - [x] **🌍 CIDR**: Search for information related to a specified CIDR (Classless Inter-Domain Routing) block, including IP range details and associated networks.
  - [x] **🔢 ASN**: Retrieve information about an Autonomous System Number (ASN), including its owner, associated IP ranges, and network details.
  - [x] **🔌 Port**: Search for information about a specific port number, including its common usage, associated services, and potential vulnerabilities.
  - [x] **🌐 ISP**: Conduct searches based on an Internet Service Provider (ISP) name to gather information about the ISP, its services, and associated IP ranges.
  - [x] **🏢 Organization (ORG)**: Search for information related to a specific organization or company, including its contact details, associated domains, and network infrastructure.
  - [x] **🔗 URL Path**: Perform searches based on a specific URL path to gather information about the path, its content, and potential security risks.
  - [x] **📞 Phone**: Conduct searches using a phone number to gather information such as the associated owner, location, and any available public records.
  - [x] **🔍Scan**: Perform a comprehensive scan on a given company domain name in one click, including finding
    - Related companies.
    - App applications.
    - Ips (`Port, Org, Isp, Asn`).
    - Subdomains.
    - Client credentials (`Email, Username, Password`).
    - Employee credentials (`Email, Username, Password`)
    - URLs (`Domain/IP, Port, Endpoint`)

  - [X] **🌍Country**: Sort and filter search results by country to gain insights into the geographic distribution of the identified information.
  - [x] **📋Output Customization**: Choose the desired output format (text, JSON, or CSV) and specify the filename to save the search results.
  - [x] **⚙️Additional Options**: The tool offers various additional options, such as viewing different result types (credentials, URLs, subdomains, emails, passwords, usernames, or applications), setting API tokens, specifying timeouts, limiting results, and more.



  - **🏢Company Name**: We understand the importance of comprehensive company research. In our upcoming release, you'll be able to search by company name and access a wide range of documents associated with that company. This feature will provide you with a convenient and efficient way to gather crucial information, such as legal documents, financial reports, and other relevant records.

  - **👤Face (Photo)**: Visual data is a powerful tool, and we are excited to introduce our advanced facial recognition feature. With "Search by Face (Photo)," you can upload an image containing a face and leverage cutting-edge technology to identify and match individuals across various data sources. This will allow you to gather valuable information, such as social media profiles, online presence, and potential connections, all through the power of facial recognition.


  Chiasmodon niger is a species of deep sea fish in the family Chiasmodontidae. It is known for its ability to **swallow fish larger than itself**. and so do we. 😉
  ![Chiasmodon background](https://journal.voca.network/wp-content/uploads/2017/10/DTR083_1200.png)


  Join us today and unlock the potential of our cutting-edge OSINT tool. Contact https://t.me/Chiasmod0n on Telegram to subscribe and start harnessing the power of Chiasmodon for your domain investigations.


  ```bash
  $ pip install chiasmodon
  ```
  Only for linux 👇
  ```bash
  $ activate-global-python-argcomplete
  ```

  Chiasmodon provides a flexible and user-friendly command-line interface and python library. Here are some examples to demonstrate its usage:


  ```
  usage: chiasmodon_cli.py [-h]
                           [-m {cred.username,cred.password,cred.email,cred.phone,cred.email.domain,cred.country,domain,domain.all,ip,ip.asn,ip.isp,ip.org,ip.port,ip.country,app.id,app.name,app.domain,url.path,url.port}]
                           [-vt {full,cred,url,email,phone,password,username,app,domain,ip,related,subdomain}] [-s] [-sr SCAN_RELATED]
                           [-ss SCAN_SUBDOMAINS] [-sa SCAN_APPS] [-si SCAN_IPS] [-sc SCAN_CLIENTS] [-se SCAN_EMPLOYEES] [-o OUTPUT]
                           [-ot {text,json,csv}] [-t TIMEOUT] [-l LIMIT] [-nc] [-lv] [-lm] [--init INIT] [-v]
                           query

  Chiasmodon CLI

  positional arguments:
    query                 query argument

  options:
    -h, --help            show this help message and exit
    -m {cred.username,cred.password,cred.email,cred.phone,cred.email.domain,cred.country,domain,domain.all,ip,ip.asn,ip.isp,ip.org,ip.port,ip.country,app.id,app.name,app.domain,url.path,url.port}, --method {cred.username,cred.password,cred.email,cred.phone,cred.email.domain,cred.country,domain,domain.all,ip,ip.asn,ip.isp,ip.org,ip.port,ip.country,app.id,app.name,app.domain,url.path,url.port}
                          method to search by it,default is "domain".
    -vt {full,cred,url,email,phone,password,username,app,domain,ip,related,subdomain}, --view-type {full,cred,url,email,phone,password,username,app,domain,ip,related,subdomain}
                          type view the result default is "full".
    -s, --scan            scan the company domain (Related company, Clients, Employees, Company ASNs, Company Apps).
    -sr SCAN_RELATED, --scan-related SCAN_RELATED
                          Run related scan, default is yes, Ex: -sr no
    -ss SCAN_SUBDOMAINS, --scan-subdomains SCAN_SUBDOMAINS
                          Run subdomains scan, default is yes, Ex: -ss no
    -sa SCAN_APPS, --scan-apps SCAN_APPS
                          Run App scan, default is yes, Ex: -sa no
    -si SCAN_IPS, --scan-ips SCAN_IPS
                          Run IPs scan, default is yes, Ex: -si no
    -sc SCAN_CLIENTS, --scan-clients SCAN_CLIENTS
                          Run clients scan, default is yes, Ex: -sc no
    -se SCAN_EMPLOYEES, --scan-employees SCAN_EMPLOYEES
                          Run employees scan, default is yes, Ex: -se no
    -o OUTPUT, --output OUTPUT
                          filename to save the result
    -ot {text,json,csv}, --output-type {text,json,csv}
                          output format default is "text".
    -t TIMEOUT, --timeout TIMEOUT
                          request timeout default is 360 sec.
    -l LIMIT, --limit LIMIT
                          limit results default is 10000.
    -nc, --no-color       show result without color.
    -lv, --list-view-type
                          list view type.
    -lm, --list-methods   list methods.
    --init INIT           set the api token.
    -v, --version         version.
  ```

  Examples:
  ```

  chiasmodon_cli.py example.com --scan


  chiasmodon_cli.py example.com


  chiasmodon_cli.py example.com --method domain.all


  chiasmodon_cli.py example.com --view-type subdomain


  chiasmodon_cli.py US --method cred.country


  chiasmodon_cli.py example.com --view-type related


  chiasmodon_cli.py com.discord --method app.id


  chiasmodon_cli.py discord.com --method app.domain


  chiasmodon_cli.py Discord --method app.name


  chiasmodon_cli.py AS123 --method ip.asn


  chiasmodon_cli.py someone --method cred.username


  chiasmodon_cli.py example@123 --method cred.password


  chiasmodon_cli.py /wp-login.php --method url.path


  chiasmodon_cli.py 1.1.1.1 --method ip


  chiasmodon_cli.py xx.xx.xx.0/24 --method ip


  chiasmodon_cli.py example.com --method cred.email.domain


  chiasmodon_cli.py someone@example.com --method cred.email


  chiasmodon_cli.py targets.txt --method domain  --output example-creds.txt
  ```

  Please note that these examples represent only a fraction of the available options and use cases. Refer to the documentation for more detailed instructions and explore the full range of features provided by Chiasmodon.




  Contributions and feedback are welcome! If you encounter any issues or have suggestions for improvements, please submit them to the Chiasmodon GitHub repository. Your input will help us enhance the tool and make it more effective for the OSINT community.



  Chiasmodon is released under the [MIT License](https://opensource.org/licenses/MIT). See the [LICENSE](https://github.com/chiasmodon/LICENSE.txt) file for more details.



  Chiasmodon is intended for legal and authorized use only. Users are responsible for ensuring compliance with applicable laws and regulations when using the tool. The developers of Chiasmodon disclaim any responsibility for the misuse or illegal use of the tool.



  Chiasmodon is the result of collaborative efforts from a dedicated team of contributors who believe in the power of OSINT. We would like to express our gratitude to the open-source community for their valuable contributions and support.



  - [🐍 Python Library](https://pypi.org/project/chiasmodon)
  - [📱 Mobile (APK)](https://github.com/chiasmod0n/chiasmodon-mobile)
  - [🌐 Website](https://chiasmodon.com)
  - [💬 Telegram](https://t.me/chiasmod0n)
  - [🐦 X/Twitter](https://x.com/chiasmod0n)




  <a href="https://star-history.com/#chiasmod0n/chiasmodon&Date">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=chiasmod0n/chiasmodon&type=Date&theme=dark" />
     <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=chiasmod0n/chiasmodon&type=Date" />
     <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=chiasmod0n/chiasmodon&type=Date" />
   </picture>
  </a>


pkgId: 5c7b254e524b4b5a48b0dae8869734a30b055da8f0a035a5dbdd1c41521789d1
name: python-chic-lib
arch: src
version: 0.1.19
epoch: 0
release: 1
summary: Coarse-grainig hybrid and inorganic crystals (CHIC)
url: https://github.com/tcnicholas/chic
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chic-lib-0.1.19-1.src.rpm
checksum_type: sha256
description:
  ![CHIC logo](/docs/source/logo.svg)

  **C**oarse-graining **H**ybrid **I**norganic **C**rystals.



  Install with `pip install chic-lib`, and you're ready to go!

  By way of a quick example, ZIF-8 (CSD RefCode: FAWCEN) can be coarse-grained
  by running:

  ```python
  from chic import Structure


  struct = Structure.from_cif("ZIF-8-sod.cif")
  struct.remove_sites_by_symbol("O")


  struct.get_neighbours_crystalnn()
  struct.find_atomic_clusters()
  struct.get_coarse_grained_net()


  struct.net_to_cif('ZIF-8-sod-cg.cif', write_bonds=True, name='ZIF-8-cg')
  ```

  Head over to the [chic docs](https://tcnicholas.github.io/chic/) to see examples
  and more details!



  - [x] Add docs.
  - [x] Add simple distance cut-off algorithm for neighbour list building.
  - [ ] Add custom implementation of optimised CrystalNN algorithm.
  - [x] Integrate back-mapping code.
  - [x] Integrate extraction of local energies from LAMMPS dump format.
  - [ ] Add registry to Net class for easier future development beyond ZIFs.



  Thomas C. Nicholas

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


pkgId: 0e0b8fba1b4618e49f3aa9d5b9e412c9b61d57e741954bc283de2cd6626f219e
name: python-chicken-dinner
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: PUBG JSON API Wrapper and Game Telemetry Visualizer
url: https://github.com/crflynn/chicken-dinner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chicken-dinner-0.11.0-1.src.rpm
checksum_type: sha256
description:
  |rtd| |pypi| |pyversions|
  Python PUBG JSON API Wrapper and (optional) playback visualizer.
  Also includes basic CLI functionality for replays, leaderboards, stats, and updating assets.


pkgId: a0fa85dd32d47a8aea5c7b81485eb7fb2a04bf6455cdfa3dd681c50467ba1ff7
name: python-chickenstats
arch: src
version: 1.7.9.8
epoch: 0
release: 1
summary: A Python package for scraping & analyzing sports statistics
url: https://pypi.org/project/chickenstats/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chickenstats-1.7.9.8-1.src.rpm
checksum_type: sha256
description:
  `chickenstats` is a Python package for scraping & analyzing sports data. With just a few lines of code:
  * **Scrape & manipulate** data from various NHL endpoints, leveraging `chickenstats.chicken_nhl`, which includes
  a **proprietary xG model** for shot quality metrics
  * **Augment play-by-play data** & **generate custom aggregations** from raw csv files downloaded from
  [Evolving-Hockey](https://evolving-hockey.com) *(subscription required)* with `chickenstats.evolving_hockey`
  For more in-depth explanations, tutorials, & detailed reference materials, consult the


pkgId: 60c991e6ce244970b65940e75d815f6b6cd6bf097464fc2f06d0a0a374984f21
name: python-chide
arch: src
version: 3.0.1
epoch: 0
release: 1
summary: Quickly create sample objects from data.
url: https://github.com/cjw296/chide
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chide-3.0.1-1.src.rpm
checksum_type: sha256
description:
  |CircleCI|_ |Docs|_
  Quickly create and compare sample objects.
  Chide's philosophy is to give you a simple registry of parameters
  needed to instantiate objects for your tests.
  There's also support for simplifying objects down to mappings of their attributes
  for easier comparison and rendering, along with parsing and rendering of formats
  for inserting or asserting about multiple objects that are naturally tabular.
  Quickstart
  ~~~~~~~~~~
  Say we have two classes that each require two parameters in order to
  be instantiated:
    from dataclasses import dataclass
    @dataclass
    class ClassOne:
      x: int
      y: int
    @dataclass
    class ClassTwo:
      a: int
      b: ClassOne
  We can set up a registry of sample values as follows:
    from chide import Collection
    samples = Collection({
        ClassOne: {'x': 1, 'y': 2},
        ClassTwo: {'a': 1, 'b': ClassOne},
    })
  Now we can quickly make sample objects:
  >>> samples.make(ClassOne)
  ClassOne(x=1, y=2)
  We can provide our own overrides if we want:
  >>> samples.make(ClassOne, y=3)
  ClassOne(x=1, y=3)
  We can also create nested trees of objects:
  >>> samples.make(ClassTwo)
  ClassTwo(a=1, b=ClassOne(x=1, y=2))


pkgId: ea7f41d388c4e901e5de5b71dcd84720a6acb26abe7cbc086c4e808a69367507
name: python-chift
arch: src
version: 0.1.72
epoch: 0
release: 1
summary: Chift API client
url: https://pypi.org/project/chift/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chift-0.1.72-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/chift.svg)](https://pypi.python.org/pypi/chift)
  [![Build Status](https://github.com/chift-oneapi/chift-python-sdk/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/chift-oneapi/chift-python-sdk/actions?query=branch:main)
  [![Coverage Status](https://coveralls.io/repos/github/chift-oneapi/chift-python-sdk/badge.svg?branch=main)](https://coveralls.io/github/chift-oneapi/chift-python-sdk?branch=master)


  The Chift Python library provides convenient access to the Chift API from
  applications written in the Python language.



  See the [API docs](https://chift.stoplight.io/docs/chift-api/intro).



  You don't need this source code unless you want to modify the package. If you just
  want to use the package, just run:

  ```sh
  pip install --upgrade chift
  ```

  Install from source with:

  ```sh
  python setup.py install
  ```



  - Python 3.9+



  ```python
  import chift

  chift.client_secret = "Spht8g8zMYWHTRaT1Qwy"
  chift.client_id = "pZMQxOJJ6tl1716"
  chift.account_id = "a8bfa890-e7ab-480f-9ae1-4c685f2a2a76"
  chift.url_base = "http://chift.localhost:8000" # for development


  consumer = chift.Consumer.get("0e260397-997e-4791-a674-90ff6dab7caa")


  products = consumer.invoicing.Product.all(limit=2)


  product = consumer.invoicing.Product.get("PRD_3789488")


  print(product.name)
  ```



  Set up the development env:

  ```sh
  make
  ```

  Run all tests:

  ```sh
  make test
  ```

  Run the formatter:

  ```sh
  make fmt
  ```


pkgId: 0cda40547ef68203d77840b1e3a678fb452f52ea1f03ca86e364f76dd66af421
name: python-chiku
arch: src
version: 0.0.25
epoch: 0
release: 1
summary: Python package for efficient probabilistic polynomial approximation of arbitrary functions.
url: https://github.com/devharsh/chiku/blob/main/README.md
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chiku-0.0.25-1.src.rpm
checksum_type: sha256
description:
  [numpy](https://github.com/numpy/numpy)||||✔||
  [scipy](https://github.com/scipy/scipy)|✔||✔|||
  [mpmath](https://github.com/mpmath/mpmath)|✔|✔|✔|✔||
  [chiku](https://github.com/devharsh/chiku)|✔|✔|✔|✔|✔|✔
  The table above compares our library with other popular Python packages for numerical analysis. While the $mpmath$ library provides Taylor, Pade, Fourier, and Chebyshev approximations, a user has to transform the functions to suit the $mpmath$ datatypes (e.g., $mpf$ for real float and $mpc$ for complex values). In contrast, our library requires no modifications and can approximate arbitrary functions. Additionally, we provide Remez approximation along with the other methods supported by the $mpmath$.

  While $ANN$ are known for their universal function approximation properties, they are often treated as a black box and used to calculate the output value. We propose to use a basic 3-layer perceptron consisting of an input layer, a hidden layer, and an output layer; both hidden and output layers have linear activations to generate the coefficients for an approximation polynomial of a given order. In this architecture, the input layer is dynamic, with the input nodes corresponding to the desired polynomial degrees. While having a variable number of hidden layers is possible, we fix it to a single layer with a single node to minimize the computation.
  ![Polynomial approximation using ANN](https://github.com/devharsh/chiku/blob/main/ANN-approximation.drawio.png "Polynomial approximation using ANN")
  We show coefficient calculations for a third-order polynomial $d=3$ for a univariate function $f(x) = y$ for an input $x$, actual output $y$, and predicted output $y_{out}$.
  Input layer weights are
  $\{w_1, w_2, \ldots, w_d\} = \{w_1, w_2, w_3\} = \{x, x^2, x^3\}$
  and biases are $\{b_1, b_2, b_3\} = b_h$. Thus the output of the hidden layer is
  $y_h = w_1 x + w_2 x^2 + w_3 x^3 + b_h$
  The predicted output is calculated by
  $y_{out} = w_{out} \cdot y_h + b_{out}$
  $= w_1 w_{out} x + w_2 w_{out} x^2 + w_3 w_{out} x^3 + (b_h w_{out} + b_{out})$
  where the layer weights $\{w_1 w_{out}, w_2 w_{out}, w_3 w_{out}\}$ are the coefficients for the approximating polynomial of order-3
  and the constant term is $b_h w_{out} + b_{out}$.
  Our polynomial approximation approach using $ANN$ can generate polynomials with specified degrees. E.g., a user can generate a complete third-order polynomial for $\sin(x)$, which yields a polynomial
  $-0.0931199x^3 - 0.001205849x^2 + 0.85615075x + 0.0009873845$
  in the interval $[-\pi,\pi]$. Meanwhile, a user may want to optimize the above polynomial by eliminating the coefficients for $x^2$ to reduce costly multiplications in FHE, which yields the following:
  $-0.09340597x^3 + 0.8596622x + 0.0005142888.$


pkgId: 6eb3c1a6dfa81db248c5b6b34ca80ee3a8cab645e927e19deaf28619e79a4cf7
name: python-chili
arch: src
version: 2.9.0
epoch: 0
release: 1
summary: Chili is serialisation library. It can serialise/deserialise almost any object.
url: https://github.com/kodemore/chili
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chili-2.9.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/chili.svg)](https://pypi.org/project/chili) [![codecov](https://codecov.io/gh/kodemore/chili/branch/main/graph/badge.svg?token=TCG7SRQFD5)](https://codecov.io/gh/kodemore/chili) [![CI](https://github.com/kodemore/chili/actions/workflows/main.yaml/badge.svg?branch=main)](https://github.com/kodemore/chili/actions/workflows/main.yaml) [![Release](https://github.com/kodemore/chili/actions/workflows/release.yml/badge.svg)](https://github.com/kodemore/chili/actions/workflows/release.yml) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  Chili is an extensible library which provides a simple and efficient way to encode and decode complex Python objects to and from their dictionary representation.

  It offers complete coverage for the `typing` package; including generics, and supports custom types, allowing you to extend the library to handle your specific needs.

  With support for nested data structures, default values, forward references, and data mapping and transformation, Chili is designed to be both easy to use and powerful enough to handle complex data structures.

  > Note: Chili is not a validation library, although it ensures the type integrity.



  To install the library, simply use pip:

  ```shell
  pip install chili
  ```

  or poetry:

  ```shell
  poetry add chili
  ```



  The library provides three main classes for encoding and decoding objects, `chili.Encoder` and `chili.Decoder`, and `chili.Serializer`, which combines both functionalities.
  Functional interface is also provided through `chili.encode` and `chili.decode` functions.

  Additionally, library by default supports json serialization and deserialization, so you can use `chili.JsonDecoder`, and `chili.JsonDecoder`, and `chili.JsonSerializer` or its functional replacement `chili.json_encode` and `chili.json_decode` to serialize and deserialize objects to and from json.


  To define the properties of a class that should be encoded and decoded, you need to define them with type annotations.
  The `@encodable`, `@decodable`, or `@serializable` decorator should also be used to mark the class as encodable/decodable or serializable.

  > Note: Dataclasses are supported automatically, so you don't need to use the decorator.

  ```python
  from chili import encodable

  @encodable
  class Pet:
      name: str
      age: int
      breed: str

      def __init__(self, name: str, age: int, breed: str):
          self.name = name
          self.age = age
          self.breed = breed
  ```



  To encode an object, you need to create an instance of the `chili.Encoder` class, and then call the `encode()` method, passing the object to be encoded as an argument.

  > Note: The `chili.Encoder` class is a generic class, and you need to pass the type of the object to be encoded as a type argument.

  ```python
  from chili import Encoder

  encoder = Encoder[Pet]()

  my_pet = Pet("Max", 3, "Golden Retriever")
  encoded = encoder.encode(my_pet)

  assert encoded == {"name": "Max", "age": 3, "breed": "Golden Retriever"}
  ```

  Alternatevely you can use `chili.encode` function:

  ```python
  from chili import encode

  my_pet = Pet("Max", 3, "Golden Retriever")
  encoded = encode(my_pet, Pet)

  assert encoded == {"name": "Max", "age": 3, "breed": "Golden Retriever"}
  ```

  > `chili.encode` function by default only encodes `@encodable` objects, this behavior might be amended with the `force` flag.


  To decode an object, you need to create an instance of the `chili.Decoder` class, and then call the `decode()` method, passing the dictionary to be decoded as an argument.


  > Note: The `chili.Decoder` class is a generic class, and you need to pass the type of the object to be decoded as a type argument.

  ```python
  from chili import Decoder

  decoder = Decoder[Pet]()

  data = {"name": "Max", "age": 3, "breed": "Golden Retriever"}
  decoded = decoder.decode(data)

  assert isinstance(decoded, Pet)
  ```

  Alternatevely you can use `chili.decode` function:

  ```python
  from chili import decode

  data = {"name": "Max", "age": 3, "breed": "Golden Retriever"}
  decoded = decode(data, Pet)

  assert isinstance(decoded, Pet)
  ```

  > `chili.decode` function by default only decodes `@decodable` objects, this behavior might be amended with the `force` flag.


  If a property is not present in the dictionary when decoding, the `chili.Decoder` class will not fill in the property value, unless there is a default value defined in the type annotation. Similarly, if a property is not defined on the class, the `chili.Encoder` class will hide the property in the resulting dictionary.


  To provide default values for class properties that are not present in the encoded dictionary, you can define the properties with an equal sign and the default value. For example:

  ```python
  from typing import List
  from chili import Decoder, decodable

  @decodable
  class Book:
      name: str
      author: str
      isbn: str = "1234567890"
      tags: List[str] = []

  book_data = {"name": "The Hobbit", "author": "J.R.R. Tolkien"}
  decoder = Decoder[Book]()

  book = decoder.decode(book_data)

  assert book.tags == []
  assert book.isbn == "1234567890"
  ```

  > Note: When using default values with mutable objects, such as lists or dictionaries, be aware that the default value is shared among all instances of the class that do not have that property defined in the encoded dictionary. However, if the default value is empty (e.g. `[]` for a list, `{}` for a dictionary), it is not shared among instances.


  You can also specify custom type encoders by defining a class that implements the `chili.TypeEncoder` protocol and passing it as a dictionary to the `encoders` argument of the Encoder constructor.

  ```python
  from chili import Encoder, TypeEncoder

  class MyCustomEncoder(TypeEncoder):
      def encode(self, value: MyCustomType) -> str:
          return value.encode()


  type_encoders = {MyCustomType: MyCustomEncoder()}
  encoder = Encoder[Pet](encoders=type_encoders)
  ```


  You can also specify custom type decoders by defining a class that implements the `chili.TypeDecoder` protocol and passing it as a dictionary to the `decoders` argument of the Decoder constructor.

  ```python
  from chili import Decoder, TypeDecoder

  class MyCustomDecoder(TypeDecoder):
      def decode(self, value: str) -> MyCustomType:
          return MyCustomType.decode(value)

  type_decoders = {MyCustomType: MyCustomDecoder()}
  decoder = Decoder[Pet](decoders=type_decoders)
  ```


  The library also provides convenient functions for encoding and decoding objects.

  The `chili.encode` function takes an object and an optional type hint and returns a dictionary.

  The `chili.decode` function takes a dictionary, a type hint, and returns an object.

  ```python
  from chili import encode, decode

  my_pet = Pet("Max", 3, "Golden Retriever")

  encoded = encode(my_pet)
  decoded = decode(encoded, Pet)
  ```

  > To specify custom type encoders and decoders, you can pass them as keyword arguments to the `chili.encode` and `chili.decode` functions.


  If your object is both encodable and decodable, you can use the `@serializable` decorator to mark it as such. You can then use the `chili.Serializer` class to encode and decode objects.

  ```python
  from chili import Serializer, serializable

  @serializable
  class Pet:
      name: str
      age: int
      breed: str

      def __init__(self, name: str, age: int, breed: str):
          self.name = name
          self.age = age
          self.breed = breed

  my_pet = Pet("Max", 3, "Golden Retriever")
  serializer = Serializer[Pet]()

  encoded = serializer.encode(my_pet)
  decoded = serializer.decode(encoded)
  ```

  > Note: that you should only use the `@serializable` decorator for objects that are both @encodable and @decodable.



  The library also provides classes for encoding and decoding objects to and from JSON formats. The `chili.JsonEncoder` and `chili.JsonDecoder` classes provide JSON serialization.

  ```python
  from chili import JsonEncoder, JsonDecoder, JsonSerializer


  encoder = JsonEncoder[Pet]()
  decoder = JsonDecoder[Pet]()
  serializer = JsonSerializer[Pet]()

  my_pet = Pet("Max", 3, "Golden Retriever")
  encoded = encoder.encode(my_pet)
  decoded = decoder.decode(encoded)
  ```

  The `encoded` value will be a json string:

  ```json
  {"name": "Max", "age": 3, "breed": "Golden Retriever"}
  ```

  The `decoded` value will be an instance of a Pet object.

  > Functional interface is also available through the `chili.json_encode`, `chili.json_decode` functions.


  Chili recognizes private attributes within a class, enabling it to serialize these attributes when a class specifies a getter for an attribute and an associated private storage (must be denoted with a `_` prefix).

  Here is an example:

  ```python
  from chili import encodable, encode

  @encodable
  class Pet:
      name: str

      def __init__(self, name: str) -> None:
          self._name = name

      @property
      def name(self) -> str:
          return self._name

  pet = Pet("Bobik")
  data = encode(pet)
  assert data == {
      "name": "Bobik",
  }
  ```



  Mapping allows you to remap keys, apply functions to the values, and even change the structure of the input dictionary. This is particularly useful when you need to convert data from one format to another, such as when interacting with different APIs or data sources that use different naming conventions.


  Here's an example of how to use the `chili.Mapper` class from the library with a Pet class:

  ```python
  from chili import Mapper


  mapper = Mapper({
      "pet_name": "name",
      "pet_age": "age",
      "pet_tags": {
          "tag_name": "tag",
          "tag_type": "type",
      },
  })

  data = {
      "pet_name": "Max",
      "pet_age": 3,
      "pet_tags": [
          {"tag_name": "cute", "tag_type": "description"},
          {"tag_name": "furry", "tag_type": "description"},
      ],
  }


  mapped_data = mapper.map(data)

  print(mapped_data)
  ```

  The `mapped_data` output would be:

  ```python
  {
      "name": "Max",
      "age": 3,
      "pet_tags": [
          {"tag": "cute", "type": "description"},
          {"tag": "furry", "type": "description"},
      ],
  }
  ```



  `KeyScheme` can be used to define mapping rules for nested structures more explicitly.
  It allows you to specify both the old key and the nested mapping scheme in a single, concise object. This can be particularly useful when you want to map a nested structure but need to maintain clarity in your mapping scheme.

  Here's an example of how to use `chili.KeyScheme` with the `chili.Mapper` class:

  ```python
  from chili import Mapper, KeyScheme


  mapper = Mapper({
      "pet_name": "name",
      "pet_age": "age",
      "pet_tags": KeyScheme("tags", {
          "tag_name": "tag",
          "tag_type": "type",
      }),
  })

  pet_dict = {
      "pet_name": "Max",
      "pet_age": 3,
      "pet_tags": [
          {"tag_name": "cute", "tag_type": "description"},
          {"tag_name": "furry", "tag_type": "description"},
      ],
  }


  mapped_data = mapper.map(pet_dict)

  print(mapped_data)
  ```

  The `mapped_data` output would be:

  ```python
  {
      "name": "Max",
      "age": 3,
      "tags": [
          {"tag": "cute", "type": "description"},
          {"tag": "furry", "type": "description"},
      ],
  }
  ```



  The `chili.Mapper` supports using `...` (Ellipsis) as a wildcard for keys that you want to include in the mapping but do not want to explicitly define. This can be useful when you want to map all keys in the input data, or when you want to map specific keys and leave the remaining keys unchanged.

  You can use a lambda function with the `...` wildcard to apply a transformation to the keys or values that match the wildcard.

  Here's an example of how to use the `...` wildcard with the `chili.Mapper` class:

  ```python
  from chili import Mapper


  mapper = Mapper({
      "pet_name": "name",
      "pet_age": "age",
      ...: lambda k, v: (f"extra_{k}", v.upper() if isinstance(v, str) else v),
  })

  pet_dict = {
      "pet_name": "Max",
      "pet_age": 3,
      "pet_color": "white",
      "pet_breed": "Golden Retriever",
      "pet_tags": [
          {"tag": "cute", "type": "description"},
          {"tag": "furry", "type": "description"},
      ],
  }


  mapped_data = mapper.map(pet_dict)

  print(mapped_data)
  ```

  The `mapped_data` output would be:

  ```python
  {
      "pet_name": "Fluffy",
      "pet_age": 3,
      "extra_color": "WHITE",
      "extra_breed": "POODLE",
      "extra_tags": [
          {
              "tag": "cute",
              "type": "description",
          },
          {
              "tag": "furry",
              "type": "description",
          },
      ],
  }
  ```



  You can also use mapping by setting `mapper` parameter in `@chili.encodable` and `@chili.decodable` decorators.

  ```python
  from typing import List

  from chili import encodable, Mapper, encode

  mapper = Mapper({
      "pet_name": "name",
      "pet_age": "age",
      "pet_tags": {
          "tag_name": "tag",
          "tag_type": "type",
      },
  })


  @encodable(mapper=mapper)
  class Pet:
      name: str
      age: int
      tags: List[str]

      def __init__(self, name: str, age: int, tags: List[str]):
          self.name = name
          self.age = age
          self.tags = tags


  pet = Pet("Max", 3, ["cute", "furry"])
  encoded = encode(pet)

  assert encoded == {
      "pet_name": "Max",
      "pet_age": 3,
      "pet_tags": [
          {"tag_name": "cute", "tag_type": "description"},
          {"tag_name": "furry", "tag_type": "description"},
      ],
  }
  ```

  Alternatively you can set mapper in `Encoder` and `Decoder` classes:

  ```python
  encoder = Encoder[Pet](mapper=mapper)

  pet = Pet("Max", 3, ["cute", "furry"])
  encoded = encoder.encode(pet)
  ```


  The library raises errors if an invalid type is passed to the Encoder or Decoder, or if an invalid dictionary is passed to the Decoder.

  ```python
  from chili import Encoder, Decoder
  from chili.error import EncoderError, DecoderError


  encoder = Encoder[MyInvalidType]()  # Raises EncoderError.invalid_type

  decoder = Decoder[MyInvalidType]()  # Raises DecoderError.invalid_type


  decoder = Decoder[Pet]()
  invalid_data = {"name": "Max", "age": "three", "breed": "Golden Retriever"}
  decoded = decoder.decode(invalid_data)  # Raises DecoderError.invalid_input
  ```



  The table below shows the results of the benchmarks for encoding and decoding objects with the library, [Pydantic](https://pydantic-docs.helpmanual.io/), and [attrs](https://www.attrs.org/en/stable/).

  | Command | Mean [ms] | Min [ms] | Max [ms] | Relative |
  |:---|---:|---:|---:|---:|
  | `poetry run python benchmarks/chili_decode.py` | 249.4 ± 4.1 | 245.5 | 258.8 | 1.01 ± 0.02 |
  | `poetry run python benchmarks/pydantic_decode.py` | 295.5 ± 12.5 | 287.6 | 327.1 | 1.19 ± 0.05 |
  | `poetry run python benchmarks/attrs_decode.py` | 260.9 ± 8.6 | 253.2 | 283.5 | 1.05 ± 0.04 |
  | `poetry run python benchmarks/chili_encode.py` | 247.8 ± 2.3 | 245.4 | 253.0 | 1.00 |
  | `poetry run python benchmarks/pydantic_encode.py` | 292.4 ± 4.7 | 287.1 | 302.5 | 1.18 ± 0.02 |
  | `poetry run python benchmarks/attrs_encode.py` | 258.2 ± 2.1 | 254.4 | 261.4 | 1.04 ± 0.01 |




  The following section lists all the data types supported by the library and explains how they are decoded and encoded. The supported data types include built-in Python types like `bool`, `dict`, `float`, `int`, `list`, `set`, `str`, and `tuple`, as well as more complex types like `collections.namedtuple`, `collections.deque`, `collections.OrderedDict`, `datetime.date`, `datetime.datetime`, `datetime.time`, `datetime.timedelta`, `decimal.Decimal`, `enum.Enum`, `enum.IntEnum`, `pathlib.Path`, and various types defined in the typing module.



  Simple type are handled by a ProxyEncoder and ProxyDecoder. These types are decoded and encoded by casting the value to the specified type.


  > For more details please refer to [chili.encoder.ProxyEncoder](chili/encoder.py#L50) and [chili.decoder.ProxyDecoder](chili/decoder.py#L65).



  Passed value is automatically cast to a boolean with python's built-in `bool` type during decoding and encoding process.



  Passed value is automatically cast to an int with python's built-in `int` type during decoding and encoding process.



  Passed value is automatically cast to float with python's built-in `float` type during decoding and encoding process.




  Passed value is automatically cast to string with python's built-in `str` during encoding and decoding process.




  Passed value is automatically cast to either `set` during decoding process or `list` during encoding process.




  Passed value is automatically cast to either `frozenset` during decoding process or `list` during encoding process.



  Passed value is automatically cast to list with python's built-in `list` during encoding and decoding process.



  Passed value is automatically cast either to `tuple` during decoding process or to `list` during encoding process.




  Passed value is automatically cast to dict with python's built-in `dict` during encoding and decoding process.



  Complex types are handled by corresponding Encoder and Decoder classes.



  Passed value is automatically cast to either `collections.namedtuple` during decoding process or `list` during encoding process.




  Passed value is automatically cast to either `collections.deque` during decoding process or `list` during encoding process.




  Passed value is automatically cast to either `collections.OrderedDict` during decoding process or `list` where each item is a `list` of two elements corresponding to `key` and `value`, during encoding process.




  Passed value is automatically cast to either `datetime.date` during decoding process or `str` (valid ISO-8601 date string) during encoding process.





  Passed value must be valid ISO-8601 date time string, then it is automatically hydrated to an instance of `datetime.datetime`
  class and extracted to ISO-8601 format compatible string.



  Passed value must be valid ISO-8601 time string, then it is automatically hydrated to an instance of `datetime.time`
  class and extracted to ISO-8601 format compatible string.



  Passed value must be valid ISO-8601 duration string, then it is automatically hydrated to an instance of `datetime.timedelta`
  class and extracted to ISO-8601 format compatible string.



  Passed value must be a string containing valid decimal number representation, for more please read python's manual
  about [`decimal.Decimal`](https://docs.python.org/3/library/decimal.html#decimal.Decimal), on extraction value is
  extracted back to string.



  Supports hydration of all instances of `enum.Enum` subclasses as long as value can be assigned
  to one of the members defined in the specified `enum.Enum` subclass. During extraction the value is
  extracted to value of the enum member.



  Same as `enum.Enum`.



  Supported hydration for all instances of `pathlib.Path` class, during extraction value is extracted to string.





  Passed value is unchanged during hydration and extraction process.



  Same as `str`



  Same as `collection.dequeue` with one exception, if subtype is defined, eg `typing.Deque[int]` each item inside queue
  is hydrated accordingly to subtype.



  Same as `dict` with exception that keys and values are respectively hydrated and extracted to match
  annotated type.



  Same as `frozenset` with exception that values of a frozen set are respectively hydrated and extracted to
  match annotated type.



  Same as `list` with exception that values of a list are respectively hydrated and extracted to match annotated type.



  Same as `namedtuple`.



  Same as `set` with exception that values of a set are respectively hydrated and extracted to match annotated type.



  Same as `tuple` with exception that values of a set are respectively hydrated and extracted to match annotated types.
  Ellipsis operator (`...`) is also supported.



  Same as `dict` but values of a dict are respectively hydrated and extracted to match annotated types.




  Only parametrised generic classes are supported, dataclasses that extends other Generic classes without parametrisation will fail.




  Optional types can carry additional `None` value which chili's hydration process will respect, so for example
  if your type is `typing.Optional[int]` `None` value is not hydrated to `int`.




  Limited support for Unions.



  Passed value must be a valid regex pattern, if contains flags regex should start with `/` and flags should be passed after `/` only `ismx` flags are supported.


pkgId: e32f4c5d60f4288620b14aea950259d2d2d6ffa0afea6763222cdf9a477e264b
name: python-chill
arch: src
version: 0.10.1
epoch: 0
release: 1
summary: Database driven web application framework in Flask
url: https://git.sr.ht/~jkenlooper/chill
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chill-0.10.1-1.src.rpm
checksum_type: sha256
description:
  *Or, just chill.*  This is a **database driven web application framework in
  [Flask](https://palletsprojects.com/p/flask/)** and it can be used to create
  static or dynamic web sites.

  This involves creating custom SQL queries to pull data from a database and uses
  [Jinja2](https://palletsprojects.com/p/jinja/) HTML templates to populate pages
  for a website.  Chill can create static files for the website or can run as
  a Flask app and build pages on request.

  Chill is database driven when it comes to handling http requests.  Each http
  request uses data from the database when determining what content to show on the
  page as well as what HTML templates to use.  Content for a page can come from
  other database queries and can recursively call other queries when populating
  the page.



  Chill can be installed via pip.
  ```bash
  python3 -m pip install chill[cli]
  ```

  Or from within this cloned project; install with pip in editable mode.  It is
  recommended to setup a virtual environment first.

  ```bash

  python3 -m venv .
  source ./bin/activate


  python -m pip install -e .[cli,test]
  ```

  This will create a script called `chill`.  Type `chill --help` for help on using
  it.  It will need a config file and such.  I recommend creating an empty
  directory and running `chill init` within it.  That will create a `site.cfg`
  config file and the bare minimum to show a homepage.  Run the
  `chill run --config site.cfg`
  and visit http://localhost:5000/ with your browser.



  Run the `chill init` script in an empty directory and it will create a minimal
  starting point for using Chill. The `site.cfg` created will have comments on each
  configuration value.  The `chill run --config site.cfg` will run the app in the
  foreground at the http://localhost:5000/ URL. Notice that the script also
  creates a sqlite database file (default file name is 'db') in that directory.
  This database file is what chill uses to display the pages in a site.

  **Review the docs for more.** Some helpful guides and such are in the
  [docs/](docs/) folder.  The [tests.py](src/chill/tests.py) file within the chill
  package is also a good resource.



  The command `chill freeze --config site.cfg` will go through all the URLs and
  create a static version of each page.  It places all the necessary files in
  a folder which can then be uploaded to a static web server.  This is a wrapper
  around the Frozen-Flask python package.  Which is partly the inspiration behind
  the name 'chill'.  Also, llamas are cool and have two 'l's like chill.



  A `Dockerfile` has been included which can be used when creating a container for
  chill.  See the
  [guide on using chill with docker](docs/docker-container-usage.md).




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

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



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



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

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

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


pkgId: b53131cf564b1df4bcd020084c0f14b2aa331e245b0754a58b01d774694f33e1
name: python-chill-filter
arch: src
version: 0.1
epoch: 0
release: 1
summary: rapid sample screening for shotgun DNA sequencing data sets
url: https://pypi.org/project/chill-filter/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chill-filter-0.1-1.src.rpm
checksum_type: sha256
description:
  0. Clone the repo:

  ```
  git clone https://github.com/dib-lab/chill-filter
  cd chill-filter/
  ```

  1. Install flask, sourmash_plugin_branchwater, pandas, and snakemake.

  ```
  conda env create -f environment.yml -n chill
  conda activate chill
  ```

  2. Download the databases from [the Open Science Framework project](https://osf.io/m85ux/), and unpack them into `prepare-db/outputs/`.

  ```
  curl -JLO https://osf.io/download/pwfn8/
  mkdir -p prepare-db/outputs/
  unzip -d prepare-db/outputs/ -nu chill-filter-db-0.1.zip
  ```

  3. Run snakemake in the `sample-db/` directory to index the databases. It should take a few minutes at most.

  ```
  (cd prepare-db && snakemake -j 1 -p)
  ```

  4. Run `chill_filter_web`:

  ```
  mkdir -p /tmp/chill
  python -m chill_filter_web
  ```

  This will start a server at http://localhost:5000/, by default.

  5. Try uploading k=51, scaled=100_000 sketches!

  e.g. there are a bunch in `examples/` to try.


pkgId: 1874a17c5c4a88c1736b24f32bbbff76c77d8a09ce57bf9da9465101d00c5d92
name: python-chilo-api
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Chilo is a lightweight, form-meets-function, opinionated (yet highly configurable) api framework.
url: https://github.com/dual/chilo.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chilo-api-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://chiloproject.io"><img src="https://raw.githubusercontent.com/dual/chilo-docs/main/img/logo-no-bg.png" alt="Chilo"></a>
  </p>
  <p align="center">
      <em>Chilo is a lightweight, form-meets-function, opinionated (yet highly configurable) api framework</em>
  </p>

  [![CircleCI](https://circleci.com/gh/dual/chilo.svg?style=shield)](https://circleci.com/gh/syngenta/acai-python)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=dual_chilo&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=dual_chilo)
  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=dual_chilo&metric=coverage)](https://sonarcloud.io/summary/new_code?id=dual_chilo)
  [![Bugs](https://sonarcloud.io/api/project_badges/measure?project=dual_chilo&metric=bugs)](https://sonarcloud.io/summary/new_code?id=dual_chilo)
  [![pypi package](https://img.shields.io/pypi/v/chilo-api?color=%2334D058&label=pypi%20package)](https://pypi.org/project/chilo-api/)
  [![python](https://img.shields.io/pypi/pyversions/chilo-api.svg?color=%2334D058)](https://pypi.org/project/chilo-api)
  [![Inline docs](https://inch-ci.org/github/dwyl/hapi-auth-jwt2.svg?branch=master)](https://chiloproject.io)
  [![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/dwyl/esta/issues)


  Chilo, short for chilorhinophis (meaning two headed snake), is a lightweight, form-meets-function, opinionated (yet highly configurable) api framework.


  * No route definitions needed; route based on your directory structure
  * Built-in OpenAPI request and response validation
  * Ease of use with gunicorn
  * Generate OpenAPI spec from code base
  * Infinitely customizable with middleware extensions



  The Chilo philosophy is to provide a dry, configurable, declarative framework, which encourages Happy Path Programming (HPP).

  Happy Path Programming is an idea in which inputs are all validated before operated on. This ensures code follows the happy path without the need for mid-level, nested exceptions and all the nasty exception handling that comes with that. The library uses layers of customizable middleware options to allow a developer to easily dictate what constitutes a valid input, without nested conditionals, try/catch blocks or other coding blocks which distract from the happy path which covers the majority of the source code's intended operation.



  * [Full Docs](https://chiloproject.io)
  * [Examples](https://github.com/dual/chilo-docs/tree/main/examples)
  * Tutorial (coming soon)





  ```bash
  $ pip install chilo_api


  ```



  ```python
  from chilo_api import Chilo


  api = Chilo(
      base_path='/',
      handlers='api/handlers',
  )
  ```



  `{PWD}/api/handlers/__init__.py`
  ```python
  def get(request, response):
      response.body = {'hello': 'world'}
      return response
  ```



  ```bash
  python -m chilo_api serve --api=main --reload=true
  ```



  [http://127.0.0.1:3000/](http://127.0.0.1:3000/)



  ```python
  from chilo_api import requirements


  @requirements(required_params=['greeting'])
  def get(request, response):
      response.body = {'hello': request.query_params['greeting']}
      return response
  ```



  [http://127.0.0.1:3000/?greeting=developer](http://127.0.0.1:3000/?greeting=developer)


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



  API reference documentation is available [here](https://chima.docs.buildwithfern.com/api-reference/search).



  Add this dependency to your project's build file:

  ```bash
  pip install chima

  poetry add chima
  ```



  ```python
  from chima.client import Chima

  chima_client = Chima()

  response = chima_client.search(group_id="group_id", query="Your query")

  print(response)
  ```



  This SDK also includes an async client, which supports the `await` syntax:

  ```python
  import asyncio
  from chima.client import AsyncChima

  chima_client = AsyncChima()

  async def get_response() -> None:
      response = await chima_client.search(group_id="group_id")
      print(response)

  asyncio.run(get_response())
  ```



  Chima's streaming endpoint will return a Python generator that you can iterate over.

  ```python
  from chima.client import Chima

  chima_client = Chima()

  response = chima_client.stream(level_context="Some context.")

  for chunk in response:
      print(chunk)
  ```



  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning the package version to a specific version in your lock file. This way, you can install the same version each time without breaking changes unless you are intentionally looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically. 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](https://github.com/chima-org/chima-python/issues) first to discuss with us!

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


pkgId: 0b567181c190579b34843bd98ab4588ee3316f7d10abaa48e74da0a4cfe669af
name: python-chime
arch: src
version: 0.7.0
epoch: 0
release: 1
summary: Python sound notifications made easy.
url: https://github.com/MaxHalford/chime
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-chime-0.7.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1>chime</h1>
    <q><i>Python sound notifications made easy.</i></q>
  </div>
  <br>

  <div align="center">
    <!-- Tests -->
    <a href="https://github.com/MaxHalford/chime/actions?query=workflow%3Atests">
      <img src="https://github.com/MaxHalford/chime/workflows/tests/badge.svg?style=flat-square" alt="tests">
    </a>
    <!-- Soundboard -->
    <a href="https://chime-soundboard.herokuapp.com/">
      <img src="https://github.com/MaxHalford/chime/workflows/soundboard/badge.svg?style=flat-square" alt="soundboard">
    </a>
    <!-- PyPI -->
    <a href="https://pypi.org/project/chime">
      <img src="https://img.shields.io/pypi/v/chime.svg?label=release&color=blue&style=flat-square" alt="pypi">
    </a>
    <!-- PePy -->
    <a href="https://pepy.tech/project/chime">
      <img src="https://img.shields.io/badge/dynamic/json?style=flat-square&maxAge=86400&label=downloads&query=%24.total_downloads&url=https%3A%2F%2Fapi.pepy.tech%2Fapi%2Fprojects%2Fchime" alt="pepy">
    </a>
    <!-- License -->
    <a href="https://opensource.org/licenses/MIT">
      <img src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square" alt="license">
    </a>
  </div>
  <br>



  - [Table of contents](#table-of-contents)
  - [Motivation](#motivation)
  - [Installation](#installation)
  - [Basic usage](#basic-usage)
  - [Theming](#theming)
  - [IPython/Jupyter magic](#ipythonjupyter-magic)
  - [Exception notifications](#exception-notifications)
  - [Command-line usage](#command-line-usage)
  - [Platform support](#platform-support)
  - [I can't hear anything 🙉](#i-cant-hear-anything-)
  - [Setting a default theme](#setting-a-default-theme)
  - [Command-line arguments](#command-line-arguments)
  - [Adding a new theme](#adding-a-new-theme)
  - [Things to do](#things-to-do)
  - [Acknowledgements](#acknowledgements)
  - [License](#license)



  I made this because I wanted a simple auditory cue system to tell me when a long-running number crunching script had finished. I didn't want to have to fiddle with the command-line, and also wanted a cross-platform solution. Thus was born `chime`!



  ```sh
  pip install chime
  ```

  This library has **no dependencies**. The IPython/Jupyter functionality is only imported if you've installed the `ipython` library. It should work for any Python version above or equal to 3.6.



  `chime` puts four functions at your disposal:

  ```py
  >>> import chime

  >>> chime.success()
  >>> chime.warning()
  >>> chime.error()
  >>> chime.info()

  ```

  Calling any of the above functions will play a sound. Note that the sounds are played in asynchronous processes, and are thus non-blocking. Each function should take around 2ms to execute, regardless of the sound length. You're free to use each sound notification in any way you see fit. I'm not your mama.



  The sounds that are played depend on which theme is being used.

  ```py
  >>> chime.theme()  # return the current theme
  'chime'

  ```

  Several themes are available:

  ```py
  >>> chime.themes()
  ['big-sur', 'chime', 'mario', 'material', 'pokemon', 'sonic', 'zelda']

  ```

  The theme can be changed by passing a theme name to the `theme` function:

  ```py
  >>> chime.theme('zelda')

  ```

  A couple of things to note:

  - You can listen to the sounds interactively via [this soundboard](https://chime-soundboard.herokuapp.com/), which is made with [Streamlit](https://www.streamlit.io/).
  - A random theme will be picked each time you play a sound if you set the theme to `'random'`.



  Load the extension as so:

  ```py
  %load_ext chime
  ```

  You can wrap a line:

  ```py
  %chime print("I'm a line")
  ```

  You can also wrap an entire cell:

  ```py
  %chime

  print("I'm a cell")
  ```

  The magic command will call `chime.success` when the line/cell finishes successfully. Otherwise, `chime.error` is called whenever an exception is raised.



  If you run `chime.notify_exceptions`, then `chime.error` will be called whenever an exception is raised.

  ```py
  chime.notify_exceptions()

  raise ValueError("I'm going to make some noise")
  ```



  You can run `chime` from the command-line:

  ```sh
  $ chime
  ```

  By default, this will play the success sound. You can also choose which sound to play, like so:

  ```sh
  $ chime info
  ```

  You can also choose which theme to use:

  ```sh
  $ chime info --theme zelda
  ```

  If you're using bash, then you can use `chime` to notify you when a program finishes:

  ```sh
  $ echo "Hello world!"; chime
  ```

  This will play the sound regardless of the fact that the first command succeeded or not. If you're running on Windows, then you can run the following equivalent:

  ```sh
  > echo "Hello world!" & chime
  ```



  Under the hood, `chime` runs a command in the shell to play a `.wav` file. The command-line program that is used depends on the [platform](https://www.wikiwand.com/en/Computing_platform) that you're using. Platform information is available in the [`sys.platform` variable](https://docs.python.org/3/library/sys.html#sys.platform) as well as the [`platform` module](https://docs.python.org/3/library/platform.html) from the standard library. Currently, the supported platforms are:

  - Darwin
  - Linux
  - Windows

  A `UserWarning` is raised if you run a `chime` sound on an unsupported platform. Feel free to get in touch or issue a pull request if you want to add support for a specific platform. Likewise, don't hesitate if you're encountering trouble with one of the above platforms. I won't bite.



  Did you check if you turned your sound on? Just kidding. 😜

  This library is designed to be non-invasive. By default, sounds are played asynchronously in unchecked processes. Therefore, if something goes wrong, the process dies silently. If you can't hear anything and you think that the issue is coming from `chime`, then set the `sync` parameter when you play a sound:

  ```py
  >>> chime.info(sync=True)

  ```

  This will play the sound synchronously and issue a warning if something goes wrong, which should allow you to debug the issue. You can also raise an exception instead of sending a warning by setting the `raise_error` parameter:

  ```py
  >>> chime.info(sync=True, raise_error=True)

  ```

  Note that setting `raise_error` won't do anything if `sync` is set to `False`.



  To change the default theme a configuration file may be created in `~/.config/chime/chime.conf` on Unix or `%APPDATA%\chime\chime.ini` on Windows.

  For example, to change the default theme to `'zelda'`, the configuration file would contain:

  ```ini
  [chime]
  theme = zelda

  ```



  Chime works by running commands in the CLI. For instance, `aplay` is used on Linux systems, while `afplay` is used on Darwin systems. Arguments can be specified by setting the `RUN_ARGS` variable. For example, here's how to select a specific sound card, assuming a Linux system using `aplay`:

  ```py
  >>> chime.RUN_ARGS = "--device sysdefault:CARD=PCH"

  ```

  You can also specify this as a default configuration in the configuration file:

  ```ini
  [chime]
  cli_args = '--device sysdefault:CARD=PCH'

  ```

  At present, it isn't possible to pass CLI arguments on Windows, due to a limitation of the [`winsound`](https://docs.python.org/3/library/winsound.html) module.



  I have toyed with the idea of allowing users to add their own theme(s), but at the moment I rather keep things minimal. However, I'm happy to integrate new themes into the library. You can propose a new theme by [opening a pull request](https://github.com/MaxHalford/chime/issues/new) that adds the necessary .wav files to the [`themes` directory](https://github.com/MaxHalford/chime/tree/main/themes). A theme is made up of four files: `success.wav`, `warning.wav`, `error.wav`, and `info.wav`. That's all you need to do: the theme will picked up be automatically once the necessary files are provided.

  Be creative! 👩‍🎨



  - Some mechanism to automatically call `chime.warning` when a warning occurs.
  - Make it work with a remote machine. For instance a Jupyter Notebook hosted on a remote machine.
  - More themes!



  - Special thanks to [Michael Vlah](https://github.com/vlahm) for being a gentleman by giving up the "chime" name on PyPI.
  - Thanks to u/Pajke on reddit for helping me debug Windows support.
  - Thanks to [David Chen](https://github.com/dchen327) for adding Linux support by suggesting the use of [aplay](https://linux.die.net/man/1/aplay).
  - Thanks to [Vincent Warmerdam](https://twitter.com/fishnets88) for suggesting a command-line interface.
  - Calmcode made a [video introduction to chime](https://calmcode.io/chime/introduction.html) ❤️
  - Thanks to [Paulo S. Costa](https://github.com/paw-lu) for contributing in many different ways.
  - Thanks to [d34d_m8](https://github.com/d34dm8) for adding OpenBSD support.



  As you would probably expect, this is [MIT licensed](LICENSE).


