# packages

pkgId: 25fb8da2aaf03ca3f3528ed3fd8e77ef699dfbe539c54eab41940918e9c414e7
name: python-click-prompt
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: click-prompt provides more beautiful interactive options for the Python click library
url: https://pypi.org/project/click-prompt/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-prompt-0.6.1-1.src.rpm
checksum_type: sha256
description:
  [![Supported Python Versions](https://img.shields.io/pypi/pyversions/click-prompt)](https://pypi.org/project/click-prompt/)
  [![PyPI version](https://img.shields.io/pypi/v/click-prompt)](https://pypi.org/project/click-prompt/)



  **click-prompt** is a Python library that enhances the functionality of the Click library by providing interactive prompts for user inputs. It features simple prompts to easily prompt users for a single/multi input from a list. It also allows for more advanced prompting such as path completion.
  This library is inspired by a post on [stackoverflow.com](https://stackoverflow.com/questions/54311067/).
  Contributions are welcome! Please send me an e-mail or create a pull request.




  To install `click-prompt`, use pip:

  ```bash
  pip install click-prompt
  ```




  The library can be used with decorators:

  ```python
  import click
  from click_prompt import choice_option

  @click.command()
  @choice_option('--fruit', type=click.Choice(['Apples', 'Bananas', 'Grapefruits', 'Mangoes']))
  def select_fruit(fruit: str):
      print(fruit)
  ```



  For more examples see the file [example.py](./example.py).

  ![Example](./docs/example_cli.gif)




  Here is a list of available decorators that can be used with the click library
  instead of a `click.Option` decorator

   - `choice_option`: Select a single item out of a list. Use the parameter
     `multiple=True` to select multiple items out of a list
   - `confirm_option`: Yes/No confirmation
   - `filepath_option`: Select a file path with auto completion
   - `auto_complete_option`: Auto completion given a list

  for every `click.Option` there is also a `click.Argument` implementation




  This project is licensed under the MIT License. See the [LICENSE](LICENSE.md) file for more information.


pkgId: 844c3cad81a5f765642923f865729482f01883b69ba3aa3479211ab53e132c7e
name: python-click-repl
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: REPL plugin for Click
url: https://github.com/untitaker/click-repl
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-repl-0.3.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/click-contrib/click-repl/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/click-contrib/click-repl/actions/workflows/tests.yml)
  [![License](https://img.shields.io/pypi/l/click-repl?label=License)](https://github.com/click-contrib/click-repl/LICENSE)
  ![Python - version](https://img.shields.io/badge/python-3%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue)
  [![PyPi - version](https://img.shields.io/badge/pypi-v0.2.0-blue)](https://pypi.org/project/click-repl/)
  ![wheels](https://img.shields.io/piwheels/v/click-repl?label=wheel)
  ![PyPI - Status](https://img.shields.io/pypi/status/click)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/click-repl)


pkgId: 5ead20a18f34de00a3a1a5414ff2c2cab576b4e45bd6f46a450fc2dec4b0d295
name: python-click-shell
arch: src
version: 2.1
epoch: 0
release: 1
summary: An extension to click that easily turns your click app into a shell utility
url: https://github.com/clarkperkins/click-shell
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-shell-2.1-1.src.rpm
checksum_type: sha256
description:
  |TravisCI| |DocsStatus|
  click-shell is an extension to `click`_ that easily turns your click app into a shell utility.
  It is built on top of the built in python `cmd`_ module, with modifications to make it work with click.


pkgId: faaf13ebe6288d3e941068ab518c09c5a947b43ef20db182bb5f599e8dbb52b6
name: python-click-spinner
arch: src
version: 0.1.10
epoch: 0
release: 1
summary: Spinner for Click
url: https://github.com/click-contrib/click-spinner
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-spinner-0.1.10-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/click-spinner.svg)](https://pypi.python.org/pypi/click-spinner/) [![Build Status](https://travis-ci.org/click-contrib/click-spinner.svg?branch=master)](https://travis-ci.org/click-contrib/click-spinner)

  Sometimes you would just like to show the user some progress,
  but a progress bar is not suitable because you don’t know how much longer it would take.
  In these cases you might want to display a simple spinner using the `spinner()` function.

  Example usage:

  ```py
  with click_spinner.spinner():
          do_something()
          do_something_else()
  ```

  It looks like this:

  ![spinner](https://cloud.githubusercontent.com/assets/1288133/18229827/29629cd4-728f-11e6-8007-6c85ac50565c.gif)

  Spinner class based on on a [gist by @cevaris](https://gist.github.com/cevaris/79700649f0543584009e).

  Introduced in [PR #649](https://github.com/pallets/click/pull/649).



  ```
  pip install click-spinner
  ```

  Supports Python 2.7 and 3.



  - @yoavram
  - @andy-maier
  - @AdrienPensart


pkgId: 4782db4b3ec83622502fb5b9838d35830ec8f00ef593f50eb1d2719f1b88cf03
name: python-clickable-ut
arch: src
version: 8.2.0
epoch: 0
release: 1
summary: Compile, build, and deploy Ubuntu Touch click packages all from the command line.
url: https://clickable-ut.dev/
rpm_license: GPL3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickable-ut-8.2.0-1.src.rpm
checksum_type: sha256
description:
  Compile, build, deploy an debug Ubuntu Touch click packages all from the command line.



  * [Install](https://clickable-ut.dev/en/latest/install.html)
  * [Getting Started](https://clickable-ut.dev/en/latest/getting-started.html)
  * [Usage](https://clickable-ut.dev/en/latest/usage.html)
  * [Commands](https://clickable-ut.dev/en/latest/commands.html)
  * [Project Config Format](https://clickable-ut.dev/en/latest/clickable-json.html)
  * [App Templates](https://clickable-ut.dev/en/latest/app-templates.html)
  * [Builders](https://clickable-ut.dev/en/latest/builders.html)



  Start QtCreator shipped by Clickable in a project folder via `clickable ide`.



  Please base any development on the branch `dev` and file merge requests against it.



  You can run Clickable directly from sources via the `clickable-dev` script.
  Add the `--verbose` option for additional output.

  It is recommended to add your clickable repo folder to `PATH`.
  This can be done by adding `export PATH="$PATH:$HOME/clickable"` to your `.bashrc`.
  Replace `$HOME/clickable` with your path.

  To enable configuration validation either install **jsonschema** via pip
  (`pip3 install jsonschema`) or apt (`apt install python3-jsonschema`). If you
  got Clickable regularly installed, you already have jsonschema, too.



  Clickable uses flake8 and pylint for linting as well as autopep8 for formatting.
  Install them using `pip3 install flake8 pylint autopep8`.
  Run `make lint` to lint and `make format` to format the source code.



  Install the pytest modules: `pip3 install pytest pytest-cov`.

  Run pytest to complete the tests: `make test`.



  * [Clickable docker images and app templates](https://gitlab.com/clickable)



  Copyright (C) 2022 Clickable Team

  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3, as published
  by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranties of MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.


pkgId: bba24c4f5dde9a5e5bf4b4487190afc4bea5c6d2d444fd2e5d7c8cdae3e65f12
name: python-clickhouse-cityhash
arch: src
version: 1.0.2.4
epoch: 0
release: 1
summary: Python-bindings for CityHash, a fast non-cryptographic hash algorithm
url: https://github.com/xzkostyan/clickhouse-cityhash
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhouse-cityhash-1.0.2.4-1.src.rpm
checksum_type: sha256
description:
  A fork of Python wrapper around `CityHash <https://github.com/google/cityhash>`__
  with downgraded version of algorithm. This fork used as 3-rd party library
  for hashing data in ClickHouse protocol. Unfortunately ClickHouse
  server comes with built-in old version of this algorithm.
  Please use original `python-cityhash <https://github.com/escherba/python-cityhash>`_
  package for other purposes.


pkgId: 2693eaf0c3b2bb22c6f9fa46a594f4b7a122351e60ea7e1daaf6e17f32e00fa2
name: python-clickhouse-connect
arch: src
version: 0.7.19
epoch: 0
release: 1
summary: ClickHouse Database Core Driver for Python, Pandas, and Superset
url: https://github.com/ClickHouse/clickhouse-connect
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhouse-connect-0.7.19-1.src.rpm
checksum_type: sha256
description:
  A high performance core database driver for connecting ClickHouse to Python, Pandas, and Superset

  * Pandas DataFrames
  * Numpy Arrays
  * PyArrow Tables
  * Superset Connector
  * SQLAlchemy 1.3 and 1.4 (limited feature set)

  ClickHouse Connect currently uses the ClickHouse HTTP interface for maximum compatibility.



  ```
  pip install clickhouse-connect
  ```

  ClickHouse Connect requires Python 3.8 or higher.



  ClickHouse Connect is fully integrated with Apache Superset. Previous versions of ClickHouse Connect utilized a
  dynamically loaded Superset Engine Spec, but as of Superset v2.1.0 the engine spec was incorporated into the main
  Apache Superset project and removed from clickhouse-connect in v0.6.0. If you have issues connecting to earlier
  versions of Superset, please use clickhouse-connect v0.5.25.

  When creating a Superset Data Source, either use the provided connection dialog, or a SqlAlchemy DSN in the form
  `clickhousedb://{username}:{password}@{host}:{port}`.



  ClickHouse Connect incorporates a minimal SQLAlchemy implementation (without any ORM features) for compatibility with
  Superset. It has only been tested against SQLAlchemy versions 1.3.x and 1.4.x, and is unlikely to work with more
  complex SQLAlchemy applications.



  ClickHouse Connect provides an async wrapper, so that it is possible to use the client in an `asyncio` environment.
  See the [run_async example](./examples/run_async.py) for more details.



  The documentation for ClickHouse Connect has moved to
  [ClickHouse Docs](https://clickhouse.com/docs/en/integrations/language-clients/python/intro)


pkgId: 5d188dcc5bf461f210524399b80fb7160baf8127cd71c0214963665e4bef6031
name: python-clickhouse-driver
arch: src
version: 0.2.9
epoch: 0
release: 1
summary: Python driver with native interface for ClickHouse
url: https://github.com/mymarilyn/clickhouse-driver
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhouse-driver-0.2.9-1.src.rpm
checksum_type: sha256
description:
  ClickHouse Python Driver with native (TCP) interface support.
  Asynchronous wrapper is available here: https://github.com/mymarilyn/aioch


pkgId: 6554d28d20c286cd144c65719f72359dccd1e0be3e4e7621b6b47809bd9e977e
name: python-clickhouse-migrations
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: Simple file-based migrations for clickhouse
url: https://github.com/zifter/clickhouse-migrations
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhouse-migrations-0.8.0-1.src.rpm
checksum_type: sha256
description:
  [clickhouse-migrator](https://github.com/delium/clickhouse-migrator) | Doesn't support multistatement in a single file , to heavy because of pandas, looks like abandoned
  [django-clickhouse](https://github.com/carrotquest/django-clickhouse) | Need django
  [clickhouse-migrate](https://github.com/trushad0w/clickhouse-migrate) | Doesn't support multistatement

  You can install from pypi using `pip install clickhouse-migrations`.


  ```bash
  clickhouse-migrations --db-host localhost \
      --db-user default \
      --db-password secret \
      --db-name test \
      --migrations-dir ./migrations
  ```

  ```python
  from clickhouse_migrations.clickhouse_cluster import ClickhouseCluster
  cluster = ClickhouseCluster(db_host, db_user, db_password)
  cluster.migrate(db_name, migrations_home, cluster_name=None,create_db_if_no_exists=True, multi_statement=True)
  ```


pkgId: 2c8b3555fa274aac9c50f17a66c86721eadf222d4a0a2b4692da6eff65a86ec3
name: python-clickhouse-pool
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: a thread-safe connection pool for ClickHouse
url: https://ericmccarthy7.github.io/clickhouse-pool/
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhouse-pool-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/clickhouse-pool?style=for-the-badge)](https://pypi.org/project/clickhouse-pool/)
  [![PyPI - License](https://img.shields.io/pypi/l/clickhouse-pool?style=for-the-badge)](https://pypi.org/project/clickhouse-pool/)
  [![Read the Docs](https://img.shields.io/badge/docs-gh--pages-success?style=for-the-badge)](https://ericmccarthy7.github.io/clickhouse-pool/)

  A thread-safe connection pool for ClickHouse. Inspired by `psycopg2` and using
  [`clickhouse-driver`](https://github.com/mymarilyn/clickhouse-driver) for
  connections.



  ```sh
  pip install clickhouse-pool
  ```



  ```python
  from clickhouse_pool import ChPool


  pool = ChPool(host="localhost")

  with pool.get_client() as client:
      
      result = client.execute("SELECT * FROM system.numbers LIMIT 5")
      print(result)


  pool.cleanup()
  ```



  To change the connection pool size,

  ```python
  pool = ChPool(connections_min=20, connections_max=40)

  with pool.get_client() as client:
      result = client.execute("SELECT * FROM system.numbers LIMIT 5")
      print(result)


  pool.cleanup()
  ```



  To run tests locally ensure you have an instance of clickhouse-server running on
  localhost. The easiest way is to use docker:

  ```sh
  docker run -d -p 9000:9000 yandex/clickhouse-server
  poetry run pytest
  ```



  ```sh
  poetry run sphinx-build -M html docs/source docs/_build
  ```


pkgId: 3fbacddd8e7b9767d62e4d7ce87a7da54e0084b25ac523d30acad7d1ffb89991
name: python-clickhousePandasWrapper
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
description: wrapper for insert pandas dataframe in clickhouse
url: https://github.com/fb929/clickhousePandasWrapper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhousePandasWrapper-1.1.4-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Grigory Efimov  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: 09e9d1e03264a9bb3283b626b12c9c51b01b52b1819f3d89fdfcf7a13ebd881a
name: python-clickhousepy
arch: src
version: 2021.3.10
epoch: 0
release: 1
summary: Python обертка для запросов в БД Clickhouse
url: https://github.com/pavelmaksimov/clickhousepy
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickhousepy-2021.3.10-1.src.rpm
checksum_type: sha256
description:
  The wrapper is done around [clickhouse-driver](https://clickhouse-driver.readthedocs.io)

  Written in python version 3.5


  ```
  pip install clickhousepy
  or
  pip install clickhousepy[pandas]  (for installation pandas)
  ```



  ```python
  from clickhousepy import Client
  import datetime as dt

  TEST_DB = "__chpytest12345"
  TEST_TABLE = "__chpytest12345"


  client.create_db(TEST_DB)
  client.create_table_mergetree(
      TEST_DB, TEST_TABLE,
      columns=[("i", "UInt32")], # or ["i UInt32"]
      orders=["i"],
  )
  client.insert(
      TEST_DB, TEST_TABLE,
      [{"i": 1}, {"i": 2}],
  )
  query = "SELECT i FROM {}.{}".format(TEST_DB, TEST_TABLE)
  r = client.get_df(query, columns_names=["Col Integer"])
  print(r)
  ```


  ```python
  from clickhousepy import Client
  import datetime as dt


  TEST_DB = "__chpytest12345"
  TEST_TABLE = "__chpytest12345"

  client = Client(host="", user="", password="")

  r = client.show_databases()
  print("list of databases:", r)

  client.create_db(TEST_DB)

  client.create_table_mergetree(
      TEST_DB, TEST_TABLE,
      columns=[("s", "String")],
      orders=["s"],
  )



  client.insert(
      TEST_DB, TEST_TABLE,
      [{"s": "1"}],
  )

  r = client.exists(TEST_DB, TEST_TABLE)
  print("does the table exist?", r)

  r = client.get_count_rows(TEST_DB, TEST_TABLE)
  print("number of lines:", r)


  r = client.execute("SELECT * FROM {}.{}".format(TEST_DB, TEST_TABLE))
  print(r)
  ```


  ```python
  db = client.DB(TEST_DB)
  r = db.show_tables()
  print("list of database tables {}:".format(TEST_DB), r)

  db.drop_db()
  ```


  ```python
  db = client.create_db(TEST_DB)

  table = db.create_table_mergetree(
      TEST_TABLE,
      columns=[("s", "String"), ("t", "String"), ("d", "Date")],
      orders=["d"],
      partition=["s", "d"],
  )



  r = table.show_create_table()
  print("table creation description", r)

  r = table.describe()
  print("table columns", r)

  table.insert(
      [
          {"s": "1", "t": "1", "d": dt.datetime(2000, 1, 1)},
          {"s": "2", "t": "2", "d": dt.datetime(2000, 1, 2)},
          {"s": "3", "t": "3", "d": dt.datetime(2000, 1, 3)},
          {"s": "4", "t": "4", "d": dt.datetime(2000, 1, 4)},
      ],
      columns=["s", "t", "d"],
  )

  data = table.select()
  print("First 10 rows of the table", data)

  data = table.select(limit=1, columns=["s"], where="s = 2")
  print("Filtered sampling", data)

  r = table.get_count_rows()
  print("number of lines:", r)

  r = table.get_min_date(date_column_name="d")
  print("minimum date:", r)

  r = table.get_max_date(date_column_name="d")
  print("maximum date:", r)

  print("deleting partitions")
  table.drop_partitions([["3", "2000-01-03"], ["4", "2000-01-04"]])

  r = table.get_count_rows()
  print("number of lines after deleting partitions:", r)

  print("row update mutation")
  table.update(update="t = '20' ", where="t = '2' ")

  print("row deletion mutation")
  table.delete(where="t = '20'")
  time.sleep(1)
  r = table.get_count_rows()
  print("number of lines after mutation of line deletion:", r)

  print("clear table")
  table.truncate()
  r = table.get_count_rows()
  print("number of rows after clearing the table:", r)

  new_table_name = TEST_TABLE + "_new"
  print("rename table {} в {}".format(TEST_TABLE, new_table_name))
  table.rename(TEST_DB, new_table_name)

  r = client.exists(TEST_DB, TEST_TABLE)
  print("does table {} exist?".format(TEST_TABLE), r)

  print("drop tables")
  table.drop_table()

  print("deleting a database")
  db.drop_db()
  ```



  ```python
  client.drop_db(TEST_DB)
  db = client.create_db(TEST_DB)
  table = db.create_table_mergetree(
      TEST_TABLE,
      columns=[("string", "String"), ("integer", "UInt32"), ("dt", "DateTime")],
      orders=["string"],
      partition=["string"],
  )
  table.insert(
      [
          {"string": "a", "integer": 1, "dt": dt.datetime(2000, 1, 1)},
          {"string": "b", "integer": 2, "dt": dt.datetime(2000, 1, 2)},
          {"string": "c", "integer": 3, "dt": dt.datetime(2000, 1, 3)},
          {"string": "c", "integer": 3, "dt": dt.datetime(2000, 1, 3)},
      ],
  )

  table_name_2 = TEST_TABLE + "_copy"
  table2 = table.copy_table(TEST_DB, table_name_2, return_new_table=True)
  is_identic = table2.copy_data_from(
      TEST_DB, TEST_TABLE,
      where="string != 'c' ",
      columns=["string"]
  )

  assert is_identic
  ```


  ```python
  client.drop_db(TEST_DB)
  db = client.create_db(TEST_DB)
  table = db.create_table_mergetree(
      TEST_TABLE,
      columns=[("string", "String"), ("integer", "UInt32"), ("dt", "DateTime")],
      orders=["string"],
      partition=["string"],
  )
  table.insert(
      [
          {"string": "a", "integer": 1, "dt": dt.datetime(2000, 1, 1)},
          {"string": "b", "integer": 2, "dt": dt.datetime(2000, 1, 2)},
          {"string": "c", "integer": 3, "dt": dt.datetime(2000, 1, 3)},
          {"string": "c", "integer": 3, "dt": dt.datetime(2000, 1, 3)},
      ],
  )

  table_name_2 = TEST_TABLE + "_copy"
  table2 = table.copy_table(TEST_DB, table_name_2, return_new_table=True)


  table2.copy_data_from(
      TEST_DB, TEST_TABLE,
      columns=["string"],
      distinct=True
  )
  assert 3 == table2.get_count_rows()
  ```


  - [clickhouse-driver](https://github.com/mymarilyn/clickhouse-driver/)
  - [pandas](https://github.com/pandas-dev/pandas) (Optional)


  Pavel Maksimov

  You can contact me at
  [Telegram](https://teleg.run/pavel_maksimow),
  [Facebook](https://www.facebook.com/pavel.maksimow)

  Удачи тебе, друг! Поставь звездочку ;)


pkgId: 87e23010684602d69e555e26e48ef94f4fedbf3239478480ebfd71c01c278e2a
name: python-clickplc
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: Python driver for AutomationDirect (formerly Koyo) Ethernet ClickPLCs.
url: https://github.com/alexrudd2/clickplc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickplc-0.12.0-1.src.rpm
checksum_type: sha256
description:
  Python ≥3.8 driver and command-line tool for [Koyo Ethernet ClickPLCs](https://www.automationdirect.com/adc/Overview/Catalog/Programmable_Controllers/CLICK_Series_PLCs_(Stackable_Micro_Brick)).
  <p align="center">
    <img src="https://www.automationdirect.com/microsites/clickplcs/images/expandedclick.jpg" />
  </p>


pkgId: 0f783b288a922c91e9ed7e114d4889d7058a3c79f963b60bc26037ec4f41d13d
name: python-clickpy-client
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Client for clickpy.clickhouse.com database
url: https://pypi.org/project/clickpy-client/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickpy-client-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Client for [clickpy.clickhouse.com](https://clickpy.clickhouse.com) database.

  [![PyPI](https://img.shields.io/pypi/v/clickpy-client)](https://pypi.org/project/clickpy-client/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/clickpy-client)](https://pypi.org/project/clickpy-client/)

  [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=rocshers_clickpy-client&metric=coverage)](https://sonarcloud.io/summary/new_code?id=rocshers_clickpy-client)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=rocshers_clickpy-client&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=rocshers_clickpy-client)

  [![Downloads](https://static.pepy.tech/badge/clickpy-client)](https://pepy.tech/project/clickpy-client)
  [![GitLab stars](https://img.shields.io/gitlab/stars/rocshers/python/clickpy-client)](https://gitlab.com/rocshers/python/clickpy-client)
  [![GitLab last commit](https://img.shields.io/gitlab/last-commit/rocshers/python/clickpy-client)](https://gitlab.com/rocshers/python/clickpy-client)



  ```bash
  pip install clickpy-client
  ```

  ```python
  import asyncio

  from clickpy import ClickPyClient


  async def main():
      clickpy = ClickPyClient()

      tables = await clickpy.get_tables()
      for table in tables:
          print(f'Database: {table.database}; table: {table.name} rows: {table.total_rows}')

      keywords = await clickpy.get_keywords_by_releases()
      for keyword in keywords:
          print(f'Database: {keyword.name}; releases: {keyword.releases}')


  asyncio.run(main())
  ```



  The client uses a public connection. But if you have your own DB instance with a similar structure, you can override the access parameters via environment variables.

  ```bash
  CLICKPY_HOST='https://clickpy-clickhouse.clickhouse.com'
  CLICKPY_SECURE=True
  CLICKPY_USERNAME='play'
  CLICKPY_PASSWORD=''
  ```





  Get all tables in `github` and `pypi` databases.



  Get all keywords based on project description. Sorted by number of releases.



  Issue Tracker: <https://gitlab.com/rocshers/python/clickpy-client/-/issues>
  Source Code: <https://gitlab.com/rocshers/python/clickpy-client>

  Before adding changes:

  ```bash
  make install-dev
  ```

  After changes:

  ```bash
  make format test
  ```


pkgId: 5ac7cfe095166616193dcd259de9f93ede77d7dc0770196a41995d1ac8885aa9
name: python-clicksend-client
arch: src
version: 5.0.78
epoch: 0
release: 1
summary: ClickSend v3 API
url: https://pypi.org/project/clicksend-client/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clicksend-client-5.0.78-1.src.rpm
checksum_type: sha256
description:
       This is an official SDK for [ClickSend](https://clicksend.com)  Below you will find a current list of the available methods for clicksend.  *NOTE: You will need to create a free account to use the API. You can register [here](https://dashboard.clicksend.com/#/signup/step1/)..*   # noqa: E501


pkgId: 7f310218cd9d1df11e89c08895c168e4d44e5964d35ae78420ae37f4843aab2c
name: python-clickshots
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A robust automated screenshot capture system
url: https://github.com/fadultech/clickshots
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickshots-0.1.1-1.src.rpm
checksum_type: sha256
description:
  A robust automated screenshot capture system that monitors user interactions.



  ```bash
  pip install -e .
  ```





  ```bash

  clickshots


  clickshots -d /path/to/save/directory
  clickshots --directory /path/to/save/directory
  ```



  ```python
  from clickshots import main


  main()


  main(save_dir="/path/to/save/directory")
  ```



  - **Ctrl + Shift**: Toggle mouse/touchpad screenshots
  - **Alt + \\**: Toggle keyboard screenshots
  - **Ctrl + C**: Exit program


pkgId: 46b07862e404581cf7138b6b2d8a8a544c0107b4c6e82bb89158589c89a3d0b7
name: python-clickshots
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A robust automated screenshot capture system
url: https://github.com/ayon1901/clickshots
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickshots-0.2.0-1.src.rpm
checksum_type: sha256
description:
  A robust automated screenshot capture system that monitors user interactions and saves screenshots based on configurable triggers.



  - Event-Based Capture: Takes screenshots based on mouse and keyboard events
  - Configurable Delays: Prevents spam by enforcing minimum delays between captures
  - Toggle Controls: Separate controls for mouse and keyboard monitoring
  - Organized Storage: Automatically saves screenshots with descriptive timestamps
  - Cross-Platform Support: Works on Linux, macOS, and Windows




  ```bash
  pip install clickshots
  ```


  ```bash

  git clone https://github.com/ayon1901/clickshots.git
  cd clickshots


  python -m venv venv
  source venv/bin/activate  # On Windows: venv\Scripts\activate


  pip install -e .[test]
  ```




  ```bash

  clickshots


  clickshots -d /path/to/save/directory
  ```


  ```python
  from clickshots import main


  main()


  main(save_dir="/path/to/save/directory")
  ```




  - **Ctrl + M**: Toggle mouse/touchpad screenshots
  - Left click/tap: Capture screenshot (when enabled)


  - **Alt + \\**: Toggle keyboard screenshots
  - Space/Enter: Capture screenshot (when enabled)


  - **Ctrl + C**: Exit program



  Screenshots are saved with descriptive names:
  ```
  round_{device_type}_{round_number}_{event_type}_{timestamp}.png
  ```

  Example: `round_mouse_1_left_click_20240320-143022.png`




  ```bash

  pytest


  pytest --cov=clickshots
  ```



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


pkgId: d664ec54802fe9c677946a503c8fc4b681fe235b10eacf5bd248ec5bdbd48257
name: python-clickup-apiV2
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A Python client for interacting with the ClickUp API V2.
url: https://github.com/lorithai/clickup_apiV2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickup-apiV2-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A Python client for interacting with the ClickUp API V2, providing convenient methods to fetch data, update tasks, and manage custom fields.
  Features

  * Retrieve team IDs.
  * Fetch workspaces, folders, lists, and tasks.
  * Get custom fields for a specific list.
  * Update task attributes.
  * Set custom field values for tasks.



  pip install


  Initialize the Client

  ```
  from clickup_apiV2 import Client

  api_token = "your_clickup_api_token"
  client = Client(api_token)
  ```

  1. Get Team IDs

  Retrieve the IDs of your teams.
  ```
  team_ids = client.get_team_id()
  print("Team IDs:", team_ids)
  ```
  2. Get Workspaces

  Fetch all workspaces (spaces) for a given team.
  ```
  team_id = "your_team_id"
  workspaces = client.get_workspaces(team_id)
  print("Workspaces:", workspaces)
  ```
  3. Get Workspace Folders

  Fetch all folders within a specific workspace.
  ```
  workspace_id = "your_workspace_id"
  folders = client.get_workspace_folders(workspace_id)
  print("Folders:", folders)
  ```
  4. Get Workspace Lists

  Retrieve lists directly under a workspace.
  ```
  workspace_id = "your_workspace_id"
  lists = client.get_workspace_lists(workspace_id)
  print("Lists:", lists)
  ```
  5. Get Folder Lists

  Fetch lists contained within a folder.
  ```
  folder_id = "your_folder_id"
  lists = client.get_folder_lists(folder_id)
  print("Folder Lists:", lists)
  ```
  6. Get List Tasks

  Retrieve all tasks in a specific list.
  ```
  list_id = "your_list_id"
  tasks = client.get_list_tasks(list_id)
  print("Tasks:", tasks)
  ```
  7. Get List Custom Fields

  Fetch all custom fields for a list.
  ```
  list_id = "your_list_id"
  custom_fields = client.get_list_custom_fields(list_id)
  print("Custom Fields:", custom_fields)
  ```
  8. Update a Task

  Update attributes of a task (e.g., name, status).
  ```
  task_id = "your_task_id"
  update_task_data = {
      "name": "New Task Name",
      "status": "in progress"
  }
  response = client.update_task(task_id, update_task_data)
  print("Task Update Response:", response)
  ```
  9. Set Task Custom Field Value

  Set or update a custom field value for a task.
  ```
  task_id = "your_task_id"
  field_id = "your_field_id"
  custom_field_data = {"value": "New Value"}

  response = client.set_task_custom_field_value(task_id, field_id, custom_field_data)
  print("Set Custom Field Response:", response)
  ```



  ```
  api_token = "your_clickup_api_token"
  client = Client(api_token)
  ```

  ```
  team_ids = client.get_team_id()

  if team_ids:
      team_id = team_ids[0]

      
      workspaces = client.get_workspaces(team_id)
      print("Workspaces:", workspaces)

      if workspaces:
          workspace_id = workspaces[0]["id"]

          
          lists = client.get_workspace_lists(workspace_id)
          print("Lists:", lists)

          if lists:
              list_id = lists[0]["id"]

              
              tasks = client.get_list_tasks(list_id)
              print("Tasks:", tasks)

              if tasks:
                  task_id = tasks[0]["id"]

                  
                  update_data = {"status": "completed"}
                  client.update_task(task_id, update_data)

                  
                  field_id = "your_field_id"
                  client.set_task_custom_field_value(task_id, field_id, {"value": "Updated Value"})
  ```
  Error Handling

  The client handles HTTP errors gracefully by catching requests.exceptions.RequestException and printing a relevant error message.



  Feel free to submit issues or pull requests to enhance the functionality.



  This project is licensed under the MIT License.


pkgId: 071ddfd21b3c1b58a64660c286529700475b71b5f4183dce1d66c60c33404153
name: python-clickup-apiv2
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A Python client for interacting with the ClickUp API V2.
url: https://github.com/lorithai/clickup_apiV2
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickup-apiv2-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A Python client for interacting with the ClickUp API V2, providing convenient methods to fetch data, update tasks, and manage custom fields.
  Features

  * Retrieve team IDs.
  * Fetch workspaces, folders, lists, and tasks.
  * Get custom fields for a specific list.
  * Update task attributes.
  * Set custom field values for tasks.


  ```
  pip install clickup-apiv2
  ```

  Initialize the Client

  ```
  from clickup_apiv2 import Client

  api_token = "your_clickup_api_token"
  client = Client(api_token)
  ```

  1. Get Team IDs

  Retrieve the IDs of your teams.
  ```
  team_ids = client.get_team_id()
  print("Team IDs:", team_ids)
  ```
  2. Get Workspaces

  Fetch all workspaces (spaces) for a given team.
  ```
  team_id = "your_team_id"
  workspaces = client.get_workspaces(team_id)
  print("Workspaces:", workspaces)
  ```
  3. Get Workspace Folders

  Fetch all folders within a specific workspace.
  ```
  workspace_id = "your_workspace_id"
  folders = client.get_workspace_folders(workspace_id)
  print("Folders:", folders)
  ```
  4. Get Workspace Lists

  Retrieve lists directly under a workspace.
  ```
  workspace_id = "your_workspace_id"
  lists = client.get_workspace_lists(workspace_id)
  print("Lists:", lists)
  ```
  5. Get Folder Lists

  Fetch lists contained within a folder.
  ```
  folder_id = "your_folder_id"
  lists = client.get_folder_lists(folder_id)
  print("Folder Lists:", lists)
  ```
  6. Get List Tasks

  Retrieve all tasks in a specific list.
  ```
  list_id = "your_list_id"
  tasks = client.get_list_tasks(list_id)
  print("Tasks:", tasks)
  ```
  7. Get List Custom Fields

  Fetch all custom fields for a list.
  ```
  list_id = "your_list_id"
  custom_fields = client.get_list_custom_fields(list_id)
  print("Custom Fields:", custom_fields)
  ```
  8. Update a Task

  Update attributes of a task (e.g., name, status).
  ```
  task_id = "your_task_id"
  update_task_data = {
      "name": "New Task Name",
      "status": "in progress"
  }
  response = client.update_task(task_id, update_task_data)
  print("Task Update Response:", response)
  ```
  9. Set Task Custom Field Value

  Set or update a custom field value for a task.
  ```
  task_id = "your_task_id"
  field_id = "your_field_id"
  custom_field_data = {"value": "New Value"}

  response = client.set_task_custom_field_value(task_id, field_id, custom_field_data)
  print("Set Custom Field Response:", response)
  ```



  ```
  api_token = "your_clickup_api_token"
  client = Client(api_token)
  ```

  ```
  team_ids = client.get_team_id()

  if team_ids:
      team_id = team_ids[0]

      
      workspaces = client.get_workspaces(team_id)
      print("Workspaces:", workspaces)

      if workspaces:
          workspace_id = workspaces[0]["id"]

          
          lists = client.get_workspace_lists(workspace_id)
          print("Lists:", lists)

          if lists:
              list_id = lists[0]["id"]

              
              tasks = client.get_list_tasks(list_id)
              print("Tasks:", tasks)

              if tasks:
                  task_id = tasks[0]["id"]

                  
                  update_data = {"status": "completed"}
                  client.update_task(task_id, update_data)

                  
                  field_id = "your_field_id"
                  client.set_task_custom_field_value(task_id, field_id, {"value": "Updated Value"})
  ```


  The client handles HTTP errors gracefully by catching requests.exceptions.RequestException and printing a relevant error message.



  Feel free to submit issues or pull requests to enhance the functionality.



  This project is licensed under the MIT License.


pkgId: 47ef8a3686f918715bed75e8a63b8ac56e589168d1db2f5b1579f0c4b01449f5
name: python-clickuphelper
arch: src
version: 0.3.7
epoch: 0
release: 1
summary: Python classes, cli, and tooling to interact with Clickup
url: https://github.com/newmanrs/clickuphelper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clickuphelper-0.3.7-1.src.rpm
checksum_type: sha256
description:
  Python classes, cli, and tooling to interact with Clickup.  Install with `git+https`, `setup.py` or `make`.  Install creates a few handy cli utilities for itneracting with clickup.



  You will need to provide your clickup team id and a [clickup api key](https://help.clickup.com/hc/en-us/articles/6303426241687-Getting-Started-with-the-ClickUp-API#personal-api-key).  Place them in the variables `CLICKUP_TEAM_ID`, `CLICKUP_API_KEY`



  CLI for working with single tasks
  `clickuptask --help`

  ```
  Usage: clickuptask [OPTIONS] TASK_ID COMMAND [ARGS]...

    Basic interface for probing clickup tasks. You must provide a task ID as
    first argument. Default behaviour is to print the task json object.
    Subcommands given afterwards be used to interact with the task object.

  Options:
    --help  Show this message and exit.

  Commands:
    cf            Print custom field object
    name          Print task name
    post-comment  Post comment as whomevers credentials you are using
    post-field    Post value to a custom field.
    post-status   Post new task status
    status        Print task status
    subtasks      Display subtasks of task
  ```



  Find and print information about lists

  ```
  clickuplist --help
  Usage: clickuplist [OPTIONS] SPACE_NAME FOLDER_NAME LIST_NAME

  Options:
    -d, --display [list_id|list_obj|status_names|statuses|tasks|task_count]
    --help                          Show this message and exit.
  ```

  Provide FOLDER_NAME as empty string `''` if the list exists directly in a space.  Display options affect print output.



  Prints all spaces, folders, and lists available in the entire account.  Provide optional flags to include task ids as well.

  ```
  Usage: clickuptree [OPTIONS]

  Options:
    -d, --display [no-tasks|tasks|subtasks]
    --help                          Show this message and exit
  ```

rpm_license:
  MIT License  Copyright (c) 2021 Richmond Newman  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: b86c15f807eaf146f25411ea4a2ed19ed56541dfbf18636c96aaf604cadbfc4c
name: python-cliconfig
arch: src
version: 1.4.4
epoch: 0
release: 1
summary: Merge your config files and set parameters from the command line in a simple way.
url: https://pypi.org/project/cliconfig/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cliconfig-1.4.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img
    src="https://raw.githubusercontent.com/valentingol/cliconfig/main/docs/_static/logo_extend_black.png"
    alt="CLI-Config-logo" width="100%" height="100%"
    />
  </p>

  *CLI Config* is a lightweight library that provides routines to merge nested configs
  and set parameters from command line. It contains many routines to create and manipulate
  the config as flatten or nested python dictionaries. It also provides processing functions
  that can change the whole configuration before and after each config manipulation.

  The package was initially designed for machine learning experiments where the
  number of parameters is huge and a lot of them have to be set by the user between
  each experiment. If your project matches this description, this package is for you!

  [![Release](https://img.shields.io/github/v/tag/valentingol/cliconfig?label=Pypi&logo=pypi&logoColor=yellow)](https://pypi.org/project/cliconfig/)
  ![PythonVersion](https://img.shields.io/badge/Python-3.7%20%7E%203.11-informational)
  [![License](https://img.shields.io/github/license/valentingol/cliconfig?color=999)](https://stringfixer.com/fr/MIT_license)

  [![Ruff_logo](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
  [![Black_logo](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  [![Ruff](https://github.com/valentingol/cliconfig/actions/workflows/ruff.yaml/badge.svg)](https://github.com/valentingol/cliconfig/actions/workflows/ruff.yaml)
  [![Flake8](https://github.com/valentingol/cliconfig/actions/workflows/flake.yaml/badge.svg)](https://github.com/valentingol/cliconfig/actions/workflows/flake.yaml)
  [![Pydocstyle](https://github.com/valentingol/cliconfig/actions/workflows/pydocstyle.yaml/badge.svg)](https://github.com/valentingol/cliconfig/actions/workflows/pydocstyle.yaml)
  [![MyPy](https://github.com/valentingol/cliconfig/actions/workflows/mypy.yaml/badge.svg)](https://github.com/valentingol/cliconfig/actions/workflows/mypy.yaml)
  [![PyLint](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/valentingol/ab12676c87f0eaa715bef0f8ad31a604/raw/cliconfig_pylint.json)](https://github.com/valentingol/cliconfig/actions/workflows/pylint.yaml)

  [![Tests](https://github.com/valentingol/cliconfig/actions/workflows/tests.yaml/badge.svg)](https://github.com/valentingol/cliconfig/actions/workflows/tests.yaml)
  [![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/valentingol/098e9c7c53be88779ee52ef2f2bc8803/raw/cliconfig_tests.json)](https://github.com/valentingol/cliconfig/actions/workflows/tests.yaml)
  [![Documentation Status](https://github.com/valentingol/cliconfig/actions/workflows/pdoc.yaml/badge.svg)](https://valentingol.github.io/cliconfig)

  Official badge :
  [![Config](https://custom-icon-badges.demolab.com/badge/cliconfig-black?logo=cliconfig)](https://github.com/valentingol/cliconfig)



  Here you can find the [documentation](https://valentingol.github.io/cliconfig) (built with pdoc3).

  The old documentation with readthedocs (1.3.6, not up to date) is also available
  [here](cliconfig.readthedocs.io).



  Here you can find the [Pypi page](https://pypi.org/project/cliconfig/).



  In a new virtual environment, simply install the package with:

  ```bash
  pip install cliconfig
  ```

  This package is OS independent and supported on Linux, macOS and Windows.



  See the [*Quick Start*](https://valentingol.github.io/cliconfig/cliconfig.html#quick-start)
  section of the documentation for a quick overview.

  First of all, make default config yaml file(s) in your project (configs are merged from left to right).
  Then you can create a config object from these files in python:

  ```python

  from cliconfig import make_config
  config = make_config('default1.yaml', 'default2.yaml')
  ```

  Now launch your script with eventually additional config file(s) and parameters by command line.
  The additional configs are merged on the default one's then the parameters are set.

  ```bash
  python main.py --config first.yaml,second.yaml --param1=1 --subconfig.param2='foo'
  ```

  **By default, these additional configs cannot add new parameters to the default config
  (for security and retro-compatibility reasons).**

  See the [*Edge cases*](https://valentingol.github.io/cliconfig/cliconfig.html#edge-cases)
  section of the documentation for some edge cases due to implementation.



  You can add tags `@<tag_name>` at the end of parameters names to activate some features.
  See the [*Quick start*](https://valentingol.github.io/cliconfig/cliconfig.html#quick-start)
  section of the documentation for a quick overview.

  The default tags include:

  * `@merge_add`, `@merge_before`, and `@merge_after`: merge other yaml files
    indicating the path
  * `@copy`: copy another parameter
  * `@def`: safely evaluate an expression to define the parameter value (a lot of
    operations and functions are available)
  * `@type:<my type>`: try to convert and check the type
  * `@select`: target a sub-config and delete the sub-config in the parent config
  * `@delete`: delete the key from the config
  * `@new`: allow adding parameters that are not present in default config
  * `@dict`: create a dict object that is not a sub-config (see the
  * [*Edge cases*](https://valentingol.github.io/cliconfig/cliconfig.html#edge-cases) section)

  It is also easy to create your own features and possibilities are endless. The way to do
  it are explained in the
  [*Processing*](https://valentingol.github.io/cliconfig/cliconfig.html#processing)
  section of the documentation.



  For **development**, install the package dynamically and dev requirements with:

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

  Everyone can contribute to CLI Config, and we value everyone’s contributions.
  Please see our [contributing guidelines](CONTRIBUTING.md) for more information 🤗



  This program is free software under the [MIT License](LICENSE).

  It means that:

  * If you use this package as a library without modifying it, there is no obligation
    regarding this license.
  * If you modify the source code of this package, you must keep the original copyright
    in the source code and add your own. The LICENSE file must also contain the original
    copyright (and the original MIT license notice if not sublicensed).
  * In any case, you can use this package in open source or closed source projects and for
    commercial or non-commercial purposes.

  Copyright © 2023 Valentin Goldité


pkgId: 2d9261d91226005227b53b1b43c9e3648f89f647709e5754f5cc3bb4dbf4547a
name: python-client-database
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A package for managing client database
url: https://pypi.org/project/client-database/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-client-database-0.0.1-1.src.rpm
checksum_type: sha256
description:
    
          This package provides tools for creating, populating, and querying a SQLite client database.


pkgId: 4c254e5133a7c2718f4294f18f386933d973e2741d9f355d1236fa844d4352e0
name: python-client-for3party
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A simple, reliable, and easy-to-debug unified client for third-party APIs
url: https://github.com/oerlock/client_for3party
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-client-for3party-0.1.5-1.src.rpm
checksum_type: sha256
description:
  A simple, reliable, and easy-to-debug unified client for third-party APIs, designed to provide users with an efficient API interface management and calling experience.


  1. [Base usage](https://github.com/oerlock/client_for3party/blob/main/examples/a1_basic_usage.py)


pkgId: 99849ef72733896a29b95932b44a1d0d272a86a96cc9780e1583fcd92f460c7d
name: python-client-for3party
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: A simple, reliable, and easy-to-debug unified client for third-party APIs
url: https://github.com/oerlock/client_for3party
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-client-for3party-0.1.7-1.src.rpm
checksum_type: sha256
description:
  A simple, reliable, and easy-to-debug unified client for third-party APIs, designed to provide users with an efficient API interface management and calling experience.
  * Auto Test
  * Pypi package


  1. [Base usage](https://github.com/oerlock/client_for3party/blob/main/examples/a1_basic_usage.py)


pkgId: a1d2aa41153fbf898adbffe28b20fdee84a1a8c4c1e361e394f5e3da9a330b92
name: python-client-onedoc
arch: src
version: 0.0.21
epoch: 0
release: 1
summary: Onedoc SDK for Python
url: https://github.com/onedoclabs/onedoc
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-client-onedoc-0.0.21-1.src.rpm
checksum_type: sha256
description:
  ![React email cover](https://pbs.twimg.com/profile_banners/1733139456645795840/1705969228/1500x500)

  <div align="center"><strong>Onedoc</strong></div>
  <div align="center">Onedocs makes it easy for developers to design beautiful PDFs. With our API, we make document generation simpler, faster, better.</div>
  <br />
  <div align="center">
  <a href="https://www.onedoclabs.com/">Website</a>
  <span> · </span>
  <a href="https://github.com/OnedocLabs/react-print">GitHub</a>
  <span> · </span>
  <a href="https://discord.com/invite/uRJE6e2rgr">Discord</a>
  <span> · </span>
  <a href="https://docs.onedoclabs.com">Documentation</a>
  </div>


  Stop spending hours making ugly documents, and start creating a dynamic experience now!

  Onedoc makes it easy for developers to generate beautiful PDFs. It is a comprehensive solution with:

  * An [open-source library](https://github.com/OnedocLabs/react-print-pdf) to design your documents.
  * A simple [API](https://docs.onedoclabs.com/api-reference/introduction) to generate your documents.
  * A [cloud platform](https://app.onedoclabs.com/) to host and track your documents.


  The first developer-oriented document platform. Generate, host and track documents with a single API.



  https://github.com/OnedocLabs/onedoc/assets/33000377/5bbda4a8-150c-48ed-877b-b0a805fa647f





  Billions of PDFs are generated daily: invoices, contracts, receipts, tickets,… yet there are no toolkits to allow companies to easily build them. Developers need to get their hands dirty to produce basic documents - let alone beautiful ones. This makes PDFs hard to dynamize and maintain, leading to poor brand experience and flawed analytics.


  Onedoc bridges the gap between developers and documents. We make modern web technologies work for PDF generation: React, Tailwind, … In turn, developers can make highly dynamic documents and iterate quickly. **What used to take hours now takes seconds with our API.**

  To make it even faster, we maintain an [open-source library](https://github.com/OnedocLabs/react-print-pdf) of beautiful components and templates and we offer a hosting and tracking service to better understand your documents.



  Onedoc is dedicated to transforming document management. We aim to empower businesses and developers to create, manage, and utilize documents more effectively, driving productivity and innovation in today's fast-paced, digital-first world.



  We previously worked with giant firms, where documents were central to most workflows. They would get passed around, get into client’s hands, and everyone would complain about their layout and lack of proper information. While at a large mining company, clients would want to see shipping information and product details on their invoices. However, the development team wouldn’t be able to update these documents because the task was too complex and expensive.



  - [Node.js SDK](https://www.npmjs.com/package/@onedoc/client)
  - [Component library](https://www.npmjs.com/package/@onedoc/react-print)




  - **[Auguste LEFEVRE](https://www.linkedin.com/in/augustelefevre/)**
    *EPF Lausanne and ETH Zürich graduate in Computer Science, Auguste built extensive knowledge in machine intelligence and data analytics. Continuing his academic journey with a PhD in Quantitative Finance at the National University of Singapore, he left to co-found Onedoc with Pierre and Titouan with the idea to reshape the document management experience.*

  - **[Titouan LAUNAY](https://www.linkedin.com/in/titouan-launay/)**
    *INSA Lyon graduate in civil engineering and architecture, Titouan is a self-taught computer programmer, developing and selling software to businesses since the age of 12. Co-founded an IT consulting company while studying, providing companies with data management and cloud consulting services. He now puts his effort into improving document management around the world.*

  - **[Pierre DORGE](https://www.linkedin.com/in/pierre-dorge-3372bb16a/)**
    *EPF Lausanne and ETH Zürich graduate in Computer Science specializing in machine intelligence and information security. Pierre built extensive experience in software engineering and data management as the co-founder of an IT consulting company and now decided to focus on revolutionizing the document management experiences.*


  There are many ways you can contribute to the sucees of Onedoc :

  * **Onedoc:** Check out our [website](https://www.onedoclabs.com/) and sign-up to our app to [get started](https://app.onedoclabs.com/)
  * **react-print-pdf:** Contribute to the [open-source library](https://github.com/OnedocLabs/react-print-pdf) and share components/templates with the community.
  * **Join the community:** Follow us on [X](https://twitter.com/Onedoclabs), [Linkedin](https://www.linkedin.com/company/onedoclabs/), and engage with others on [Discord](https://discord.com/invite/uRJE6e2rgr)


  ![intro](https://github.com/OnedocLabs/onedoc/assets/33000377/ee77e121-e1df-4b43-8684-53a1bcc9fc8b)


pkgId: 4640bff3fa28bb9a21954aa725260d9b9ab9fdb8fa2f2f7fa08f14fb27661897
name: python-client-render
arch: src
version: 0.71
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/telepenin/client-render/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-client-render-0.71-1.src.rpm
checksum_type: sha256
description:
  * Choose AMI windows instance (for example, ...) with GUI
  * Boot from image by hand (for example on the t2.medium)
  * Execute script (link), why it's needed:
      * disable antivirus (no required)
      * disable firewall (no required)
      * enable download files from internet (no required)
      * set autoload with specific user (needs for the screenshots)
          * add info to the regedit (DEFAULT_USER, DEFAULT_PASS)
          * Disable Ctrl+Alt+Del at Configuration\Windows Settings\Security Settings\Local Policies\Security
      * add bat file in the autoload folder
      * add ability to use user-data for the instance
      * additional installations:
          * install google chrome (no required)
          * install notepad++ (no required)
          * install python > 3.7
          * create virtualenv in the c:\venv\3dsmax\
  * Install necessary environment and enter license:
      * 3DS MAX
      * Corona renderer
  * Configure video driver for 3DS MAX
  * Shutdown
  * Save the Image


pkgId: 53f0eab57372ac0afbe668d70771437036506ae06d0e6a2b8be06c22a7e430e0
name: python-clientai
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: Simple unified API for multiple AI services.
url: https://pypi.org/project/clientai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clientai-0.3.3-1.src.rpm
checksum_type: sha256
description:
  **ClientAI** is a Python package that provides a unified interface for interacting with multiple AI providers, including OpenAI, Replicate, Groq and Ollama. It offers seamless integration and consistent methods for text generation and chat functionality across different AI platforms.


pkgId: cdbf9e5df35979f8a4e39ffa377d06ca0a3005d8c0fc9a7f54dbf0d1700e8923
name: python-clientcentral
arch: src
version: 12.5.9
epoch: 0
release: 1
summary: Client Central Python API.
url: https://github.com/EPI-USE-Labs/client-central-python-api
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clientcentral-12.5.9-1.src.rpm
checksum_type: sha256
description:
  [![version](https://img.shields.io/badge/version-12.5.9-brightgreen.svg)]()
  [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
  [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)


  ```bash
  pip install clientcentral --user
  ```

  ```bash
  pip install --user --upgrade clientcentral
  ```

  A specific version can also be installed by adding the tag:
  ```bash
  pip install --user --upgrade clientcentral==12.5.9
  ```


  This library was built and tested on `Python 3.11` a minimal Python version of `Python 3.7.x` is required.

  `Python 2` is not supported.


  - Object Oriented API
  - Querying
  - Lazy loading (Events)


  The token that will be used can either be sent as an environement variable:
  ```bash
  CC_TOKEN=<TOKEN> python3 main.py
  ```
  or parsed to the constructor:
  ```python
  cc = ClientCentral(production=True, token="123")
  ```



  ```python
  import clientcentral.ticketformatting as tf
  from clientcentral.clientcentral import ClientCentral


  cc = ClientCentral(production=True)




  ticket = cc.create_ticket(subject="New awesome subject" ,
                            description="this is an awesome ticket",
                            account_vp=1,
                            customer_user_vp=1,
                            project_id=8,
                            workspace_id=16,
                            custom_fields_attributes=[{
                                "id": 17,
                                "values": 0
                            }, {
                                "id": 75,
                                "values": 363
                            }])

  ticket.comment("<p>" + tf.bold("I am BOLD") + "</p>")


  print("Ticket creator: " + ticket.owner.name)


  print("Ticket status:" + ticket.status.name)


  print("Ticket description: " + ticket.description)


  ticket.add_user_watcher(14012) # 14012 refers to the user id in this case its "Thomas Scholtz"


  ticket.description = "New and improved ticket description"


  ticket.commit()

  for comment in ticket.comments:
      if comment.created_by_user:
          print("Comment from: " + comment.created_by_user.name + " says: " + comment.comment)


  for change_event in ticket.change_events:
      if change_event.created_by_user:
          print("Change by: " + str(change_event.created_by_user.name))
      for change in change_event.changes:
          print("Changed: " + str(change.name) + " from: " + str(change.from_value) + " to: " + str(change.to_value))
  ```


  ```python
  from clientcentral.clientcentral import ClientCentral
  import clientcentral.query as operators


  cc = ClientCentral(production=True)







  tickets = cc.query_tickets().filter_by(
              operators.and_( operators.statement("status.open"),
                              operators.comparison("workspace_id", "=", "87"),
                              operators.comparison("created_by_user.email", "=", "'thomas@labs.epiuse.com'"),
                              operators.comparison("updated_at", "<", "'2019-02-20'"),
                              operators.comparison("subject", "CONTAINS", "'New awesome subject'"))
                             ).all()

  for ticket in tickets:
      
      print("Ticket creator: " + ticket.owner.name)

      
      print("Ticket status:" + ticket.status.name)

      
      print("Ticket description: " + ticket.description)

      
      for comment in ticket.comments:
          if comment.created_by_user:
              print("Comment from: " + comment.created_by_user.name +
                    " says: " + comment.comment)
      for change_event in ticket.change_events:
          if change_event.created_by_user:
              print("Change by: " + str(change_event.created_by_user.name))
          for change in change_event.changes:
              print("Changed: " + str(change.name) + " from: " +
                    str(change.from_value) + " to: " + str(change.to_value))


  ```


  For this repository we are enforcing the use of `Commitizen`. Respective merge requests require to follow the format created from `Commitizen`. More info can be found at: http://commitizen.github.io/cz-cli/

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  Copyright (C) 2019 Thomas Scholtz  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  Client-Central-API-Python  Copyright (C) 2019 Thomas Scholtz This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: e936c3b0a8e51ee8d434f5d4c5058bca4f42809a3f2a5c7334a6bf0cc3d9fa7c
name: python-clientele
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: Generate loveable Python HTTP API Clients
url: https://phalt.github.io/clientele/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clientele-0.9.0-1.src.rpm
checksum_type: sha256
description:
  [![Package version](https://img.shields.io/pypi/v/clientele?color=%2334D058&label=latest%20version)](https://pypi.org/project/clientele)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/clientele?label=python%20support)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/clientele)
  ![PyPI - License](https://img.shields.io/pypi/l/clientele)

  Clientele lets you generate fully-typed, pythonic HTTP API Clients using an OpenAPI schema.

  It's easy to use:

  ```sh

  pipx install clientele

  clientele generate -u https://raw.githubusercontent.com/phalt/clientele/main/example_openapi_specs/best.json -o api_client/
  ```



  The generated code is designed by python developers, for python developers.

  It uses modern tooling and has a great developer experience.

  ```py
  from my_api import client, schemas


  data = schemas.RequestDataRequest(my_input="test")


  response = client.request_data_request_data_post(data=data)


  match response:
      case schemas.RequestDataResponse():
          
          ...
      case schemas.ValidationError():
          
          ...
  ```

  The generated code is tiny - the [example schema](https://github.com/phalt/clientele/blob/main/example_openapi_specs/best.json) we use for documentation and testing only requires [250 lines of code](https://github.com/phalt/clientele/tree/main/tests/test_client) and 5 files.



  You can choose to generate either a sync or an async client - we support both:

  ```py
  from my_async_api import client


  response = await client.simple_request_simple_request_get()
  ```



  * Written entirely in Python.
  * Designed to work with [FastAPI](https://fastapi.tiangolo.com/)'s and [drf-spectacular](https://github.com/tfranzel/drf-spectacular)'s OpenAPI schema generator.
  * The generated client only depends on [httpx](https://www.python-httpx.org/) and [Pydantic 2.4](https://docs.pydantic.dev/latest/).
  * HTTP Basic and HTTP Bearer authentication support.
  * Support your own configuration - we provide an entry point that will never be overwritten.
  * Designed for easy testing with [respx](https://lundberg.github.io/respx/).
  * API updated? Just run the same command again and check the git diff.
  * Automatically formats the generated client with [black](https://black.readthedocs.io/en/stable/index.html).


pkgId: 05ee6248ea274a0b696f29df9487c8763bcca773bb4b26eb4dee2b5949f10b33
name: python-clifford
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Numerical Geometric Algebra Module
url: http://clifford.readthedocs.io
rpm_license: bsd
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clifford-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://badgen.net/pypi/v/clifford)](https://pypi.org/project/clifford/)
  [![DOI](https://zenodo.org/badge/26588915.svg)](https://zenodo.org/badge/latestdoi/26588915)
  [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/pygae/clifford/master?filepath=examples%2Fg3c.ipynb)
  [![Documentation Status](https://readthedocs.org/projects/clifford/badge/?version=latest)](http://clifford.readthedocs.io/en/latest/?badge=latest)
  [![Build Status](https://github.com/pygae/clifford/actions/workflows/python-package.yml/badge.svg?branch=master)](https://github.com/pygae/clifford/actions/workflows/python-package.yml)
  [![Build Status](https://dev.azure.com/hadfieldhugo/clifford/_apis/build/status/pygae.clifford?branchName=master)](https://dev.azure.com/hadfieldhugo/clifford/_build/latest?definitionId=1&branchName=master)
  [![codecov](https://codecov.io/gh/pygae/clifford/branch/master/graph/badge.svg)](https://codecov.io/gh/pygae/clifford)
  `clifford` is a numerical Geometric Algebra (a.k.a. Clifford algebra) package for python.
  - **Documentation:** http://clifford.readthedocs.org
  - **Source code:** https://github.com/pygae/clifford
  - **Bug reports:** https://github.com/pygae/clifford/issues
  Geometric Algebra (GA) is a universal algebra which among several other independent mathematical systems, subsumes:
  * Complex numbers
  * Quaternions
  * Linear algebra
  Scalars, vectors, and higher-grade entities can be mixed freely and consistently in the form of mixed-grade multivectors. Like this,
  ![Visual explanation of blades](https://raw.githubusercontent.com/pygae/clifford/master/docs/_static/blades.png)


pkgId: 05a1fb731659b33cadbbf70e1284a6c95bec22b24dfa9289e075ca88519f91b6
name: python-cliffy
arch: src
version: 0.3.8
epoch: 0
release: 1
summary: $ cli load from.yaml
url: https://github.com/jaykv/cliffy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cliffy-0.3.8-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Workflow Status (with branch)](https://img.shields.io/github/actions/workflow/status/jaykv/cliffy/python-app.yaml?branch=main)](https://github.com/jaykv/cliffy/actions)
  [![PyPI](https://img.shields.io/pypi/v/cliffy)](https://pypi.org/project/cliffy/)
  ![GitHub](https://img.shields.io/github/license/jaykv/cliffy)


  cliffy is a YAML-defined CLI generator, manager, and builder for Python. It offers features to rapidly build, test, and deploy CLIs.


  * Write CLIs with YAML manifests
  * Manage CLIs- load, test, update, list, and remove
  * Built-in shell and Python scripting support
  * Supports Jinja2 templating
  * Hot-reload CLIs on manifest changes for easier development
  * Build CLIs into self-contained, single-file portable zipapps for sharing



  1. Define a manifest
  ```yaml

  name: hello
  version: 0.1.0

  commands:
    bash: $echo "hello from bash"
    python: print("hello from python")
  ```

  2. Load CLI
  ```
  $ cli load hello.yaml
  ```
  Parses `hello.yaml` to generate a Typer CLI and load it into the running Python environment.

  3. Run CLI directly

  `hello -h`

  ![hello-demo](docs/images/hello.png)

  For more examples, check [examples](examples/) directory.



  1. Define a manifest
  ```yaml

  name: requires
  version: 0.1.0

  requires:
    - requests >= 2.30.0
    - six

  imports:
    - import six

  commands:
    bash: $echo "hello from bash"
    python: print("hello from python")
    py: |
      if six.PY2:
          print("python 2")
      if six.PY3:
          print("python 3")
  ```

  2. Build CLI
  ```
  $ cli build requires.yaml -o dist
  ```

  Builds a portable zipapp containing the CLI and its package requirements.

  3. Run CLI
  ```
  ./dist/requires -h
  ```


  `cli <command>`
  * `init <cli name> --raw`: Generate a template CLI manifest for a new CLI
  * `load <manifest>`: Add a new CLI based on the manifest
  * `render <manifest>`: View generated CLI script for a manifest
  * `list` or `ls`: Output a list of loaded CLIs
  * `update <cli name>`: Reload a loaded CLI
  * `remove <cli name>` or `rm <cli name>`: Remove a loaded CLI
  * `run <manifest> -- <args>`: Runs a CLI manifest as a one-time operation
  * `build <cli name or manifest>`: Build a CLI manifest or a loaded CLI into a self-contained zipapp
  * `info <cli name>`: Display CLI metadata
  * `dev <manifest>`: Start hot-reloader for a manifest for active development


  1. Define CLI manifests in YAML files
  2. Run `cli` commands to load, build, and manage CLIs
  3. When loaded, cliffy parses the manifest and generates a [Typer](https://github.com/tiangolo/typer) CLI that is deployed directly as a script
  4. Any code starting with `$` will translate to subprocess calls via [PyBash](https://github.com/cliffy-sh/pybash)
  5. Run loaded CLIs straight from the terminal
  6. When ready to share, run `build` to generate portable zipapps built with [Shiv](https://github.com/linkedin/shiv)


  * `pip install "cliffy[rich]"` to include [rich-click](https://github.com/ewels/rich-click) for colorful CLI help output formatted with [rich](https://github.com/Textualize/rich).

  or

  * `pip install cliffy`


  Generated by `cli init`. For a barebones template, run `cli init --raw`
  ```yaml

  manifestVersion: v1



  name: cliffy



  version: 0.1.0




  includes: []




  requires: []





  vars:
      default_mood: happy



  imports:
      - import os
      - |
          from collections import defaultdict
          import re




  functions:
      - |
          def greet_name(name: str):
              print("hello " + name)



  types:
      Language: str = typer.Option("english", "-l", help="Language to greet in", prompt=True)




  args:
      world: [--name|-n: str!]                      # a REQUIRED option
      greet.all:
          - names: str!                             # a REQUIRED param as denoted by the ! at the end
          - mood: str = "{{default_mood}}"          # an OPTIONAL param that uses a manifest var as default
          - --language: Language                    # an option with a default that uses Language type as arg definition






  commands:
      
      world:
          - |
              """
              Help text for list
              """
              greet_name("world")
          - $ echo "i can also mix-and-match this command script to run bash commands"

      
      greet.all:
          - help: Help text for list.all       # you can also define help text like this
          - $ echo "hello all"                 # this is a bash command that will get converted to python subprocess call
          - print("greetings from python")     # this python code will get directly invoked

  ```


  ```
  poetry shell
  cli -h
  ```


pkgId: e1622e7e27067d9c117e304cd577a54dec51c93c12d16d4734fca41718195d5c
name: python-clifs
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Command line interface for basic file system operations.
url: https://pypi.org/project/clifs/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clifs-1.6.1-1.src.rpm
checksum_type: sha256
description:
  ![Lint](https://github.com/Don-Felice/clifs/workflows/Lint/badge.svg)
  ![Test](https://github.com/Don-Felice/clifs/workflows/Test/badge.svg)



  Multi-platform command line interface for file system operations.

  For installation run:

  ```powershell
  pip install clifs
  ```

  After installation all functionality can be accessed typing `clifs` in the command line, which alone will show a list of installed plugins.

  To implement your own plugin best inherit from the `clifs.ClifsPlugin` class.





  Rename files or directories using regular expressions. Supports options such as selecting files and folders by sub-string filter, time of the last modification or creation/change, or by list. Type `clifs ren --help` for a list of options. By default a preview mode is running to prevent unpleasant surprises.



  Command:

  ```powershell
  clifs ren ".\some_dir" --recursive --pattern "(?<!_suffix)\.(.*)" --replacement "_suffix.\1"
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_ren.png" width="800"/>



  Show disc usage for one or more directories.



  Command:

  ```powershell
  clifs du "some\dir\on\some_drive" "some\other\dir\on\some_other_drive" "some\other\dir\on\yet_another_drive"
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_du.png" width="800"/>



  Show a directory tree including sizes of folders and files. Supports options such as controlling the tree depth or showing folders only. Type `clifs tree --help` for a list of options.



  Command:

  ```powershell
  clifs tree .\clifs --depth 2
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_tree.png" width="800"/>



  Edit text files using regular expressions. Runs line by line and gives a preview of the changes by default. Supports options such as picking lines by number, selection of files by sub-string filter, time of the last modification or creation/change, or by list. Type `clifs sed --help` for a list of options.

  You can e.g. remove specific lines choosing `-pt ".*[\r\n]+" -l 5` or add lines in specific locations using `-pt "[\r\n]+" -rp "\nadded line\n" -l 3,4"`.



  ```powershell
  clifs sed ".\some\place" --pattern "(s\w*)" --replacement "no \1"  --lines 4-6 --recursive
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_sed.png" width="800"/>



  Copy files from one location to the other.
  Supports selection of files and folders by sub-string filter, time of the last modification or creation/change, or by list. Also supports flattening the folder hierarchy. Type `clifs cp --help` for a full list of options.



  Command:

  ```powershell
  clifs cp ".\some_source_dir" ".\some_dest_dir" --recursive --flatten --keep_all
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_cp.png" width="800"/>



  Move files from one location to the other.
  Supports selection of files and folders by sub-string filter, time of the last modification or creation/change, or by list. Also supports flattening the folder hierarchy. Type `clifs mv --help` for a full list of options.



  Command:

  ```powershell
  clifs mv ".\some_source_dir" ".\some_dest_dir" --recursive --skip_existing
  ```

  Output:
  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_mv.png" width="800"/>



  Delete files from the drive.
  Supports options such as selecting files and folders by sub-string filter, time of the last modification or creation/change, or by list. Type `clifs del --help` for a full list of options.



  Command:

  ```powershell
  clifs del ".\some_dir" --recursive --filterstring ".py"
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_del.png" width="800"/>



  Back up files and folders. Supports backing up via a config file giving multiple source/target pairs and the option to delete files which are not present in the source directory from the corresponding target directory.
  Type `clifs backup --help` for a full list of options.



  Command:

  ```powershell
  clifs backup --dir_source ".\some_source_dir" --dir_dest ".\some_dest_dir" --delete --verbose
  ```

  Output:

  <img src="https://github.com/Don-Felice/clifs/raw/v1.6.1/doc/imgs/example_backup.png" width="800"/>


pkgId: 49ae37a9418f8d88f379eb573e27d2f1fad1cd9148621e38493a220ecd3d6f50
name: python-cligj
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Click params for commmand line interfaces to GeoJSON
url: https://github.com/mapbox/cligj
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cligj-0.7.2-1.src.rpm
checksum_type: sha256
description:
  Common arguments and options for GeoJSON processing commands, using Click.
  `cligj` is for Python developers who create command line interfaces for geospatial data.
  `cligj` allows you to quickly build consistent, well-tested and interoperable CLIs for handling GeoJSON.


pkgId: 93150441509150ba8f9dd32ad442503140b2670416b86c9ca82f6bb0a8ff18c0
name: python-clikit
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: CliKit is a group of utilities to build beautiful and testable command line interfaces.
url: https://github.com/sdispater/clikit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clikit-0.6.2-1.src.rpm
checksum_type: sha256
description:
  CliKit is a group of utilities to build beautiful and testable command line interfaces.

  This is at the core of [Cleo](https://github.com/sdispater/cleo).


pkgId: c80f17f878948cd8a6a2348fabc6393d866e2142914d7b0f1486026c9502790a
name: python-clilib
arch: src
version: 3.7.4
epoch: 0
release: 1
summary: A library for setting up cli applications
url: https://github.com/gageleblanc/clilib
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clilib-3.7.4-1.src.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/v/clilib)
  ![](https://img.shields.io/pypi/pyversions/clilib)
  ![](http://img.shields.io/pypi/l/clilib)
  ![](https://github.com/gageleblanc/clilib/actions/workflows/build-publish.yml/badge.svg?branch=master)

  clilib is a python library that does some automatic setup for command-line applications as well as includes various
  utilities that can be used in many applications. This can be used to rapidly deploy cli applications in python.

  [Full documentation](https://clilib.symnet.io)



  To quickly turn your function or class into a CLI application based on its arguments, defaults, annotations, and docstrings,
  you will need a file that looks something like this:
  ```
  from clilib.util.logging import Logging
  from clilib.builders.app import EasyCLI


  class TestCommand:
      """
      A test command class
      """
      def __init__(self, debug: bool = False):
          """
          :param debug: Add additional debugging output.
          """
          self.debug = debug
          self.logger = Logging("TestCommand", debug=debug).get_logger()

      ...


  if __name__ == "__main__":
      e = EasyCLI(TestCommand)
  ```

  For a working example (an application included with the library that uses EasyCLI) check out [clilib.util.wheel](https://github.com/gageleblanc/clilib/blob/master/clilib/util/wheel.py).

  It's that easy! You can now execute this script from the command line, and you'll be able to pass any arguments your class
  or function requires.

  EasyCLI will register each non-private method in a class (sans __init__) as a subcommand with the same name whereas the __init__ method defines
  the base arguments. Arguments with defaults are added as flags, arguments without defaults are positionals, and any class
  within your class is treated as a subcommand (with its own methods being added as subcommands to itself)

  EasyCLI requires a docstring in order to populate the help information for your command line application. EasyCLI will fail
  without the docstring present. This is intentional, because it makes you document your code more consistently :)

  With the above out of the way, EasyCLI will produce something similar to the following when passed a class:
  ```
  usage: testapp.py [-h] [-d] {hello,goodbye} ...

  A test command class

  optional arguments:
    -h, --help       show this help message and exit
    -d, --debug      Add additional debugging output.

  subcommands:
    Available Subcommands

    {hello,goodbye}
      hello          Say hello
      goodbye        Say goodbye
  ```

  Some EasyCLI option highlights:
  * `enable_logging` (default False) will enable file logging of the CLI generation (by default, to /var/log/clilib/EasyCLI.log)
  * `print_return` (default False) will enable printing the return statement of the method your command resolves to.
  * `dump_json` (default True) will dump a list or dict return value to json before printing it. (only effective if `print_return` is true)


  You should keep in mind when using EasyCLI that it is built to provide a simple, quick command line application. Some things
  to try and remember when using EasyCLI is that you should do your best to adhere to standard python naming conventions [(PEP8),](https://www.python.org/dev/peps/pep-0008/#naming-conventions)
  particularly lowercase, underscored method names are best for EasyCLI. EasyCLI will replace underscores in subcommand names
  and argument names with hyphens, and will ignore private class methods (methods whose names start with an underscore).

  You may also tell EasyCLI to ignore a method in your class by putting ":easycli_ignore:" in its docstring.



  SearchableDict is a class that works just like a regular dict with the added functionality of being able to get and set
  values based on simple dot separated pathing.

  Example:
  ```
  >>> from clilib.util.dict import SearchableDict
  >>> d = SearchableDict()
  >>> d.set_path("foo.bar", "baz")
  >>> d.get_path("foo.bar")
  'baz'
  >>> d.get_path("foo.baz", "None!")
  'None!'
  ```


pkgId: cb5e55e4333222a57535cffd1427fb0e95cd1d4bf9bcdcbc8025130cf29417c1
name: python-climada
arch: src
version: 5.0.0
epoch: 0
release: 1
summary: CLIMADA in Python
url: https://github.com/CLIMADA-project/climada_python
rpm_license: OSI Approved :: GNU Lesser General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climada-5.0.0-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/112729129.svg)](https://zenodo.org/badge/latestdoi/112729129)
  [![Build Status](http://ied-wcr-jenkins.ethz.ch/buildStatus/icon?job=climada_branches/develop)](http://ied-wcr-jenkins.ethz.ch/job/climada_branches/)
  [![Documentation build status](https://img.shields.io/readthedocs/climada-python.svg?style=flat-square)](https://readthedocs.org/projects/climada-python/builds/)



  CLIMADA stands for **CLIM**ate **ADA**ptation and is a probabilistic natural catastrophe impact model, that also calculates averted damage (benefit) thanks to adaptation measures of any kind (from grey to green infrastructure, behavioural, etc.).

  As of today, CLIMADA provides global coverage of major climate-related extreme-weather hazards at high resolution (4x4km) via a [data API](https://climada.ethz.ch/data-api/v1/docs) For select hazards, historic and probabilistic events sets, for past, present and future climate exist at distinct time horizons.
  You will find a repository containing scientific peer-reviewed articles that explain software components implemented in CLIMADA [here](https://github.com/CLIMADA-project/climada_papers).

  CLIMADA is divided into two parts (two repositories):

  1. the core [climada_python](https://github.com/CLIMADA-project/climada_python) contains all the modules necessary for the probabilistic impact, the averted damage, uncertainty and forecast calculations. Data for hazard, exposures and impact functions can be obtained from the [data API](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_util_api_client.ipynb). [Litpop](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_entity_LitPop.ipynb) is included as demo Exposures module, and [Tropical cyclones](https://github.com/CLIMADA-project/climada_python/blob/main/doc/tutorial/climada_hazard_TropCyclone.ipynb) is included as a demo Hazard module.
  2. the petals [climada_petals](https://github.com/CLIMADA-project/climada_petals) contains all the modules for generating data (e.g., TC_Surge, WildFire, OpenStreeMap, ...). Most development is done here. The petals builds-upon the core and does not work as a stand-alone.

  It is recommend for new users to begin with the core (1) and the [tutorials](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial) therein.

  This is the Python (3.9+) version of CLIMADA - please see [here](https://github.com/davidnbresch/climada) for backward compatibility with the MATLAB version.



  CLIMADA runs on Windows, macOS and Linux.
  The released versions of CLIMADA are available from [conda-forge](https://anaconda.org/conda-forge/climada).
  Use the [Mamba](https://mamba.readthedocs.io/en/latest/) package manager to install it:

  ```shell
  mamba install -c conda-forge climada
  ```

  It is **highly recommended** to install CLIMADA into a **separate** Conda environment.
  See the [installation guide](https://climada-python.readthedocs.io/en/latest/guide/install.html) for further information.

  Follow the [tutorials](https://climada-python.readthedocs.io/en/stable/tutorial/1_main_climada.html) in a Jupyter Notebook to see what can be done with CLIMADA and how.



  The online documentation is available on [Read the Docs](https://climada-python.readthedocs.io/en/stable/).The documentation of each release version of CLIMADA can be accessed separately through the drop-down menu at the bottom of the left sidebar. Additionally, the version 'stable' refers to the most recent release (installed via `conda`), and 'latest' refers to the latest unstable development version (the `develop` branch).


  CLIMADA python:

  * [online (recommended)](https://climada-python.readthedocs.io/en/latest/)
  * [PDF file](https://climada-python.readthedocs.io/_/downloads/en/stable/pdf/)
  * [core Tutorials on GitHub](https://github.com/CLIMADA-project/climada_python/tree/main/doc/tutorial)

  CLIMADA petals:

  * [online (recommended)](https://climada-petals.readthedocs.io/en/latest/)
  * [PDF file](https://climada-petals.readthedocs.io/_/downloads/en/stable/pdf/)
  * [petals Tutorials on GitHub](https://github.com/CLIMADA-project/climada_petals/tree/main/doc/tutorial)

  The documentation can also be [built locally](https://climada-python.readthedocs.io/en/latest/README.html).



  See the [Citation Guide](https://climada-python.readthedocs.io/en/latest/misc/citation.html).

  Please use the following logo if you are presenting results obtained with or through CLIMADA:

  ![https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/img/CLIMADA_logo_QR.png](https://github.com/CLIMADA-project/climada_python/blob/main/doc/guide/img/CLIMADA_logo_QR.png?raw=true)



  We welcome any contribution to this repository, be it bugfixes and other code changes and additions, documentation improvements, or tutorial updates.

  If you would like to contribute, please refer to our [Contribution Guide](CONTRIBUTING.md).



  We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [releases on this repository](https://github.com/CLIMADA-project/climada_python/releases).



  Copyright (C) 2017 ETH Zurich, CLIMADA contributors listed in AUTHORS.

  CLIMADA is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License Version 3, 29 June 2007 as published by the Free Software Foundation, https://www.gnu.org/licenses/gpl-3.0.html

  CLIMADA is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details: https://www.gnu.org/licenses/gpl-3.0.html


pkgId: 882498e6954eb84681bc21cb03b2ea5d8e4fa60889e1b201f7d4d70a5cb3288b
name: python-climage
arch: src
version: 0.2.2
epoch: 0
release: 1
summary: Convert images to beautiful ANSI escape codes
url: https://pypi.org/project/climage/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climage-0.2.2-1.src.rpm
checksum_type: sha256
description:
  Convert images to beautiful ANSI escape codes for display in command line interfaces.

  Available as both a CLI application and a Python library.

  ![demo](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/demo.png)


   - Custom sized images
   - ASCII or Unicode support
      - Unicode enables 4x more detail
   - 8/16/256/Truecolor support, for a wider gamut of colors
   - Selectable system palettes to adjust for user terminal themes
   - Fast color lookup with KDTrees & memoization



  CLImage is available as both a standalone CLI program, or available for import as a Python3 library.



  By default converting an image will output in 256 color, as 80 columns, and ASCII (for reasonable compatibility).
  ```bash
  $ climage image.png
  ```
  ![demo](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/warhol256ascii.png)


  A nicer image can be obtained when enabling unicode and truecolor flags.
  ```bash
  $ climage --unicode --truecolour image.png
  ```
  ![demo](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/warholtruecolorunicode.png)

  For display in TTYs such as the Linux terminal before starting X11 (also accessible by Ctrl-Alt-F3, etc), you should restrict yourself to 8 color, and ASCII only. As 8 and 16 colors are solely constructed out of system colors (often set by the terminal theme), it is recommended to select a palette for these, depending on what you have selected.
  ```bash
  $ climage --8color warhol.png --palette solarized
  ```
  ![demo](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/warhol8colsolarized.png)

  Further options may be found by running `climage --help`



  It is recommended that you use the Python library if converting a large number of images. Simple usage:

  ```python3
  import climage


  output = climage.convert('image.png', is_unicode=True, width=50)
  print(output)


  climage.to_file('image.png', 'out.txt', is_8color=True, width=100)
  ```


  The API also supports supplying a [Pillow](https://pypi.org/project/Pillow/) Image object, or a [numpy](https://numpy.org/) array representing an image.

  These formats may be useful if you have already loaded from file, or are applying complex filters to the images prior to rendering.

  Pillow Images can be converted via the `convert_pil` function:

  ```python3
  import climage
  from PIL import Image





  img = Image.open('image.png').convert('RGB')
  output = climage.convert_pil(img, is_unicode=True)
  print(output)
  ```

  Similarly, numpy arrays are converted using the `convert_arr` function. In the example below we use Pillow to generate the numpy array, but any row-major array whose element represents an RGB triplet. Each colour is represented by a number in the range [0,255].

  ```python3
  import climage
  from PIL import Image



  img = Image.open('image.png').convert('RGB').resize((50, 50))
  arr = np.array(img)
  output = climage.convert_array(arr, is_unicode=True)
  print(output)

  ```

  Python lists are also accepted:

  ```
  from climage import convert_array


  print(
    convert_array([
      [[128, 128, 0], [0, 128, 128]],
      [[0, 128, 0], [0, 0, 128]],
    ], is_unicode=True)
  )
  ```

  Output:

  ![python list example](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/python-list.png)



  To provide you more expressiveness and flexibility, various helper methods are exposed.

  ```python3
  from climage import color_to_flags, color_types, convert








  print(convert('teapot.png', is_unicode=True, **color_to_flags(color_types.truecolor)))

  ```

  Output:

  ![teapot example](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/teapot-example.png)

  ```python3
  from climage import get_ansi_pixel, get_reset_code, color_types






  pix = get_ansi_pixel(
    
    (148, 0, 211),
    ctype=color_types.truecolor,
  )



  print(pix + get_reset_code())
  ```

  Output:

  ![single pixel example](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/single-pixel.png)


  ```python3
  from climage import get_dual_unicode_ansi_pixels, get_reset_code, color_types




  pixels = get_dual_unicode_ansi_pixels(
    
    (0, 128, 0),
    
    (128, 0, 0),
    ctype=color_types.color256,
    palette="solarized",
  )
  print(pixels + get_reset_code())
  ```

  Output:

  ![dual pixel unicode example](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/dual-pixel.png)


  As `climage` can convert arbitrary images in memory, converting images on the Internet is possible using the `requests` library:

  ```python3
  import requests
  import climage
  from io import BytesIO

  response = requests.get('https://www.python.org/static/community_logos/python-logo-master-v3-TM-flattened.png')


  img = Image.open(BytesIO(response.content)).convert('RGB')

  converted = climage.convert_pil(img, is_unicode=True)
  print(converted)
  ```

  Output:

  ![internet conversion](https://raw.githubusercontent.com/pnappa/CLImage/master/extra/internet-conversion.png)

  Note that caching the image may be more efficient for multiple invocations.


   - [ ] Improve performance in 256 color mapping, see [here](https://github.com/pnappa/CLImage/issues/1)
   - Ideas? Let me know by filing an issue. :)


pkgId: 4279b2a9e7132788957d8fde5450b41b1a31c72b0a6730e5d5b03e80849709c3
name: python-climate-categories
arch: src
version: 0.10.2
epoch: 0
release: 1
url: https://github.com/pik-primap/climate_categories
rpm_license: Apache Software License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climate-categories-0.10.2-1.src.rpm
checksum_type: sha256
summary:
  Commonly used codes, categories, terminologies, and nomenclatures used in climate policy analysis as a Python package.


pkgId: 8c9f441e67c30e72c7858ff9df49d52245c67af8b0d72bf4cbd89419f74e9aeb
name: python-climate-resilience
arch: src
version: 0.4.10
epoch: 0
release: 1
summary: Download, Preprocessing, and Visualization code for climate resilience data.
url: https://github.com/ALTEMIS-DOE/climate-resilience.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climate-resilience-0.4.10-1.src.rpm
checksum_type: sha256
description:
  This file requires a [`download_params.yml`](https://github.com/satyarth934/lbnl-climate-resilience/blob/main/examples/climate-resilience/scripts/download_params.yml) file to specify the download configurations.


pkgId: b7b6b59a69c25f8f7cfe60530e074efe89a1b03ff7f6b5f2dfa5ac7f358d76dd
name: python-climate-trace
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: A package for loading and analyzing data from the Climate TRACE consortium.
url: https://github.com/tjhunter/climate-trace-handbook/
rpm_license: CC BY-SA 4.0 Deed
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climate-trace-0.3.0-1.src.rpm
checksum_type: sha256
description:
  This reposity contains:
  - the source to the Climate TRACE handbook for data scientists (published [here](https://tjhunter.github.io/climate-trace-handbook/))
  - the [ctrace](https://pypi.org/project/climate-trace/) python package, used to access and manipulate the Climate TRACE dataset

  **Relationship to the Climate TRACE project** Both projects are unofficial and unrelated
  to the Climate TRACE project. The Climate TRACE consortium does not sponsor
  or endorse any content in this repository. Any analysis, error, conclusion contained in these pages should not be attributed to the Climate TRACE project.


pkgId: ce53535b870434f5872d059567da246909844c529680c039fbec60f9a0412062
name: python-climatePy
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: A Python package for getting point and gridded climate data by AOI.
url: https://pypi.org/project/climatePy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climatePy-0.5.1-1.src.rpm
checksum_type: sha256
description:
  <br>

  If you would like to contribute, submit a PR and we will get to as soon as we can!
  If you have any issues please open an issue on GitHub. For any questions, feel free to ask [@anguswg-ucsb](https://github.com/anguswg-ucsb) or [@mikejohnson51](https://github.com/mikejohnson51), or simply create an issue on GitHub.


pkgId: 4fa553849810189186d8d6f5d34b1b9102d546200794b0148b0c5c96b508b31c
name: python-climateserv
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: This is a package to access the ClimateSERV API](https://climateserv.servirglobal.net/)
url: https://github.com/servir/ClimateSERVpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climateserv-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Python: 3.7](https://img.shields.io/badge/python-3.7-blue.svg)](https://www.python.org/)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![SERVIR: Global](https://img.shields.io/badge/SERVIR-Global-green)](https://servirglobal.net)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11582736.svg)](https://doi.org/10.5281/zenodo.11582736)

  This is a python package to access the [ClimateSERV API](https://climateserv.servirglobal.net/)
  you can install using conda or pip:
  * conda install -c servir climateserv
  * pip install climateserv


  * Timeseries CSV
      * Variables
          * Average
          * Min
          * Max
  * Download Zip file of tifs
      * Variable
          * Download
  * Download Zip file containing a NetCDF
      * Variable
          * NetCDF



  We are moving to the dataset numbers to match the way ClimateSERV handles the datasets.  We will continue to
  support the prior named variables for the datasets, but recommend updating to use the integer values.  This will
  allow any future datasets that are added to be accessed by their ID found on ClimateSERV even if this documentation
  is not yet updated.

  * UCSB CHIRPS Rainfall: 0
  * eMODIS West Africa NDVI: 1
  * eMODIS East Africa NDVI: 2
  * eMODIS Southern Africa NDVI: 5
  * IMERG 1 Day (late): 26
  * eMODIS Central Asia NDVI: 28
  * Evaporative Stress Index (ESI) 4 week: 29
  * CHIRPS GEFS Anomalies: 31
  * CHIRPS GEFS Precipitation: 32
  * Evaporative Stress Index (ESI) 12 week: 33
  * NASA-USDA Enhanced SMAP Global Soil moisture profile: 37
  * NASA-USDA Enhanced SMAP Global Surface soil moisture: 38
  * NASA-USDA Enhanced SMAP Global Surface soil moisture anomaly: 39
  * NASA-USDA Enhanced SMAP Global Subsurface soil moisture: 40
  * NASA-USDA Enhanced SMAP Global Subsurface soil moisture anomaly: 41
  * UCSB CHIRP Rainfall: 90
  * IMERG 1 Day (early): 91
  * NSIDC SMAP Sentinel 1Km: 541
  * NSIDC SMAP Sentinel 1Km 15 day: 542
  * LIS-modeled Evapotranspiration: 661
  * LIS-modeled Baseflow: 662
  * LIS-Modeled Runoff: 663
  * LIS-Modeled Soil Moisture 0-10cm: 664
  * LIS-Modeled Soil Moisture 10-40cm: 665
  * LIS-Modeled Soil Moisture 40-100cm: 666
  * LIS-Modeled Soil Moisture 100-200cm: 667


  NMME forecast datasets:


  * NMME ccsm4 ens01 Temperature: 6
  * NMME ccsm4 ens01 Precipitation: 7
  * NMME ccsm4 ens02 Temperature: 8
  * NMME ccsm4 ens02 Precipitation: 9
  * NMME ccsm4 ens03 Temperature: 10
  * NMME ccsm4 ens03 Precipitation: 11
  * NMME ccsm4 ens04 Temperature: 12
  * NMME ccsm4 ens04 Precipitation: 13
  * NMME ccsm4 ens05 Temperature: 14
  * NMME ccsm4 ens05 Precipitation: 15
  * NMME ccsm4 ens06 Temperature: 16
  * NMME ccsm4 ens06 Precipitation: 17
  * NMME ccsm4 ens07 Temperature: 18
  * NMME ccsm4 ens07 Precipitation: 19
  * NMME ccsm4 ens08 Temperature: 20
  * NMME ccsm4 ens08 Precipitation: 21
  * NMME ccsm4 ens09 Temperature: 22
  * NMME ccsm4 ens09 Precipitation: 23
  * NMME ccsm4 ens10 Temperature: 24
  * NMME ccsm4 ens10 Precipitation: 25


  * NMME cfsv2 ens01 Temperature: 42
  * NMME cfsv2 ens01 Precipitation: 43
  * NMME cfsv2 ens02 Temperature: 44
  * NMME cfsv2 ens02 Precipitation: 45
  * NMME cfsv2 ens03 Temperature: 46
  * NMME cfsv2 ens03 Precipitation: 47
  * NMME cfsv2 ens04 Temperature: 48
  * NMME cfsv2 ens04 Precipitation: 49
  * NMME cfsv2 ens05 Temperature: 50
  * NMME cfsv2 ens05 Precipitation: 51
  * NMME cfsv2 ens06 Temperature: 52
  * NMME cfsv2 ens06 Precipitation: 53
  * NMME cfsv2 ens07 Temperature: 54
  * NMME cfsv2 ens07 Precipitation: 55
  * NMME cfsv2 ens08 Temperature: 56
  * NMME cfsv2 ens08 Precipitation: 57
  * NMME cfsv2 ens09 Temperature: 58
  * NMME cfsv2 ens09 Precipitation: 59
  * NMME cfsv2 ens10 Temperature: 60
  * NMME cfsv2 ens10 Precipitation: 61
  * NMME cfsv2 ens11 Temperature: 62
  * NMME cfsv2 ens11 Precipitation: 63
  * NMME cfsv2 ens12 Temperature: 64
  * NMME cfsv2 ens12 Precipitation: 65
  * NMME cfsv2 ens13 Temperature: 66
  * NMME cfsv2 ens13 Precipitation: 67
  * NMME cfsv2 ens14 Temperature: 68
  * NMME cfsv2 ens14 Precipitation: 69
  * NMME cfsv2 ens15 Temperature: 70
  * NMME cfsv2 ens15 Precipitation: 71
  * NMME cfsv2 ens16 Temperature: 72
  * NMME cfsv2 ens16 Precipitation: 73
  * NMME cfsv2 ens17 Temperature: 74
  * NMME cfsv2 ens17 Precipitation: 75
  * NMME cfsv2 ens18 Temperature: 76
  * NMME cfsv2 ens18 Precipitation: 77
  * NMME cfsv2 ens19 Temperature: 78
  * NMME cfsv2 ens19 Precipitation: 79
  * NMME cfsv2 ens20 Temperature: 80
  * NMME cfsv2 ens20 Precipitation: 81
  * NMME cfsv2 ens21 Temperature: 82
  * NMME cfsv2 ens21 Precipitation: 83
  * NMME cfsv2 ens22 Temperature: 84
  * NMME cfsv2 ens22 Precipitation: 85
  * NMME cfsv2 ens23 Temperature: 86
  * NMME cfsv2 ens23 Precipitation: 87
  * NMME cfsv2 ens24 Temperature: 88
  * NMME cfsv2 ens24 Precipitation: 89





  This is sample code to produce a time series csv using the CentralAsia_eModis dataset.  If you were to choose the OperationType of Download you would need to change the Outfile from .csv to .zip If you would like the data returned as a json object to a variable set Outfile to 'memory_object' and create a variable to hold the return from the climateserv.api.request_data call.
  <pre>
  import climateserv

  x = 81.27
  y = 29.19

  GeometryCoords = [[x-.01,y+.01],[x+.01, y+.01],
                    [x+.01, y-.01],[x-.01,y-.01],[x-.01,y+.01]]

  DatasetType = 28
  OperationType = 'Average'
  EarliestDate = '01/03/2018'
  LatestDate = '03/16/2018'
  SeasonalEnsemble = '' # Leave empty when using the new integer dataset IDs
  SeasonalVariable = '' # Leave empty when using the new integer dataset IDs
  Outfile = 'out.csv'

  climateserv.api.request_data(DatasetType, OperationType,
               EarliestDate, LatestDate,GeometryCoords,
               SeasonalEnsemble, SeasonalVariable,Outfile)
  </pre>




  ClimateSERVpy is distributed by SERVIR under the terms of the MIT License. See
  [LICENSE](https://github.com/SERVIR/ClimateSERVpy/blob/master/LICENSE) in this directory for more information.



  ClimateSERVpy abides to all of SERVIR's privacy and terms of use as described
  at [https://servirglobal.net/Privacy-Terms-of-Use](https://servirglobal.net/Privacy-Terms-of-Use).


pkgId: 1928ebf396fcad639d5eb663680a4675c6e9f949c727bdd2868cac3e12c5e923
name: python-climetlab
arch: src
version: 0.24.0
epoch: 0
release: 1
summary: Handling of climate/meteorological dataa.
url: https://github.com/ecmwf/climetlab/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climetlab-0.24.0-1.src.rpm
checksum_type: sha256
rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright 2020 European Centre for Medium-Range Weather Forecasts  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: a9d79238ae092033c74f7de2d91083d3b22349d9802301f093a6fd2dfab2b25b
name: python-climetlab-cems-flood
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Download GloFAS Copernicus Emergency Management System dataset
url: https://github.com/iacopoff/climetlab-cems-flood
rpm_license: Apache License Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climetlab-cems-flood-0.2.6-1.src.rpm
checksum_type: sha256
description:
  | **Build Status**                                                                                |
  |:-------------------------------------------------------------------------------:|
  |![Build Status](https://github.com/iacopoff/climetlab-cems-flood/workflows/pytest/badge.svg)|

  Download GloFAS data from the Climate Data Store.

  ```python
  import climetlab as cml

  dataset = cml.load_dataset(
              'glofas-seasonal',
              model='lisflood',
              system_version='operational',
              temporal_filter= '2022 01 01',
              leadtime_hour = '24-72',
              variable="river_discharge_in_the_last_24_hours"
  )

  ds = dataset.to_xarray()

  ds
  (<xarray.Dataset>
   Dimensions:                  (realization: 51, forecast_reference_time: 1,
                                 leadtime: 3, lat: 1500, lon: 3600)
   Coordinates:
     * realization              (realization) int64 0 1 2 3 4 5 ... 46 47 48 49 50
     * forecast_reference_time  (forecast_reference_time) datetime64[ns] 2022-01-01
     * leadtime                 (leadtime) timedelta64[ns] 1 days 2 days 3 days
     * lat                      (lat) float64 -59.95 -59.85 -59.75 ... 89.85 89.95
     * lon                      (lon) float64 -179.9 -179.8 -179.8 ... 179.8 540.0
       time                     (forecast_reference_time, leadtime) datetime64[ns] ...
   Data variables:
       dis24                    (realization, forecast_reference_time, leadtime, lat, lon) float32 ...
   Attributes:
       GRIB_edition:            2
       GRIB_centre:             ecmf
       GRIB_centreDescription:  European Centre for Medium-Range Weather Forecasts
       GRIB_subCentre:          0
       Conventions:             CF-1.7
       institution:             European Centre for Medium-Range Weather Forecasts
       history:                 2023-01-02T10:51 GRIB to CDM+CF via cfgrib-0.9.1...,)


  ```

  More
  [example requests](https://climetlab-cems-flood.readthedocs.io/en/latest/how_to.html)
  and
  [documentation](https://climetlab-cems-flood.readthedocs.io/)


pkgId: 2c8f21234ff8e7b22aea45b4194dcf5d3c9410739a709fb7b09da76876347e74
name: python-climpred
arch: src
version: 2.5.0
epoch: 0
release: 1
summary: """Verification of weather and climate forecasts and prediction."""
url: https://climpred.readthedocs.io/en/stable/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-climpred-2.5.0-1.src.rpm
checksum_type: sha256
description:
  You can install the latest release of ``climpred`` using ``pip`` or ``conda``:
      python -m pip install climpred[complete]
      conda install -c conda-forge climpred
  You can also install the bleeding edge (pre-release versions) by cloning this
  repository or installing directly from GitHub:
      git clone https://github.com/pangeo-data/climpred.git
      cd climpred
      python -m pip install . --upgrade
      pip install git+https://github.com/pangeo-data/climpred.git

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


pkgId: 8f260411f1d360aa1e4ca5bd8d84b9a3fcdbb7b699f339836ed2eb2e1cf1f1e2
name: python-clin
arch: src
version: 1.8.0
epoch: 0
release: 1
summary: Cli for Nakadi resources management in Infrastructure as Code style
url: https://github.com/zalando-incubator/clin
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clin-1.8.0-1.src.rpm
checksum_type: sha256
description:
  **Clin** is a command-line utility to manage [Nakadi](https://nakadi.io/)
  resources from schema files in "Infrastructure as Code" style.
  ![](https://github.com/zalando-incubator/clin/raw/master/docs/gifs/demo.gif)





  * [Python](https://www.python.org/) >= 3.7


  You can install **clin** directly from [PyPI](https://pypi.org/project/clin/)
  using pip:

  ```bash
  pip install clin
  ```



  After this you should be able to run the `clin` tool:
  ```bash
  ~ clin --help
  Usage: clin [OPTIONS] COMMAND [ARGS]...
  ...
  ```

  Please refer to the [documentation](https://github.com/zalando-incubator/clin/tree/master/docs)
  and [examples](https://github.com/zalando-incubator/clin/tree/master/docs/examples).



  Please read [CONTRIBUTING](https://github.com/zalando-incubator/clin/blob/master/CONTRIBUTING.md)
  for details on our process for submitting pull requests to us, and please ensure
  you follow the [CODE_OF_CONDUCT](https://github.com/zalando-incubator/clin/blob/master/CODE_OF_CONDUCT.md).



  * [Python](https://www.python.org/) >= 3.7
  * [Poetry](https://python-poetry.org/) for packaging and dependency
    management. See the [official docs](https://python-poetry.org/docs/) for
    instructions on installation and basic usage.


  After cloning the repository, use `poetry` to create a new virtual environment
  and restore all dependencies.

  ```bash
  poetry install
  ```

  If you're using an IDE (eg. PyCharm), make sure that it's configured to use the
  virtual environment created by poetry as the project's interpreter. You can find
  the path to the used environment with `poetry env info`.



  ```bash
  poetry run pytest
  ```



  We use [SemVer](http://semver.org) for versioning. For the versions available,
  see the [tags on this repository](https://github.com/zalando-incubator/clin/tags).



  * **Dmitry Erokhin** [@Dmitry-Erokhin](https://github.com/Dmitry-Erokhin)
  * **Daniel Stockhammer** [@dstockhammer](https://github.com/dstockhammer)

  See also the list of [contributors](Chttps://github.com/zalando-incubator/clin/blob/master/ONTRIBUTORS.md)
  who participated in this project.



  This project is licensed under the MIT License. See the
  [LICENSE](https://github.com/zalando-incubator/clin/blob/master/LICENSE) file
  for details.


pkgId: 5557bcad749d814f080644b6190affe407af45fdaf697bdc00c21c50998cd88d
name: python-cline
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Command line interface builder
url: https://github.com/cariad/cline
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cline-1.2.2-1.src.rpm
checksum_type: sha256
description:
  **Cline** is a Python package that helps you build command line applications by separating the concerns of _understanding the command line arguments you receive_ and _operating on strongly-typed arguments_, and helps you to write clean, testable tasks.

  <edition value="toc" />





  Cline requires **Python 3.8 or later**.

  Install Cline via pip:

  ```bash
  pip install cline
  ```



  1. Create a `Cli` class to parse arguments and orchestrate tasks.
  1. Create `Task` classes to describe the work that your application can perform.
  1. On startup, invoke your CLI's `invoke_and_exit()` method. Cline will discover and invoke the most appropriate `Task` for the given arguments.

  The examples below go into detail.





  _The source code for this example is available at [github.com/cariad/cline/blob/main/examples/example01](https://github.com/cariad/cline/blob/main/examples/example01). The tests are in [github.com/cariad/cline/blob/main/tests/examples/example01](https://github.com/cariad/cline/blob/main/tests/examples/example01)._

  In this example, we'll build a command line application that sums two integers then prints the result:

  ```bash
  python -m examples.example01 1 3
  ```

  <!--edition-exec as=markdown fence=backticks host=shell range=start-->

  ```text
  4
  ```

  <!--edition-exec range=end-->



  For this example, we'll parse the command line arguments with Python's baked-in `ArgumentParser`. Cline provides an `ArgumentParserCli` base class for this.

  Create a class named `ExampleCli` that inherits from `cline.ArgumentParserCli`. Override `make_parser()` to return an `ArgumentParser` that accepts two numbers.

  For example:

  ```python
  from argparse import ArgumentParser
  from cline import ArgumentParserCli

  class ExampleCli(ArgumentParserCli):
      def make_parser(self) -> ArgumentParser:
          parser = ArgumentParser()
          parser.add_argument(
            "a",
            help="first number",
            nargs="?",
          )
          parser.add_argument(
            "b",
            help="second number",
            nargs="?",
          )
          return parser
  ```



  A task does two things:

  1. Converts the command line arguments to strongly-typed task arguments
  1. Operates on strongly-typed task arguments

  We'll start with the strongly-typed task arguments. Since we'll be summing two integers, let's define a dataclass that holds two integers:

  ```python
  from dataclasses import dataclass

  @dataclass
  class NumberArgs:
      a: int
      b: int
  ```

  Now we need a way to convert command line arguments to these task arguments. Create a class named `SumTask` and inherit from `cline.Task`. `Task` is generic and requires your strongly-typed arguments type.

  ```python
  from dataclasses import dataclass
  from cline import CommandLineArguments, Task

  @dataclass
  class NumberArgs:
      a: int
      b: int

  class SumTask(Task[NumberArgs]):
      pass
  ```

  To convert command line arguments to strongly-typed task arguments, override the `make_args()` method:

  ```python
  from dataclasses import dataclass
  from cline import CommandLineArguments, Task

  @dataclass
  class NumberArgs:
      a: int
      b: int

  class SumTask(Task[NumberArgs]):
      @classmethod
      def make_args(cls, args: CommandLineArguments) -> NumberArgs:
          return NumberArgs(
              a=args.get_integer("a"),
              b=args.get_integer("b"),
          )
  ```

  `CommandLineArguments` wraps the parsed command line arguments with some handy functions for reading argument values.

  For example, since we named the two numbers `a` and `b` in the parser earlier, we can refer to them by name and call `get_integer()` to get their values.

  Note that `CommandLineArguments` will raise `CannotMakeArguments` if `a` or `b` aren't set or can't be parsed as integers. This is the correct way to indicate that task arguments cannot be made for a given task. You don't need to validate the arguments yourself.

  Now that `SumTask` knows how to create strongly-typed arguments, we can operate on them.

  Override the `invoke()` method to:

  1. Operate on `self.args`
  1. Write output to `self.out`
  1. Return the shell exit code

  In this example, `invoke()` sums the two integer arguments, writes the result, then returns `0` to indicate success:

  ```python
  from dataclasses import dataclass
  from cline import CommandLineArguments, Task

  @dataclass
  class NumberArgs:
      a: int
      b: int

  class SumTask(Task[NumberArgs]):
      @classmethod
      def make_args(cls, args: CommandLineArguments) -> NumberArgs:
          return NumberArgs(
              a=args.get_integer("a"),
              b=args.get_integer("b"),
          )

      def invoke(self) -> int:
          result = self.args.a + self.args.b
          self.out.write(f"{result}\n")
          return 0
  ```



  Back in your CLI class, override `register_tasks()` to register `SumTask`:

  ```python
  from argparse import ArgumentParser
  from cline import ArgumentParserCli
  from examples.example01.sum import SumTask

  class ExampleCli(ArgumentParserCli):
      def make_parser(self) -> ArgumentParser:
          parser = ArgumentParser()
          parser.add_argument(
            "a",
            help="first number",
            nargs="?",
          )
          parser.add_argument(
            "b",
            help="second number",
            nargs="?",
          )
          return parser

      def register_tasks(self) -> RegisteredTasks:
          return [
              SumTask,
          ]
  ```



  Finally, create a `__main__.py` script that calls your CLI's `invoke_and_exit()` method:

  ```python
  from examples.example01.cli import ExampleCli

  def entry() -> None:
      ExampleCli.invoke_and_exit()

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

  And that's it! You can now sum integers on the command line:

  ```bash
  python -m examples.example01 1 3
  ```

  <!--edition-exec as=markdown fence=backticks host=shell range=start-->

  ```text
  4
  ```

  <!--edition-exec range=end-->



  Cline was designed to support easy high coverage of your work.

  To test your task's `make_args()` function, construct your own `CommandLineArguments` instance with the command line arguments to test, then verify that `make_args()` returns the strongly-typed arguments that you'd expect:

  ```python
  from cline import CommandLineArguments
  from examples.example01.sum import SumTask, NumberArgs

  def test_make_args() -> None:
      cli_args = CommandLineArguments(
          {
              "a": "1",
              "b": "2",
          }
      )

      args = SumTask.make_args(cli_args)
      assert args == NumberArgs(a=1, b=2)
  ```

  To test your task's `invoke()` function, construct your own strongly-typed arguments and an output writer then assert that the shell exit code and written response are as you expect:

  ```python
  from io import StringIO
  from examples.example01.sum import SumTask, NumberArgs

  def test_invoke() -> None:
      out = StringIO()
      task = SumTask(args=NumberArgs(a=5, b=2), out=out)
      assert task.invoke() == 0
      assert out.getvalue() == "7\n"
  ```

  To test that the CLI will invoke your task for a given set of command line arguments, you can instantiate your CLI with the arguments to test then assert that the `.task` and `.task.args` properties are as you expect:

  ```python
  from typing import List, Type

  from pytest import mark

  from cline import AnyTask
  from examples.example01.cli import ExampleCli
  from examples.example01.tasks import NumberArgs, SumTask

  @mark.parametrize(
      "args, expect_task, expect_args",
      [
          (["1", "2"], SumTask, NumberArgs(a=1, b=2)),
      ],
  )
  def test(
      args: List[str],
      expect_task: Type[AnyTask],
      expect_args: NumberArgs,
  ) -> None:
      cli = ExampleCli(args=args)
      assert isinstance(cli.task, expect_task)
      assert cli.task.args == expect_args
  ```



  _The source code for this example is available at [github.com/cariad/cline/blob/main/examples/example02](https://github.com/cariad/cline/blob/main/examples/example02). The tests are in [github.com/cariad/cline/blob/main/tests/examples/example02](https://github.com/cariad/cline/blob/main/tests/examples/example02)._

  In this example, we'll build on Example 1 to allow integers to be subtracted. We'll add `--sum` and `--sub` flags to describe that we want to do.

  For example:

  ```bash
  python -m examples.example02 --sum 8 5
  python -m examples.example02 --sub 8 5
  ```

  <!--edition-exec as=markdown fence=backticks host=shell range=start-->

  ```text
  13
  3
  ```

  <!--edition-exec range=end-->



  In your CLI class, update the argument parser to support `--sum` and `--sub` flags:

  ```python
  def make_parser(self) -> ArgumentParser:
      parser = ArgumentParser()
      parser.add_argument("a", help="first number", nargs="?")
      parser.add_argument("b", help="second number", nargs="?")
      parser.add_argument(
          "--sub",
          help="subtract",
          action="store_true",
      )
      parser.add_argument(
          "--sum",
          help="sum",
          action="store_true",
      )
      return parser
  ```

  Note that the new arguments are presented as `--sub` and `--sum` here, but their names omit the dashes. The new arguments are named `sub` and `sum`.



  In the previous example, we wanted `SumTask` to always run if we gave it two numbers. Now we want it to run only if we give it two numbers _and_ the `--sum` flag.

  We can achieve this simply by calling `assert_true()` in the task's `make_args()` function, passing the name of the flag we want to assert is truthy:

  ```python
  @classmethod
  def make_args(cls, args: CommandLineArguments) -> NumberArgs:
      args.assert_true("sum")

      return NumberArgs(
          a=args.get_integer("a"),
          b=args.get_integer("b"),
      )
  ```



  To perform subtraction, we'll need a `SubtractTask` class. This is almost identical to `SumTask`, expect:

  1. We want to assert that the `sub` (not `sum`) flag is truthy
  1. We want to subtract (not sum) the arguments

  So, for example:

  ```python
  class SubtractTask(Task[NumberArgs]):
      @classmethod
      def make_args(cls, args: CommandLineArguments) -> NumberArgs:
          args.assert_true("sub")

          return NumberArgs(
              a=args.get_integer("a"),
              b=args.get_integer("b"),
          )

      def invoke(self) -> int:
          result = self.args.a - self.args.b
          self.out.write(f"{result}\n")
          return 0
  ```



  Open your CLI class and register `SubtractTask`:

  ```python
  def register_tasks(self) -> RegisteredTasks:
      return [
          examples.example02.tasks.SubtractTask,
          examples.example02.tasks.SumTask,
      ]
  ```

  ...and that's it! When your application runs, Cline will try each registered task in order until one is found that accepts the given command line arguments, then executes it:

  ```bash
  python -m examples.example02 --sum 8 5
  python -m examples.example02 --sub 8 5
  ```

  <!--edition-exec as=markdown fence=backticks host=shell range=start-->

  ```text
  13
  3
  ```

  <!--edition-exec range=end-->



  _The source code for this example is available at [github.com/cariad/cline/blob/main/examples/example03](https://github.com/cariad/cline/blob/main/examples/example03). The tests are in [github.com/cariad/cline/blob/main/tests/examples/example03](https://github.com/cariad/cline/blob/main/tests/examples/example03)._

  Cline has baked-in support for printing your application's help and version on the command line.

  Enabling support for help is easy enough: it's already enabled. If Cline cannot find any registered tasks that can handle the given command line arguments then it will print the argument parser's help.

  For example, if we run one of the above examples without specifying any numbers then each task's `make_args()` call will fail and Cline will fall back to displaying the help:

  ```bash
  python -m examples.example01
  ```

  <!--edition-exec as=markdown fence=backticks host=shell range=start-->

  ```text
  usage: __main__.py [-h] [a] [b]

  positional arguments:
    a           first number
    b           second number

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

  <!--edition-exec range=end-->

  Adding support for version printing is a two-step process. First, add a `--version` flag to your argument parser:

  ```python
  def make_parser(self) -> ArgumentParser:
      parser = ArgumentParser()
      parser.add_argument("a", help="first number", nargs="?")
      parser.add_argument("b", help="second number", nargs="?")
      parser.add_argument(
          "--sub",
          help="subtracts numbers",
          action="store_true",
      )
      parser.add_argument(
          "--sum",
          help="sums numbers",
          action="store_true",
      )
      parser.add_argument(
          "--version",
          help="show version",
          action="store_true",
      )
      return parser
  ```

  Then in `__main__.py`, pass your application's version into `invoke_and_exit()`:

  ```python
  from examples.full import __version__
  from examples.full.cli import ExampleCli

  def entry() -> None:
      ExampleCli.invoke_and_exit(app_version=__version__)

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

  Now you can pass `--version` on the command line and get your application's version:

  ```bash
  python -m examples.example03 --version
  ```

  <!--edition-exec as=markdown fence=backticks host=shell range=start-->

  ```text
  1.2.3
  ```

  <!--edition-exec range=end-->

  Note that this code depends on your own implementation of versioning. I use `__version__` but you don't have to. If your application's version is gettable via a property other than `__version__` then pass that instead.



  This isn't Cline functionality, but I'll preempt the question by answering it now.

  In your `setup.py` script, pass an `entry_points` value into `setup()`:

  ```python
  setup(
      
      entry_points={
          "console_scripts": [
              "foo=bar.__main__:entry",
          ],
      },
      
  )
  ```

  Note that:

  - `foo` is the name of the command you want your users to run (i.e. `foo --help`)
  - `bar` is your package name
  - `entry` is the name of the function to run inside `__main__.py`





  To contribute a bug report, enhancement or feature request, please raise an issue at [github.com/cariad/cline/issues](https://github.com/cariad/cline/issues).

  If you want to contribute a code change, please raise an issue first so we can chat about the direction you want to take.



  Edition is released at [github.com/cariad/cline](https://github.com/cariad/cline) under the MIT Licence.

  See [LICENSE](https://github.com/cariad/cline/blob/main/LICENSE) for more information.



  Hello! 👋 I'm **Cariad Eccleston** and I'm a freelance DevOps and backend engineer. My contact details are available on my personal wiki at [cariad.earth](https://cariad.earth).

  Please consider supporting my open source projects by [sponsoring me on GitHub](https://github.com/sponsors/cariad/).



  - This documentation was pressed with [Edition](https://github.com/cariad/edition).


pkgId: a58b5652e29c070b3b2f77c96bdaead8d2b996e51e869e21132c38befc7809f5
name: python-clingexplaid
arch: src
version: 1.1.0
epoch: 0
release: 1
summary: Tools to aid the development of explanation systems using clingo
url: https://github.com/potassco/clingo-explaid
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clingexplaid-1.1.0-1.src.rpm
checksum_type: sha256
description:
  API to aid the development of explanation systems using clingo



  Clingo-Explaid easily be installed with `pip`:

  ```bash
  pip install clingexplaid
  ```



  - `python >= 3.9`
  - `clingo >= 5.7.1`



  Please refer to [DEVELOPEMENT](DEVELOPMENT.md)



  Here are two example for using `clingexplaid`'s API.



  ```python
  import clingo
  from clingexplaid.transformers import AssumptionTransformer
  from clingexplaid.mus import CoreComputer

  PROGRAM = """
  a(1..3).
  {b(4..6)}.

  a(X) :- b(X).

  :- a(X), X>=3.
  """

  control = clingo.Control()
  at = AssumptionTransformer(signatures={("a", 1)})

  transformed_program = at.parse_string(PROGRAM)

  control.add("base", [], transformed_program)
  control.ground([("base", [])])

  assumptions = at.get_assumption_literals(control)

  cc = CoreComputer(control, assumptions)


  def shrink_on_core(core) -> None:
      mus_literals = cc.shrink(core)
      print("MUS:", cc.mus_to_string(mus_literals))


  control.solve(assumptions=list(assumptions), on_core=shrink_on_core)
  ```



  ```python
  from clingexplaid.unsat_constraints import UnsatConstraintComputer

  PROGRAM = """
  a(1..3).
  {b(4..6)}.

  a(X) :- b(X).

  :- a(X), X>=3.
  """

  ucc = UnsatConstraintComputer()
  ucc.parse_string(PROGRAM)
  unsat_constraints = ucc.get_unsat_constraints()

  for uc_id, unsat_constraint in unsat_constraints.items():
      print(f"Unsat Constraint {uc_id}:", unsat_constraint)
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Hannes Weichelt  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: 343f6423b0c6e1da4fa3b0754f4eb102949fdffbe9762e9141f9fa2c7732f937
name: python-clingraph
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A visualizer for graphs defined as facts with special integration for clingo
url: https://github.com/potassco/clingraph
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clingraph-1.1.2-1.src.rpm
checksum_type: sha256
description:
  A **declarative visualizer for graphs** defined as a set of facts. The graphs are generated using [graphviz](https://graphviz.org) but are defined via fixed predicates that can be computed from logic programs.

  ***Graph defined by facts***
  ```prolog
  node(clingraph). node(visual). node(asp).
  edge((clingraph,visual)). edge((clingraph,asp)).
  attr(node,clingraph,style,filled).
  ```
  ***Visualization***
  ![](./docs/clingraph.png)

  Clingraph also contains **special features** for integration with **[clingo](https://potassco.org/clingo/)**, as well as for generating **latex** code and **gifs**!

  Check out our paper **[here](https://arxiv.org/pdf/2303.10118.pdf)**. This work was published in LPNMR22 where it recived the *"Best student paper award"*.



  Look at our [documentation page](https://clingraph.readthedocs.io/en/latest/) to see how to use clingraph.

  Try clingraph via [command line](https://clingraph.readthedocs.io/en/latest/clingraph/console.html) or as a package online in a jupyter notebook via [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/potassco/clingraph/master?labpath=notebook.ipynb)




  Our **[examples folder](https://github.com/potassco/clingraph/tree/master/examples)** shows how to use the range of functionalities in different applications.

  - Examples used in the documentation ([doc](https://github.com/potassco/clingraph/tree/master/examples/doc))
    - *Attribute definition* ([example1](https://github.com/potassco/clingraph/tree/master/examples/doc/example1))
    - *Multi graphs* ([example2](https://github.com/potassco/clingraph/tree/master/examples/doc/example2))
    - *Subgraphs* ([example3](https://github.com/potassco/clingraph/tree/master/examples/doc/example3))
    - *Complex attributes* ([example4](https://github.com/potassco/clingraph/tree/master/examples/doc/example4))
    - *Clingo integration with multi model* ([example5](https://github.com/potassco/clingraph/examples/doc/example5))
    - *Latex integration* ([example6](https://github.com/potassco/clingraph/tree/master/examples/doc/example6))
  - Simple ([color](https://github.com/potassco/clingraph/tree/master/examples/color), [cube](https://github.com/potassco/clingraph/tree/master/examples/cube), [lights](https://github.com/potassco/clingraph/tree/master/examples/lights))
  - Clingo integration ([sudoku](https://github.com/potassco/clingraph/tree/master/examples/sudoku), [reify](https://github.com/potassco/clingraph/tree/master/examples/reify), [transition_system](https://github.com/potassco/clingraph/tree/master/examples/transition_system))
    - *Absolute positioning*
    - *Legends*
    - *Latex integration*
  - Dynamic applications ([asprilo](https://github.com/potassco/clingraph/tree/master/examples/asprilo), [elevator](https://github.com/potassco/clingraph/tree/master/examples/elevator), [minotaur](https://github.com/potassco/clingraph/tree/master/examples/minotaur))
    - *Clingo integration*
    - *Multi graphs*
    - *Animation via Gif*
  - SVG interaction ([family_tree](https://github.com/potassco/clingraph/tree/master/examples/family_tree), [queens_interactive](https://github.com/potassco/clingraph/tree/master/examples/queens_interactive), [minesweeper](https://github.com/potassco/clingraph/tree/master/examples/minesweeper))
    - *Interaction using SVG*
  - Visualizing  the [solving](https://github.com/potassco/clingraph/tree/master/examples/propagator) and [program structure](https://github.com/potassco/clingraph/tree/master/examples/ast)






  - Python (version 3.8, 3.9, or 3.10)

  For instructions to install from source, pip and conda see our [documentation page](https://clingraph.readthedocs.io/en/latest/clingraph/installation.html).


pkgId: cea426981e7d296c9eb5f602065bf9f1b6a23c3e73178c101072e83bc2092e35
name: python-clinguin
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: An interactive visualizer for clingo
url: https://github.com/krr-up/clinguin
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinguin-2.1.1-1.src.rpm
checksum_type: sha256
description:
  Clinguin enables ASP developers to **create interactive User Interface** (UI) prototypes **using only ASP**.
  UIs are defined as sets of facts,  which are then rendered to provide continuous interaction with the ASP solver *clingo* based on user-triggered events.

  ***Your UI definition would look like this!***

  ```prolog
  elem(w, window, root).
  elem(b1, button, w).
  attr(b1, label, "Button 1").
  when(b1, click, call, next_solution).
  ```



  Look at our [documentation page](https://clinguin.readthedocs.io/en/latest/) to see how to use clinguin.



  Our **[examples folder](https://github.com/potassco/clinguin/tree/master/examples)** shows how to use the range of functionalities in different applications.



  ***Integration with different applications***

  Clinguin includes a wide range of [clingo](https://potassco.org/clingo/) functionalities such as multi-shot solving, theory solving and more! It also has extensions for interacting with [clingraph](https://clinguin.readthedocs.io/en/latest/clinguin/installation.html) graphs and providing explanations.


  ***Is clinguin missing something for your application?***

  No worries! Clinguin can be extended with different functionalities and even frontend languages, take a look [at this guide](https://clinguin.readthedocs.io/en/latest/clinguin/development/customBackend.html).






  - Python (version 3.8, 3.9, or 3.10)

  For instructions to install from source, pip and conda see our [documentation page](https://clinguin.readthedocs.io/en/latest/clinguin/installation.html).


pkgId: 9536f2281a1df0557d8825a1a77d2d9e82976f12ad00a28ac584990b7d2c4220
name: python-clinica
arch: src
version: 0.9.3
epoch: 0
release: 1
summary: Software platform for clinical neuroimaging studies
url: https://www.clinica.run
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinica-0.9.3-1.src.rpm
checksum_type: sha256
description:
  <!--(http://www.clinica.run/img/clinica_brainweb.png)-->
  <!-- markdownlint-disable MD033 -->

  <h1 align="center">
    <a href="http://www.clinica.run">
      <img src="http://www.clinica.run/assets/images/clinica-icon-257x257.png" alt="Logo" width="120" height="120">
    </a>
    <br/>
    Clinica
  </h1>

  <p align="center"><strong>Software platform for clinical neuroimaging studies</strong></p>

  <p align="center">
    <a href="https://github.com/aramis-lab/clinica/actions/workflows/test.yml">
      <img src="https://github.com/aramis-lab/clinica/actions/workflows/test.yml/badge.svg" alt="Build Status">
    </a>
    <a href="https://badge.fury.io/py/clinica">
      <img src="https://badge.fury.io/py/clinica.svg" alt="PyPI version">
    </a>
    <a href="https://pypi.org/project/clinica">
      <img src="https://img.shields.io/pypi/pyversions/clinica" alt="Supported Python versions">
    </a>
    <a href="https://aramislab.paris.inria.fr/clinica/docs/public/latest/Installation/">
    </a>
    <a href="https://aramislab.paris.inria.fr/clinica/docs/public/latest/Installation/">
      <img src="https://anaconda.org/aramislab/clinica/badges/platforms.svg" alt="platform">
    </a>
    <a href="https://github.com/psf/black">
      <img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black">
    </a>
    <a href="https://pepy.tech/project/clinica">
      <img src="https://static.pepy.tech/badge/clinica/month" alt="Downloads">
    </a>
  </p>

  <p align="center">
    <a href="http://www.clinica.run">Homepage</a> |
    <a href="https://aramislab.paris.inria.fr/clinica/docs/public/latest/">Documentation</a> |
    <a href="https://doi.org/10.3389/fninf.2021.689675">Paper</a> |
    <a href="https://github.com/aramis-lab/clinica/discussions">Forum</a> |
    See also:
    <a href="#related-repositories">AD-ML</a>,
    <a href="#related-repositories">AD-DL</a>,
    <a href="#related-repositories">ClinicaDL</a>
  </p>



  Clinica is a software platform for clinical research studies involving patients
  with neurological and psychiatric diseases and the acquisition of multimodal
  data (neuroimaging, clinical and cognitive evaluations, genetics...),
  most often with longitudinal follow-up.

  Clinica is command-line driven and written in Python.
  It uses the [Nipype](https://nipype.readthedocs.io/) system for pipelining and combines
  widely-used software packages for neuroimaging data analysis
  ([ANTs](http://stnava.github.io/ANTs/),
  [FreeSurfer](https://surfer.nmr.mgh.harvard.edu/),
  [FSL](https://fsl.fmrib.ox.ac.uk/fsl/fslwiki),
  [MRtrix](https://www.mrtrix.org/),
  [PETPVC](https://github.com/UCL/PETPVC),
  [SPM](https://www.fil.ion.ucl.ac.uk/spm/)), machine learning
  ([Scikit-learn](https://scikit-learn.org/stable/)) and the [BIDS
  standard](http://bids-specification.readthedocs.io/) for data organization.

  Clinica provides tools to convert publicly available neuroimaging datasets into
  BIDS, namely:

  - [ADNI: Alzheimer’s Disease Neuroimaging Initiative](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/ADNI2BIDS/)
  - [AIBL: Australian Imaging, Biomarker & Lifestyle Flagship Study of Ageing](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/AIBL2BIDS/)
  - [HABS: Harvard Aging Brain Study](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/HABS2BIDS/)
  - [NIFD: Neuroimaging in Frontotemporal Dementia](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/NIFD2BIDS/)
  - [OASIS: Open Access Series of Imaging Studies](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/OASIS2BIDS/)
  - [OASIS-3: Longitudinal Neuroimaging, Clinical, and Cognitive Dataset for Normal Aging and Alzheimer’s Disease](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/OASIS3TOBIDS/)

  Clinica can process any BIDS-compliant dataset with a set of complex processing
  pipelines involving different software packages for the analysis of
  neuroimaging data (T1-weighted MRI, diffusion MRI and PET data).
  It also provides integration between feature extraction and statistics, machine
  learning or deep learning.

  ![ClinicaPipelines](http://www.clinica.run/img/Clinica_Pipelines_A4_2021-04-02_75dpi.jpg)

  Clinica is also showcased as a framework for the reproducible classification of
  Alzheimer's disease using
  [machine learning](https://github.com/aramis-lab/AD-ML) and
  [deep learning](https://github.com/aramis-lab/clinicadl).



  > Full instructions for installation and additional information can be found in
  the [user documentation](https://aramislab.paris.inria.fr/clinica/docs/public/latest/).



  Clinica can be easily installed and updated using [pipx](https://pypa.github.io/pipx/).

  ```console
  pipx install clinica
  ```



  ```console
  pip install clinica
  ```



  Clinica relies on multiple third-party tools to perform processing.

  An environment file is provided in this repository
  to facilitate their installation in a [Conda](https://docs.conda.io/en/latest/miniconda.html) environment:

  ```console
  git clone https://github.com/aramis-lab/clinica && cd clinica
  conda env create
  conda activate clinica
  ```

  After activation, use `pip` to install Clinica.



  Depending on the pipeline that you want to use, you need to install pipeline-specific interfaces.
  Some of which uses a different runtime or use incompatible licensing terms, which prevent their distribution alongside Clinica.
  Not all the dependencies are necessary to run Clinica.
  Please refer to this [page](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Third-party/)
  to determine which third-party libraries you need to install.



  Diagram illustrating the Clinica pipelines involved when performing a group
  comparison of FDG PET data projected on the cortical surface between patients
  with Alzheimer's disease and healthy controls from the ADNI database:

  ![ClinicaExample](http://www.clinica.run/img/Clinica_Example_2021-04-02_75dpi.jpg)

  1. Clinical and neuroimaging data are downloaded from the ADNI website and data
     are converted into BIDS with the [`adni-to-bids`
     converter](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Converters/ADNI2BIDS/).
  2. Estimation of the cortical and white surface is then produced by the
     [`t1-freesurfer`
     pipeline](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Pipelines/T1_FreeSurfer/).
  3. FDG PET data can be projected on the subject’s cortical surface and
     normalized to the FsAverage template from FreeSurfer using the
     [`pet-surface` pipeline](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Pipelines/PET_Surface/).
  4. TSV file with demographic information of the population studied is given to
     the [`statistics-surface`
     pipeline](https://aramislab.paris.inria.fr/clinica/docs/public/latest/Pipelines/Stats_Surface/) to generate
     the results of the group comparison.

  > For more examples and details, please refer to the
  > [Documentation](https://aramislab.paris.inria.fr/clinica/docs/public/latest/).



  - Check for [past answers](https://groups.google.com/forum/#!forum/clinica-user) in the old Clinica Google Group
  - Start a [discussion](https://github.com/aramis-lab/clinica/discussions) on Github
  - Report an [issue](https://github.com/aramis-lab/clinica/issues) on GitHub



  We encourage you to contribute to Clinica!
  Please check out the [Contributing to Clinica guide](CONTRIBUTING.md) for
  guidelines about how to proceed.  Do not hesitate to ask questions if something
  is not clear for you, report an issue, etc.



  This software is distributed under the MIT License.
  See [license file](https://github.com/aramis-lab/clinica/blob/dev/LICENSE.txt)
  for more information.



  - Routier, A., Burgos, N., Díaz, M., Bacci, M., Bottani, S., El-Rifai O., Fontanella, S., Gori, P., Guillon, J., Guyot, A., Hassanaly, R., Jacquemont, T.,  Lu, P., Marcoux, A.,  Moreau, T., Samper-González, J., Teichmann, M., Thibeau-Sutre, E., Vaillant G., Wen, J., Wild, A., Habert, M.-O., Durrleman, S., and Colliot, O.:
  *Clinica: An Open Source Software Platform for Reproducible Clinical Neuroscience Studies* Frontiers in Neuroinformatics, 2021
  [doi:10.3389/fninf.2021.689675](https://doi.org/10.3389/fninf.2021.689675)



  - [AD-DL: Classification of Alzheimer's disease status with convolutional neural networks](https://github.com/aramis-lab/AD-DL).
  - [AD-ML: Framework for the reproducible classification of Alzheimer's disease using
  machine learning](https://github.com/aramis-lab/AD-ML).
  - [ClinicaDL: Framework for the reproducible processing of neuroimaging data with deep learning methods](https://github.com/aramis-lab/clinicadl).


pkgId: 9fbb67ba72a2a5487d911da9bbf533adaf539d4f1650b5c6b303b86951bc9715
name: python-clinicadl
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: Framework for the reproducible processing of neuroimaging data with deep learning methods
url: https://clinicadl.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinicadl-1.6.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <a href="http://www.clinicadl.readthedocs.io">
      <img src="https://clinicadl.readthedocs.io/en/latest/images/logo.png" alt="ClinicaDL Logo" width="120" height="120">
    </a>
    <br/>
    ClinicaDL
  </h1>

  <p align="center"><strong>Framework for the reproducible processing of neuroimaging data with deep learning methods</strong></p>

  <p align="center">
    <a href="https://ci.inria.fr/clinicadl/job/AD-DL/job/dev/">
      <img src="https://ci.inria.fr/clinicadl/buildStatus/icon?job=AD-DL%2Fdev" alt="Build Status">
    </a>
    <a href="https://badge.fury.io/py/clinicadl">
      <img src="https://badge.fury.io/py/clinicadl.svg" alt="PyPI version">
    </a>
    <a href='https://clinicadl.readthedocs.io/en/latest/?badge=latest'>
      <img src='https://readthedocs.org/projects/clinicadl/badge/?version=latest' alt='Documentation Status' />
    </a>
    <a href='https://pepy.tech/project/clinicadl'>
      <img src='https://static.pepy.tech/badge/clinicadl/month' alt='Downloads' />
    </a>
  </p>

  <p align="center">
    <a href="https://clinicadl.readthedocs.io/">Documentation</a> |
    <a href="https://aramislab.paris.inria.fr/clinicadl/tuto">Tutorial</a> |
    <a href="https://groups.google.com/forum/#!forum/clinica-user">Forum</a>
  </p>




  This repository hosts ClinicaDL, the deep learning extension of [Clinica](https://github.com/aramis-lab/clinica),
  a python library to process neuroimaging data in [BIDS](https://bids.neuroimaging.io/index.html) format.

  > **Disclaimer:** this software is **under development**. Some features can
  change between different releases and/or commits.

  To access the full documentation of the project, follow the link
  [https://clinicadl.readthedocs.io/](https://clinicadl.readthedocs.io/).
  If you find a problem when using it or if you want to provide us feedback,
  please [open an issue](https://github.com/aramis-lab/ad-dl/issues) or write on
  the [forum](https://groups.google.com/forum/#!forum/clinica-user).


  ClinicaDL currently supports macOS and Linux.

  We recommend to use `conda` or `virtualenv` for the installation of ClinicaDL
  as it guarantees the correct management of libraries depending on common
  packages:

  ```{.sourceCode .bash}
  conda create --name ClinicaDL python=3.8
  conda activate ClinicaDL
  pip install clinicadl
  ```


  Visit our [hands-on tutorial web
  site](https://aramislab.paris.inria.fr/clinicadl/tuto) to start
  using **ClinicaDL** directly in a Google Colab instance!



  - [Clinica: Software platform for clinical neuroimaging studies](https://github.com/aramis-lab/clinica)
  - [AD-DL: Convolutional neural networks for classification of Alzheimer's disease: Overview and reproducible evaluation](https://github.com/aramis-lab/AD-DL)
  - [AD-ML: Framework for the reproducible classification of Alzheimer's disease using machine learning](https://github.com/aramis-lab/AD-ML)



  - Thibeau-Sutre, E., Díaz, M., Hassanaly, R., Routier, A., Dormont, D., Colliot, O., Burgos, N.: ‘ClinicaDL: an open-source deep learning software for reproducible neuroimaging processing‘, 2021. [hal-03351976](https://hal.inria.fr/hal-03351976)
  - Routier, A., Burgos, N., Díaz, M., Bacci, M., Bottani, S., El-Rifai O., Fontanella, S., Gori, P., Guillon, J., Guyot, A., Hassanaly, R., Jacquemont, T.,  Lu, P., Marcoux, A.,  Moreau, T., Samper-González, J., Teichmann, M., Thibeau-Sutre, E., Vaillant G., Wen, J., Wild, A., Habert, M.-O., Durrleman, S., and Colliot, O.: ‘Clinica: An Open Source Software Platform for Reproducible Clinical Neuroscience Studies’, 2021. [doi:10.3389/fninf.2021.689675](https://doi.org/10.3389/fninf.2021.689675) [Open Access version](https://hal.inria.fr/hal-02308126)


pkgId: 1be0377b45dd5e3ba1fc6257b2ef729a829bd21abd390a7d7ebe16db90bd8804
name: python-clinicore
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A clinical schema.
url: https://pypi.org/project/clinicore/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinicore-0.5.0-1.src.rpm
checksum_type: sha256
description:
  This schema is focused on the fundamental concepts of clinical data models.



  Please run `pre-commit install` and `gitmoji -i` on the CLI before starting to work on this repository!


pkgId: 986361eab81cff763d494b0e57614fe26cc3145c3a30124f06ca4789ea97e41a
name: python-clinker
arch: src
version: 0.0.31
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/gamcil/clinker
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinker-0.0.31-1.src.rpm
checksum_type: sha256
description:
  Align clusters, plot results and print scores to screen:
    $ clinker files/*.gbk
  Only save gene-gene links when identity is over 50%:
    $ clinker files/*.gbk -i 0.5
  Save an alignment session for later:
    $ clinker files/*.gbk -s session.json
  Save alignments to file, in comma-delimited format, with 4 decimal places:
    $ clinker files/*.gbk -o alignments.csv -dl "," -dc 4
  Generate visualisation:
    $ clinker files/*.gbk -p
  Save visualisation as a static HTML document:
    $ clinker files/*.gbk -p plot.html
  Cameron Gilchrist, 2020
  ```

  By default, clinker automatically assigns a name and colour for each group of homologous genes.
  You can instead pre-assign names (i.e. functions) using the `-gf/--gene_functions` argument, which
  takes a 2-column comma-separated file like:
  ```
  GENE_001,Cytochrome P450
  GENE_002,Cytochrome P450
  GENE_003,Methyltransferase
  GENE_004,Methyltransferase
  ```
  This will generate two groups, Cytochrome P450 (GENE_001 and 002), and Methyltransferase (GENE_003, GENE_004).
  If there any other homologous genes are identified, they will automatically be added to these groups.
  As of clinker v0.0.28, you can now specify colours for genes defined by the
  `-gf/--gene_functions` argument. To do this, use the `-cm/--colour_map` argument which
  also takes a 2-column CSV file containing the group name and hexadecimal colour code like:
  ```
  Cytochrome P450,#FF0000
  Methyltransferase,#0000FF
  ```


pkgId: c352ae64d0851eca3ac37be501998b10ba2fab6e0709b93bdb0c895599e1b7af
name: python-clinlp
arch: src
version: 0.9.4
epoch: 0
release: 1
summary: Performant and production-ready NLP pipelines for clinical text written in Dutch
url: https://pypi.org/project/clinlp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinlp-0.9.4-1.src.rpm
checksum_type: sha256
description:
  [![test](https://github.com/umcu/clinlp/actions/workflows/test.yml/badge.svg)](https://github.com/umcu/clinlp/actions/workflows/test.yml)
  [![docs](https://readthedocs.org/projects/clinlp/badge/?version=latest)](https://clinlp.readthedocs.io/en/latest/?badge=latest)
  [![pypi version](https://img.shields.io/pypi/v/clinlp?color=blue)](https://pypi.org/project/clinlp/)
  [![pypi python versions](https://img.shields.io/pypi/pyversions/clinlp)](https://pypi.org/project/clinlp/)
  [![license](https://img.shields.io/github/license/umcu/clinlp?color=blue)](https://github.com/umcu/clinlp/blob/main/LICENSE)
  [![made with spaCy](https://img.shields.io/badge/made_with-spaCy-blue)](https://spacy.io/)
  [![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

  ![clinlp](media/clinlp.png)

  <!-- start_intro_line_1 -->
  * :hospital: `clinical` + :netherlands: `nl` + :clipboard: `NLP` = :sparkles: `clinlp`
  <!-- start_intro_line_2 -->
  * :star: NLP tools and algorithms for clinical text written in Dutch
  <!-- start_intro_line_3 -->
  * :triangular_ruler: Organized in a standardized but flexible framework using `spaCy`
  <!-- start_intro_line_4 -->
  * :rocket: Production-ready, performant, well-tested and easy to use
  <!-- start_intro_line_5 -->
  * :bulb: Free, open source, created and maintained by the Dutch Clinical NLP community
  <!-- end_intro_lines -->



  If you have questions, need help getting started, found a bug, or have a feature request, please don't hesitate to [contact us](https://clinlp.readthedocs.io/en/latest/contributing.html#contact)!





  ```bash
  pip install clinlp
  ```



  ```python
  import spacy
  from clinlp.ie import Term

  nlp = spacy.blank("clinlp")


  nlp.add_pipe("clinlp_normalizer")


  nlp.add_pipe("clinlp_sentencizer")


  terms = {
      "prematuriteit": [
          "preterm", "<p3", "prematuriteit", "partus praematurus"
      ],
      "hypotensie": [
          "hypotensie", Term("bd verlaagd", proximity=1)
      ],
      "veneus_infarct": [
          "veneus infarct", Term("VI", attr="TEXT")
      ]
  }

  entity_matcher = nlp.add_pipe("clinlp_rule_based_entity_matcher", config={"attr": "NORM", "fuzzy": 1})
  entity_matcher.add_terms_from_dict(terms)


  nlp.add_pipe("clinlp_context_algorithm", config={"phrase_matcher_attr": "NORM"})

  text = (
      "Preterme neonaat (<p3) opgenomen, bd enigszins verlaagd, familieanamnese vermeldt eveneens hypotensie "
      "bij moeder. Thans geen aanwijzingen voor veneus infarkt wat ook geen "
      "verklaring voor de partus prematurus is. Risico op VI blijft aanwezig."
  )

  doc = nlp(text)
  ```

  Find information in the `Doc` object:

  ```python
  from spacy import displacy

  displacy.render(doc, style="span", options={'spans_key': 'ents'})
  ```

  ![example_doc_render.png](media/example_doc_render.png)

  With relevant qualifiers (defaults omitted for readability):

  ```python
  for ent in doc.spans["ents"]:
    print(ent, ent._.qualifiers_str)
  ```

  * `Preterme` `set()`
  * `<p3` `set()`
  * `bd enigszins verlaagd` `set()`
  * `hypotensie` `{'Experiencer.Family'}`
  * `veneus infarkt` `{'Presence.Absent'}`
  * `partus prematurus` `set()`
  * `VI` `{'Temporality.Future'}`



  The full documentation can be found at [https://clinlp.readthedocs.io](https://clinlp.readthedocs.io).



  * [Documentation](https://clinlp.readthedocs.io)
  * [Contributing guidelines](https://clinlp.readthedocs.io/en/latest/contributing.html)
  * [API](https://clinlp.readthedocs.io/en/latest/api/api.html)
  * [`clinlp` development roadmap](https://github.com/orgs/umcu/projects/3)
  * [Create an issue](https://github.com/umcu/clinlp/issues/new/choose)
  * [Cite `clinlp`](https://clinlp.readthedocs.io/en/latest/citing.html)
  * [Changelog](https://clinlp.readthedocs.io/en/latest/changelog.html)


pkgId: 501c749a57b91948d6a201e101d51da3eb0093655b57510854fb0fa98d208ead
name: python-clinner
arch: src
version: 1.12.3
epoch: 0
release: 1
summary: Command Line Interface builder that helps creating an entry point for your application.
url: https://github.com/PeRDy/clinner
rpm_license: GPL-3.0+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinner-1.12.3-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/PeRDy/clinner.svg?branch=master)](https://travis-ci.org/PeRDy/clinner)
  [![codecov](https://codecov.io/gh/PeRDy/clinner/branch/master/graph/badge.svg)](https://codecov.io/gh/PeRDy/clinner)
  [![PyPI version](https://badge.fury.io/py/clinner.svg)](https://badge.fury.io/py/clinner)

  * **Version:** 1.12.3
  * **Status:** Production/Stable
  * **Author:** José Antonio Perdiguero López

  Clinner is a library that provides some useful tools to create command line interfaces for your application

  Check [Clinner docs].


  Can **define commands** in multiple way:
  * List of shell commands such as `["docker build", "docker push"]`.
  * Python functions.
  * Python async functions.

  Clinner provides a set of **commands ready to use** like:
  * Black.
  * Flake8.
  * Isort.
  * Nosetest.
  * Prospector.
  * Pytest.
  * Sphinx.
  * Tox.

  Hooks for **injecting variables** or **add global arguments** to your script.


  Install this package using pip:

  ```bash
  pip install clinner
  ```

  Create a command

  ```python
  from clinner.command import command

  @command
  def foo(*args, **kwargs):
      return True
  ```

  Create a main file:

  ```python
  from clinner.run.main import Main

  if __name__ == '__main__':
      sys.exit(Main().run())
  ```


  Commands are declared using a decorator to register given functions. Commands are functions with the follow parameters:

  1. `func`: Function that will be called when command would be executed.
  2. `command_type`: Type of the command, could be a *bash* or *python* command.
  3. `args`: Parser arguments for this command.
  4. `parser_opts`: Command subparser's keywords, such as description.

  This decorator allows to be used as a common decorator without arguments, where default type (*python*) will be used:

  ```python
  @command
  def foobar(*args, **kwargs):
      pass
  ```

  Or specifying the type:

  ```python
  @command(command_type=CommandType.PYTHON)
  def foobar(*args, **kwargs):
      pass
  ```

  But also is possible to provide command line arguments, as expected by argparse.ArgumentParser.add_argument:

  ```python
  @command(args=((('-f', '--foo'), {'help': 'Foo argument that does nothing'}),                   # Command argument
                 (('--bar',), {'action': 'store_true', 'help': 'Bar argument stored as True'})),  # Another argument
           parser_opts={'title': 'foobar_command', 'help': 'Help for foobar_command'})            # Parser parameters
  def foobar(*args, **kwargs):
      pass
  ```

  All commands will be registered in a command register that can be accessed through ``command.register``. Each entry in
  this register is a dictionary with the fields declared at the beginning of this section.


  Example of running `ls -la` shell command.

  ```python
  @command(command_type=CommandType.SHELL)
  def lsla(*args, **kwargs):
      return [shlex.split("ls -la")]
  ```


  Run a python function.

  ```python
  @command
  def foo(*args, **kwargs):
      return "foo"
  ```


  Run a python async function.

  ```python
  @command
  async def bar(*args, **kwargs):
      await asyncio.sleep(1)
      return "bar"
  ```


  A main class is defined to ease the creation of command line applications. This class follows the process:

  1. Create a parser using ``argparse.ArgumentParser`` for the application:

      a) Calling all ``add_arguments(parser)`` methods from all super classes, e.g: ``clinner.mixins.HealthCheckMixin``.

      b) Addding a subparser for each command with their specific arguments.

  2. Parse arguments using the argument parser created previously.

  3. Inject variables into environment calling all super classes methods whose name starts with ``inject_``.


  Some Clinner examples.


  Example of a simple main with two defined commands `foo` and `bar`.

  ```python

  import shlex
  import sys

  from clinner.command import command, Type as CommandType
  from clinner.run.main import Main


  @command(command_type=CommandType.SHELL,
           args=(('-i', '--input'),
                 ('-o', '--output')),
           parser_opts={'help': 'Foo command'})
  def foo(*args, **kwargs):
      """List of foo commands"""
      ls_cmd = shlex.split('ls')
      wc_cmd = shlex.split('wc')
      wc_cmd += [kwargs['input'], kwargs['output']]

      return [ls_cmd, wc_cmd]


  @command(command_type=CommandType.PYTHON,
           parser_opts={'help': 'Bar command'})
  def bar(*args, **kwargs):
      """Do a bar."""
      return True


  if __name__ == '__main__':
      sys.exit(Main().run())
  ```


  Example of main module with build utilities such as unit tests, lint, sphinx doc, tox and dist packaging:

  ```python

  import sys

  from clinner.run import Main


  class Build(Main):
      commands = (
          'clinner.run.commands.black.black',
          'clinner.run.commands.flake8.flake8',
          'clinner.run.commands.isort.isort',
          'clinner.run.commands.pytest.pytest',
          'clinner.run.commands.sphinx.sphinx',
          'clinner.run.commands.tox.tox',
      )


  if __name__ == '__main__':
      sys.exit(Build().run())
  ```

  Check [Clinner docs] to see more advanced examples.

  [Clinner docs]: http://clinner.readthedocs.io


pkgId: b03d2e5a4ddd7651fb02750c3495fe715d421ea7f28f3e68e59841347d481314
name: python-clint
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Python Command Line Interface Tools
url: https://github.com/kennethreitz/clint
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clint-0.5.1-1.src.rpm
checksum_type: sha256
description:
  **Clint** is a module filled with a set of awesome tools for developing
  commandline applications.
  **C** ommand
  **L** ine
  **IN** terface
  **T** ools
  .
  Clint is awesome. Crazy awesome. It supports colors, but detects if the session is a TTY, so doesn't render the colors if you're piping stuff around. Automagically.
  Awesome nest-able indentation context manager. Example: (``with indent(4): puts('indented text')``). It supports custom email-style quotes. Of course, it supports color too, if and when needed.
  It has an awesome Column printer with optional auto-expanding columns. It detects how wide your current console is and adjusts accordingly. It wraps your words properly to fit the column size. With or without colors mixed in. All with a single function call.
  The world's easiest to use implicit argument system w/ chaining methods for filtering. Seriously.
  Run the various executables in examples_ to get a good feel for what Clint offers.
  You'll never want to not use it.


pkgId: 915998c5cc0c7709c33c8a08a87a2efa935633874809d73f69660516fc972959
name: python-clinvar-this
arch: src
version: 0.18.3
epoch: 0
release: 1
summary: ClinVar Submission via API Made Easy
url: https://github.com/bihealth/clinvar-this
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clinvar-this-0.18.3-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/bihealth/clinvar-this/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/bihealth/clinvar-this/actions/workflows/main.yml)
  [![codecov](https://codecov.io/gh/bihealth/clinvar-this/branch/main/graph/badge.svg?token=059T45KAQM)](https://codecov.io/gh/bihealth/clinvar-this)
  [![Documentation Status](https://readthedocs.org/projects/clinvar-this/badge/?version=latest)](https://clinvar-this.readthedocs.io/en/latest/?badge=latest)
  [![Bioconda](https://img.shields.io/conda/dn/bioconda/clinvar-this.svg?label=Bioconda)](https://bioconda.github.io/recipes/clinvar-this/README.html)
  [![Pypi](https://img.shields.io/pypi/pyversions/clinvar-this.svg)](https://pypi.org/project/clinvar-this)



  ClinVar Submission via API Made Easy

  - Free software: MIT license
  - Documentation: https://clinvar-this.readthedocs.io/en/latest/
  - Discussion Forum: https://github.com/bihealth/clinvar-this/discussions
  - Bug Reports: https://github.com/bihealth/clinvar-this/issues



  ![The clinvar-this workflow](docs/figures/clinvar-this-workflow.png)



  You can find comprehensive documentation here:

  - https://clinvar-this.readthedocs.io/en/latest/

  A good place to start is:

  - ["Getting Started" in the documentation](https://clinvar-this.readthedocs.io/en/latest/getting_started.html)









  * make _uuid4_if_falsy always return str ([#272](https://github.com/varfish-org/clinvar-this/issues/272)) ([038a22e](https://github.com/varfish-org/clinvar-this/commit/038a22e44b738578aceb83c399ff1be59bc6de15))






  * adding .pyi files ([#261](https://github.com/varfish-org/clinvar-this/issues/261)) ([a1ae5cb](https://github.com/varfish-org/clinvar-this/commit/a1ae5cb3f691662114783d911ab2091e97d53561))






  * losen lower protobuf dependency version ([#259](https://github.com/varfish-org/clinvar-this/issues/259)) ([b963510](https://github.com/varfish-org/clinvar-this/commit/b963510631ceb81b75cfb885ed917f10409ceea0))






  * extract-vars writes thinned-out SCV infos ([#240](https://github.com/varfish-org/clinvar-this/issues/240)) ([#258](https://github.com/varfish-org/clinvar-this/issues/258)) ([19ecf18](https://github.com/varfish-org/clinvar-this/commit/19ecf185b15c8300801a79525c47f9dcfe9eac07))
  * xml-to-json can now left-shift variants ([#255](https://github.com/varfish-org/clinvar-this/issues/255)) ([#256](https://github.com/varfish-org/clinvar-this/issues/256)) ([66671cd](https://github.com/varfish-org/clinvar-this/commit/66671cddc68f6c2df517a24ec436524d883c503b))






  * namespaced string issue from 2207-07-01 ([#241](https://github.com/varfish-org/clinvar-this/issues/241)) ([ab85be8](https://github.com/varfish-org/clinvar-this/commit/ab85be805f32b69178e41de0c498f8596ca38ebd))






  * adjust ClinVar XML parsing to cardinality fixes ([#233](https://github.com/varfish-org/clinvar-this/issues/233)) (#234)



  * adjust ClinVar XML parsing to cardinality fixes ([#233](https://github.com/varfish-org/clinvar-this/issues/233)) ([#234](https://github.com/varfish-org/clinvar-this/issues/234)) ([119ab42](https://github.com/varfish-org/clinvar-this/commit/119ab42ffadfb0d10ee58b3f855bd0cbf9eee825))






  * make compatible with 2024 March 1 schema of ClinVar ([#222](https://github.com/varfish-org/clinvar-this/issues/222)) ([#223](https://github.com/varfish-org/clinvar-this/issues/223)) ([a7480dd](https://github.com/varfish-org/clinvar-this/commit/a7480dd730d7c4594958e3c621da90b4353b1370))
  * make compatible with 2024 May 15 schema of ClinVar ([#221](https://github.com/varfish-org/clinvar-this/issues/221)) ([#229](https://github.com/varfish-org/clinvar-this/issues/229)) ([c0d1a4c](https://github.com/varfish-org/clinvar-this/commit/c0d1a4c746e44f9301412fe8e74f3c91aeb096a5))






  * refined (thinned out) extraction of variants ([#219](https://github.com/varfish-org/clinvar-this/issues/219)) ([dc9652c](https://github.com/varfish-org/clinvar-this/commit/dc9652c87aaad156dcc59358a77f2bd976546a02))






  * quotes in gene-impact report ([#217](https://github.com/varfish-org/clinvar-this/issues/217)) ([e10d4ef](https://github.com/varfish-org/clinvar-this/commit/e10d4eff92354528c380448a57abd47ad7602057))






  * per-gene report also includes other impact ([#216](https://github.com/varfish-org/clinvar-this/issues/216)) ([4b27718](https://github.com/varfish-org/clinvar-this/commit/4b27718d2a937b1bc2081c84ffa478917d0d0e27))




  * more API documentation ([#214](https://github.com/varfish-org/clinvar-this/issues/214)) ([41fc92a](https://github.com/varfish-org/clinvar-this/commit/41fc92afeab9acb5c24f793c1f72c7bc0e7127d1))






  * release as v0.15.2 ([#212](https://github.com/varfish-org/clinvar-this/issues/212)) ([23eb2dc](https://github.com/varfish-org/clinvar-this/commit/23eb2dcdcad532ab062b8ca6e540565968753f1c))






  * properly configure release-please with manifest ([#210](https://github.com/varfish-org/clinvar-this/issues/210)) ([25973e7](https://github.com/varfish-org/clinvar-this/commit/25973e75a03d04d032011ef7f7d735fe1d3627cb))






  * adjusting to new XML structure with germline/somatic split ([#201](https://github.com/varfish-org/clinvar-this/issues/201))



  * adjusting to new XML structure with germline/somatic split ([#201](https://github.com/varfish-org/clinvar-this/issues/201)) ([85652be](https://github.com/varfish-org/clinvar-this/commit/85652bebfa441f52c1395c15a5437df451839d33))






  * include JSON schemas in package ([#184](https://www.github.com/bihealth/clinvar-this/issues/184)) ([c3dc65a](https://www.github.com/bihealth/clinvar-this/commit/c3dc65a10c0cbadd05892146a9951d07cf18886e))






  * fixing MANIFEST.in for so py.typed are included ([#182](https://www.github.com/bihealth/clinvar-this/issues/182)) ([3015b32](https://www.github.com/bihealth/clinvar-this/commit/3015b32d13a44d034cbeea82d935c6e8f2534a6a))






  * adding missing py.typed files for mypy ([#180](https://www.github.com/bihealth/clinvar-this/issues/180)) ([3b5945a](https://www.github.com/bihealth/clinvar-this/commit/3b5945a51404decdbe79032d1afcf9b28ff6235a))






  * fixing counter types ([#178](https://www.github.com/bihealth/clinvar-this/issues/178)) ([0b23c6b](https://www.github.com/bihealth/clinvar-this/commit/0b23c6b574ee88a73945e27876193ddbc25dd971))






  * resolve dictionary dump enum issue ([#176](https://www.github.com/bihealth/clinvar-this/issues/176)) ([a6a6c20](https://www.github.com/bihealth/clinvar-this/commit/a6a6c20e24a6432bb57567c1236284d64338201b))






  * serialization of counter dict ([#174](https://www.github.com/bihealth/clinvar-this/issues/174)) ([06caa81](https://www.github.com/bihealth/clinvar-this/commit/06caa81c8f62cad5779fa62479474c52ca5c4a5d))






  * adding async client code via switch to httpx ([#167](https://www.github.com/bihealth/clinvar-this/issues/167)) ([#170](https://www.github.com/bihealth/clinvar-this/issues/170)) ([7b76770](https://www.github.com/bihealth/clinvar-this/commit/7b76770fa3423a0651b5068edc59ec0a8e8588af))
  * switch from attrs to pydantic ([#166](https://www.github.com/bihealth/clinvar-this/issues/166)) ([#168](https://www.github.com/bihealth/clinvar-this/issues/168)) ([d84db77](https://www.github.com/bihealth/clinvar-this/commit/d84db77ac2f33fc9c40c4a151fa730089b2f1788))
  * updating to latest upstream JSON schemas ([#173](https://www.github.com/bihealth/clinvar-this/issues/173)) ([f5da1fc](https://www.github.com/bihealth/clinvar-this/commit/f5da1fc02f20d3f34674b037f3f4068d4bf5cec8))
  * write out RCV/VCV version in extract_vars and phenotype_link ([#159](https://www.github.com/bihealth/clinvar-this/issues/159)) ([#172](https://www.github.com/bihealth/clinvar-this/issues/172)) ([534cba1](https://www.github.com/bihealth/clinvar-this/commit/534cba1d96f5f4c80ee7a744a847224942ad1561))




  * adding support for "no classification from unflagged records" review status ([#171](https://www.github.com/bihealth/clinvar-this/issues/171)) ([f144e74](https://www.github.com/bihealth/clinvar-this/commit/f144e7456f6177ee52e53f32e4940ab1b38ab68f))






  * pinning python to 3.11 in release for setuptools ([#164](https://www.github.com/bihealth/clinvar-this/issues/164)) ([afb6035](https://www.github.com/bihealth/clinvar-this/commit/afb60355e347449f107490d5eab351e8291e6d7a))






  * adapt to ClinVar public XML update ([#162](https://www.github.com/bihealth/clinvar-this/issues/162)) ([8d90a36](https://www.github.com/bihealth/clinvar-this/commit/8d90a36fd4acfca0fd11fcfb0673f16efbce56b3))






  * include VCV and title in "clinvar-data extract-vars" ([#152](https://www.github.com/bihealth/clinvar-this/issues/152)) ([c3e1bf2](https://www.github.com/bihealth/clinvar-this/commit/c3e1bf212643993ef0898f8ef28f4d0a973fcf7f))






  * Adding Clinvar Accession to TSV input ([#146](https://www.github.com/bihealth/clinvar-this/issues/146)) ([1ef8b8f](https://www.github.com/bihealth/clinvar-this/commit/1ef8b8f7784c729a1247a8b7e0522a4e262657c8))
  * Implement Pubmed IDs in tsv import format ([#143](https://www.github.com/bihealth/clinvar-this/issues/143)) ([9473380](https://www.github.com/bihealth/clinvar-this/commit/9473380191290edea046bd42d72df9b7c905f9e0))
  * Support multiple condition types and multiple conditions ([#147](https://www.github.com/bihealth/clinvar-this/issues/147)) ([f972356](https://www.github.com/bihealth/clinvar-this/commit/f972356c11a94a03d7545bfb9d1ffb889cef112b))




  * mypy linting of tests ([#144](https://www.github.com/bihealth/clinvar-this/issues/144)) ([ee1fc5d](https://www.github.com/bihealth/clinvar-this/commit/ee1fc5d98026c4c5c3c248eca4e0907f21d45f0e))




  * Update docs on file formats and fixing errors ([#150](https://www.github.com/bihealth/clinvar-this/issues/150)) ([0b9efc6](https://www.github.com/bihealth/clinvar-this/commit/0b9efc6640ffd4a814b1b5f8814589a9c6b65048))






  * typo accession => accession ([#135](https://www.github.com/bihealth/clinvar-this/issues/135)) ([9ac72a2](https://www.github.com/bihealth/clinvar-this/commit/9ac72a283873ba446d468cad597854e53a64689e))






  * properly write out variants to JSONL ([#133](https://www.github.com/bihealth/clinvar-this/issues/133)) ([17b7e5c](https://www.github.com/bihealth/clinvar-this/commit/17b7e5c7250a16edbf361c721a9af4ff58c1402e))






  * write out HGNC identifier with variants ([#130](https://www.github.com/bihealth/clinvar-this/issues/130)) ([#131](https://www.github.com/bihealth/clinvar-this/issues/131)) ([ea33100](https://www.github.com/bihealth/clinvar-this/commit/ea33100e4af3329fb7e3018be0a2c8d215678924))






  * write assessment to extract variants ([#128](https://www.github.com/bihealth/clinvar-this/issues/128)) ([dd72c90](https://www.github.com/bihealth/clinvar-this/commit/dd72c90a68f0e2cbd0306301de77985c0acb521e))




  * normalizing molecular consequence ([#126](https://www.github.com/bihealth/clinvar-this/issues/126)) ([c2a72cf](https://www.github.com/bihealth/clinvar-this/commit/c2a72cfcaea94752fdb8e278bc0a6d48748650a6))






  * variant extraction ([#124](https://www.github.com/bihealth/clinvar-this/issues/124)) ([c7bb7c9](https://www.github.com/bihealth/clinvar-this/commit/c7bb7c9a2376d37b512b494631cf62dfcc23b19b))






  * writing out clinical significance in gene-to-phenotype link ([#121](https://www.github.com/bihealth/clinvar-this/issues/121)) ([1c65fc6](https://www.github.com/bihealth/clinvar-this/commit/1c65fc6b9599a41810da4d020a84704e9a3f8c8c))






  * write out organisation and local key to phenotype gene link ([#119](https://www.github.com/bihealth/clinvar-this/issues/119)) ([f87facc](https://www.github.com/bihealth/clinvar-this/commit/f87facc5b2e2754d5a4825ea8af3528ab0b4b0fe))






  * allow read/write .gz everywhere ([#116](https://www.github.com/bihealth/clinvar-this/issues/116)) ([d3b658e](https://www.github.com/bihealth/clinvar-this/commit/d3b658e820953c38f7bc2b0727924490fc19ad8f))






  * adding clinvar_data to built package ([#114](https://www.github.com/bihealth/clinvar-this/issues/114)) ([4a78256](https://www.github.com/bihealth/clinvar-this/commit/4a78256a9a2f04a88472aa9b9617601e1b5c61f0))






  * add command to extract gene-to-phenotype links ([#104](https://www.github.com/bihealth/clinvar-this/issues/104)) ([#106](https://www.github.com/bihealth/clinvar-this/issues/106)) ([b3b323a](https://www.github.com/bihealth/clinvar-this/commit/b3b323a2e440d4e4e34c9895f7e0b39b5425fdd7))
  * adding --version option ([#110](https://www.github.com/bihealth/clinvar-this/issues/110)) ([7f3b091](https://www.github.com/bihealth/clinvar-this/commit/7f3b0917e39144b0b2fbbf760337ac16299500af))
  * adding command to generate per-gene impact report ([#102](https://www.github.com/bihealth/clinvar-this/issues/102)) ([#103](https://www.github.com/bihealth/clinvar-this/issues/103)) ([c86a5c7](https://www.github.com/bihealth/clinvar-this/commit/c86a5c721ac5b089d63301a7ce40c0eea552b209))
  * adding missing clinvar measure set ([#109](https://www.github.com/bihealth/clinvar-this/issues/109)) ([f0f64e0](https://www.github.com/bihealth/clinvar-this/commit/f0f64e0036a8b73eb6add02f81fcb54768b0b35f))
  * adding support for parsing ClinVar XML ([#99](https://www.github.com/bihealth/clinvar-this/issues/99)) ([#100](https://www.github.com/bihealth/clinvar-this/issues/100)) ([c673f7d](https://www.github.com/bihealth/clinvar-this/commit/c673f7db8d94f0c05c1acd4c413e060db54a8649))
  * command to extract variants per ACMG class and freq. ([#107](https://www.github.com/bihealth/clinvar-this/issues/107)) ([#108](https://www.github.com/bihealth/clinvar-this/issues/108)) ([c623f6d](https://www.github.com/bihealth/clinvar-this/commit/c623f6d804e7f9579b0cd8f15b086b066aef6338))




  * making conversion more robust, indicate errors ([#105](https://www.github.com/bihealth/clinvar-this/issues/105)) ([8333aea](https://www.github.com/bihealth/clinvar-this/commit/8333aea26cdc07b4467fa9ca56ea86eda642dd30))






  * removing versioneer in favour of version from release-please ([#95](https://www.github.com/bihealth/clinvar-this/issues/95)) ([5b922bb](https://www.github.com/bihealth/clinvar-this/commit/5b922bb0a1fef23426cc73890db3f0868d668947))




  * using varfish-bot token for release-please ([#97](https://www.github.com/bihealth/clinvar-this/issues/97)) ([35fad52](https://www.github.com/bihealth/clinvar-this/commit/35fad5261210e8dfadc1e93fe151f4e885fb843b))






  * fixing strucvar export ([#84](https://www.github.com/bihealth/clinvar-this/issues/84)) ([1050a67](https://www.github.com/bihealth/clinvar-this/commit/1050a67edff50150da955f0e5364148c82b46902))
  * sequence variant export ([#82](https://www.github.com/bihealth/clinvar-this/issues/82)) ([0fe3fb9](https://www.github.com/bihealth/clinvar-this/commit/0fe3fb9b4ec783218a408926007bb7370c70be64))






  * add support for SV TSV files ([#75](https://www.github.com/bihealth/clinvar-this/issues/75)) ([#78](https://www.github.com/bihealth/clinvar-this/issues/78)) ([d4fffce](https://www.github.com/bihealth/clinvar-this/commit/d4fffce3772ed33c9d12c81b983e3e152f0c2d83))




  * add badges to readme ([#65](https://www.github.com/bihealth/clinvar-this/issues/65)) ([207038c](https://www.github.com/bihealth/clinvar-this/commit/207038ccfa2473e09f283903e9c2a3cd249e2f30))
  * adding file format documentation ([#71](https://www.github.com/bihealth/clinvar-this/issues/71)) ([3a04ffd](https://www.github.com/bihealth/clinvar-this/commit/3a04ffddd50ab21c52d3d2fe281d96ac30c505cb))
  * extending docs; getting started from README ([#44](https://www.github.com/bihealth/clinvar-this/issues/44)) ([#68](https://www.github.com/bihealth/clinvar-this/issues/68)) ([77892f0](https://www.github.com/bihealth/clinvar-this/commit/77892f0fdaf158ed77c126f0aae11b12457c6043))
  * updating docs introduction section ([#67](https://www.github.com/bihealth/clinvar-this/issues/67)) ([d6c865b](https://www.github.com/bihealth/clinvar-this/commit/d6c865b28db14e217c839239940bf9fe4fdcd5ed))






  * add basic config management in CLI ([#32](https://www.github.com/bihealth/clinvar-this/issues/32)) ([#33](https://www.github.com/bihealth/clinvar-this/issues/33)) ([c903546](https://www.github.com/bihealth/clinvar-this/commit/c903546751fe6c59fcc20770b6a1ad1ac88fbd86))
  * add functions for managing batch data ([#34](https://www.github.com/bihealth/clinvar-this/issues/34), [#37](https://www.github.com/bihealth/clinvar-this/issues/37)) ([#35](https://www.github.com/bihealth/clinvar-this/issues/35)) ([0c7e0f9](https://www.github.com/bihealth/clinvar-this/commit/0c7e0f9b65dc0b2189c302065cdebdc2489ea842))
  * add sphinx-based documentation ([#30](https://www.github.com/bihealth/clinvar-this/issues/30)) ([#31](https://www.github.com/bihealth/clinvar-this/issues/31)) ([d10adc5](https://www.github.com/bihealth/clinvar-this/commit/d10adc50a720548b580b7aa6bd52477012bb6d29))
  * add tests for submission messages ([#19](https://www.github.com/bihealth/clinvar-this/issues/19)) ([#22](https://www.github.com/bihealth/clinvar-this/issues/22)) ([b168d47](https://www.github.com/bihealth/clinvar-this/commit/b168d47e0b3aed8d3a706ddbd28ddbb635ad86b4))
  * add unit tests for submission messages ([#19](https://www.github.com/bihealth/clinvar-this/issues/19)) ([#20](https://www.github.com/bihealth/clinvar-this/issues/20)) ([1c4e11a](https://www.github.com/bihealth/clinvar-this/commit/1c4e11aa6eda5ebce0a66e8f21f17ea89c7ed7e2))
  * adding mypy type checking ([#11](https://www.github.com/bihealth/clinvar-this/issues/11)) ([#12](https://www.github.com/bihealth/clinvar-this/issues/12)) ([700994a](https://www.github.com/bihealth/clinvar-this/commit/700994a113f2441bba76e3dc95adccf9fed6a156))
  * adjust to ClinVar API change (Nov 2022) ([#47](https://www.github.com/bihealth/clinvar-this/issues/47)) ([#48](https://www.github.com/bihealth/clinvar-this/issues/48)) ([0e4fb50](https://www.github.com/bihealth/clinvar-this/commit/0e4fb508bda571c0c0afdab417e9052667f46ea1))
  * allow annotation with HPO terms in TSV format ([#50](https://www.github.com/bihealth/clinvar-this/issues/50)) ([#56](https://www.github.com/bihealth/clinvar-this/issues/56)) ([0b0da41](https://www.github.com/bihealth/clinvar-this/commit/0b0da41e938e464e97ea1be7edcad6c666860f1e))
  * allow import of extra columns ([#53](https://www.github.com/bihealth/clinvar-this/issues/53)) ([#54](https://www.github.com/bihealth/clinvar-this/issues/54)) ([616bfe7](https://www.github.com/bihealth/clinvar-this/commit/616bfe7867fe7ddd1c898f7582b1a353069b7ccd))
  * completing enums ([#23](https://www.github.com/bihealth/clinvar-this/issues/23)) ([#24](https://www.github.com/bihealth/clinvar-this/issues/24)) ([9198983](https://www.github.com/bihealth/clinvar-this/commit/919898305a6155408118cd43a982c78153976879))
  * implement api models ([#4](https://www.github.com/bihealth/clinvar-this/issues/4)) ([#5](https://www.github.com/bihealth/clinvar-this/issues/5)) ([3690c36](https://www.github.com/bihealth/clinvar-this/commit/3690c36b25fc98e520a401f8755a48b3451a972f))
  * implement attrs-based message models ([#1](https://www.github.com/bihealth/clinvar-this/issues/1)) ([#2](https://www.github.com/bihealth/clinvar-this/issues/2)) ([f253c24](https://www.github.com/bihealth/clinvar-this/commit/f253c248cf35f749ace3c68633eb8d0357349688))
  * implement enums for submission messages ([#14](https://www.github.com/bihealth/clinvar-this/issues/14)) ([#16](https://www.github.com/bihealth/clinvar-this/issues/16)) ([201cbe4](https://www.github.com/bihealth/clinvar-this/commit/201cbe4e055e0d013efe6f85a91b5ec339c77838))
  * implement internal models for submissions ([#9](https://www.github.com/bihealth/clinvar-this/issues/9)) ([#26](https://www.github.com/bihealth/clinvar-this/issues/26)) ([be04e40](https://www.github.com/bihealth/clinvar-this/commit/be04e40e15adba180827fdc808c17d7d1647edb7))
  * implement minimal TSV format ([#17](https://www.github.com/bihealth/clinvar-this/issues/17)) ([#18](https://www.github.com/bihealth/clinvar-this/issues/18)) ([960827d](https://www.github.com/bihealth/clinvar-this/commit/960827d9be757e5cc1cfe537451e3a34c738b256))
  * implement models for extra files ([#6](https://www.github.com/bihealth/clinvar-this/issues/6)) ([#13](https://www.github.com/bihealth/clinvar-this/issues/13)) ([852e4c6](https://www.github.com/bihealth/clinvar-this/commit/852e4c6cd981ae533afbfda0217a4b9e1de8065e))
  * implement models for submission message ([#8](https://www.github.com/bihealth/clinvar-this/issues/8)) ([#15](https://www.github.com/bihealth/clinvar-this/issues/15)) ([90afd10](https://www.github.com/bihealth/clinvar-this/commit/90afd105fc0d29c3962529157f38a20e48090a56))
  * implement more columns in TSV ([#39](https://www.github.com/bihealth/clinvar-this/issues/39)) ([#55](https://www.github.com/bihealth/clinvar-this/issues/55)) ([6184d76](https://www.github.com/bihealth/clinvar-this/commit/6184d76a2f8261131718bbe69e88fdaf66b3a8de))
  * implementing REST clinvar_api.client module ([#28](https://www.github.com/bihealth/clinvar-this/issues/28)) ([#29](https://www.github.com/bihealth/clinvar-this/issues/29)) ([829d907](https://www.github.com/bihealth/clinvar-this/commit/829d907763db617a04d277f297256980d25d51ab))
  * store errors from "batch retrieve" ([#59](https://www.github.com/bihealth/clinvar-this/issues/59)) ([#60](https://www.github.com/bihealth/clinvar-this/issues/60)) ([67b8b0c](https://www.github.com/bihealth/clinvar-this/commit/67b8b0ccd85d4a913e7b8f1eb30dc4e96a2af32c))
  * write data into profile sub directory ([#52](https://www.github.com/bihealth/clinvar-this/issues/52)) ([e699736](https://www.github.com/bihealth/clinvar-this/commit/e6997367d77586c1337a44fa7b5306ecede52a41))




  * interpret TSV OMIM "not provided" ([#57](https://www.github.com/bihealth/clinvar-this/issues/57)) ([#58](https://www.github.com/bihealth/clinvar-this/issues/58)) ([b655097](https://www.github.com/bihealth/clinvar-this/commit/b655097f2bf534b57115e3f9f5d18387ddfb1f18))




  * add getting started tutorial to README ([#45](https://www.github.com/bihealth/clinvar-this/issues/45)) ([#61](https://www.github.com/bihealth/clinvar-this/issues/61)) ([3de084b](https://www.github.com/bihealth/clinvar-this/commit/3de084b49c184dfc6fb977b64cf478f03275ef9b))


pkgId: 8a000e139e4284e7f46d298a1280804b5ce2b20c72584ed09735c7e1f4a802a6
name: python-clip-as-service
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: Embed images and sentences into fixed-length vectors via CLIP
url: https://github.com/jina-ai/clip-as-service
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clip-as-service-0.8.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://clip-as-service.jina.ai"><img src="https://github.com/jina-ai/clip-as-service/blob/main/docs/_static/logo-light.svg?raw=true" alt="CLIP-as-service logo: The data structure for unstructured data" width="200px"></a>
  <br><br><br>
  </p>


  <p align=center>
  <a href="https://pypi.org/project/clip_server/"><img alt="PyPI" src="https://img.shields.io/pypi/v/clip_server?label=Release&style=flat-square"></a>
  <a href="https://discord.jina.ai"><img src="https://img.shields.io/discord/1106542220112302130?logo=discord&logoColor=white&style=flat-square"></a>
  <a href="https://codecov.io/gh/jina-ai/clip-as-service"><img alt="Codecov branch" src="https://img.shields.io/codecov/c/github/jina-ai/clip-as-service/main?logo=Codecov&logoColor=white&style=flat-square"></a>
  <a href="https://colab.research.google.com/github/jina-ai/clip-as-service/blob/main/docs/hosting/cas-on-colab.ipynb"><img src="https://img.shields.io/badge/Host-on%20Google%20Colab%20(GPU/TPU)-brightgreen?style=flat-square&logo=googlecolab&&logoColor=white" alt="Host on Google Colab with GPU/TPU support"></a>
  </p>

  <!-- start elevator-pitch -->

  CLIP-as-service is a low-latency high-scalability service for embedding images and text. It can be easily integrated as a microservice into neural search solutions.

  ⚡ **Fast**: Serve CLIP models with TensorRT, ONNX runtime and PyTorch w/o JIT with 800QPS<sup>[*]</sup>. Non-blocking duplex streaming on requests and responses, designed for large data and long-running tasks.

  🫐 **Elastic**: Horizontally scale up and down multiple CLIP models on single GPU, with automatic load balancing.

  🐥 **Easy-to-use**: No learning curve, minimalist design on client and server. Intuitive and consistent API for image and sentence embedding.

  👒 **Modern**: Async client support. Easily switch between gRPC, HTTP, WebSocket protocols with TLS and compression.

  🍱 **Integration**: Smooth integration with neural search ecosystem including [Jina](https://github.com/jina-ai/jina) and [DocArray](https://github.com/jina-ai/docarray). Build cross-modal and multi-modal solutions in no time.

  <sup>[*] with default config (single replica, PyTorch no JIT) on GeForce RTX 3090. </sup>

  <!-- end elevator-pitch -->



  <table>
  <tr>
  <td> via HTTPS 🔐 </td>
  <td> via gRPC 🔐⚡⚡ </td>
  </tr>
  <tr>
  <td>

  ```bash
  curl \
  -X POST https://<your-inference-address>-http.wolf.jina.ai/post \
  -H 'Content-Type: application/json' \
  -H 'Authorization: <your access token>' \
  -d '{"data":[{"text": "First do it"},
      {"text": "then do it right"},
      {"text": "then do it better"},
      {"uri": "https://picsum.photos/200"}],
      "execEndpoint":"/"}'
  ```

  </td>
  <td>

  ```python

  from clip_client import Client

  c = Client(
      'grpcs://<your-inference-address>-grpc.wolf.jina.ai',
      credential={'Authorization': '<your access token>'},
  )

  r = c.encode(
      [
          'First do it',
          'then do it right',
          'then do it better',
          'https://picsum.photos/200',
      ]
  )
  print(r)
  ```
  </td>
  </tr>
  </table>



  There are four basic visual reasoning skills: object recognition, object counting, color recognition, and spatial relation understanding. Let's try some:

  > You need to install [`jq` (a JSON processor)](https://stedolan.github.io/jq/) to prettify the results.

  <table>
  <tr>
  <td> Image </td>
  <td> via HTTPS 🔐 </td>
  </tr>
  <tr>
  <td>
  <img src="https://picsum.photos/id/1/300/300">
  </td>
  <td>

  ```bash
  curl \
  -X POST https://<your-inference-address>-http.wolf.jina.ai/post \
  -H 'Content-Type: application/json' \
  -H 'Authorization: <your access token>' \
  -d '{"data":[{"uri": "https://picsum.photos/id/1/300/300",
  "matches": [{"text": "there is a woman in the photo"},
              {"text": "there is a man in the photo"}]}],
              "execEndpoint":"/rank"}' \
  | jq ".data[].matches[] | (.text, .scores.clip_score.value)"
  ```

  gives:

  ```
  "there is a woman in the photo"
  0.626907229423523
  "there is a man in the photo"
  0.37309277057647705
  ```

  </td>
  </tr>
  <tr>
  <td>
  <img src="https://picsum.photos/id/133/300/300">
  </td>
  <td>

  ```bash
  curl \
  -X POST https://<your-inference-address>-http.wolf.jina.ai/post \
  -H 'Content-Type: application/json' \
  -H 'Authorization: <your access token>' \
  -d '{"data":[{"uri": "https://picsum.photos/id/133/300/300",
  "matches": [
  {"text": "the blue car is on the left, the red car is on the right"},
  {"text": "the blue car is on the right, the red car is on the left"},
  {"text": "the blue car is on top of the red car"},
  {"text": "the blue car is below the red car"}]}],
  "execEndpoint":"/rank"}' \
  | jq ".data[].matches[] | (.text, .scores.clip_score.value)"
  ```

  gives:
  ```
  "the blue car is on the left, the red car is on the right"
  0.5232442617416382
  "the blue car is on the right, the red car is on the left"
  0.32878655195236206
  "the blue car is below the red car"
  0.11064132302999496
  "the blue car is on top of the red car"
  0.03732786327600479
  ```

  </td>
  </tr>


  <tr>
  <td>
  <img src="https://picsum.photos/id/102/300/300">
  </td>
  <td>

  ```bash
  curl \
  -X POST https://<your-inference-address>-http.wolf.jina.ai/post \
  -H 'Content-Type: application/json' \
  -H 'Authorization: <your access token>' \
  -d '{"data":[{"uri": "https://picsum.photos/id/102/300/300",
  "matches": [{"text": "this is a photo of one berry"},
              {"text": "this is a photo of two berries"},
              {"text": "this is a photo of three berries"},
              {"text": "this is a photo of four berries"},
              {"text": "this is a photo of five berries"},
              {"text": "this is a photo of six berries"}]}],
              "execEndpoint":"/rank"}' \
  | jq ".data[].matches[] | (.text, .scores.clip_score.value)"
  ```

  gives:
  ```
  "this is a photo of three berries"
  0.48507222533226013
  "this is a photo of four berries"
  0.2377079576253891
  "this is a photo of one berry"
  0.11304923892021179
  "this is a photo of five berries"
  0.0731358453631401
  "this is a photo of two berries"
  0.05045759305357933
  "this is a photo of six berries"
  0.04057715833187103
  ```

  </td>
  </tr>


  </table>






  CLIP-as-service consists of two Python packages `clip-server` and `clip-client` that can be installed _independently_. Both require Python 3.7+.



  <table>
  <tr>
  <td> Pytorch Runtime ⚡ </td>
  <td> ONNX Runtime ⚡⚡</td>
  <td> TensorRT Runtime ⚡⚡⚡ </td>
  </tr>
  <tr>
  <td>

  ```bash
  pip install clip-server
  ```

  </td>
  <td>

  ```bash
  pip install "clip-server[onnx]"
  ```

  </td>
  <td>

  ```bash
  pip install nvidia-pyindex
  pip install "clip-server[tensorrt]"
  ```
  </td>
  </tr>
  </table>

  You can also [host the server on Google Colab](https://clip-as-service.jina.ai/hosting/colab/), leveraging its free GPU/TPU.



  ```bash
  pip install clip-client
  ```



  You can run a simple connectivity check after install.


  <table>
  <tr>
  <th> C/S </th>
  <th> Command </th>
  <th> Expect output </th>
  </tr>
  <tr>
  <td>
  Server
  </td>
  <td>

  ```bash
  python -m clip_server
  ```

  </td>
  <td>

  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/server-output.svg?raw=true" alt="Expected server output" width="300px">

  </td>
  </tr>
  <tr>
  <td>
  Client
  </td>
  <td>

  ```python
  from clip_client import Client

  c = Client('grpc://0.0.0.0:23456')
  c.profile()
  ```

  </td>
  <td>

  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/pyclient-output.svg?raw=true" alt="Expected clip-client output" width="300px">

  </td>
  </tr>
  </table>


  You can change `0.0.0.0` to the intranet or public IP address to test the connectivity over private and public network.






  1. Start the server: `python -m clip_server`. Remember its address and port.
  2. Create a client:
     ```python
      from clip_client import Client

      c = Client('grpc://0.0.0.0:51000')
      ```
  3. To get sentence embedding:
      ```python
      r = c.encode(['First do it', 'then do it right', 'then do it better'])

      print(r.shape)  # [3, 512]
      ```
  4. To get image embedding:
      ```python
      r = c.encode(['apple.png',  # local image
                    'https://clip-as-service.jina.ai/_static/favicon.png',  # remote image
                    'data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7'])  # in image URI

      print(r.shape)  # [3, 512]
      ```

  More comprehensive server and client user guides can be found in the [docs](https://clip-as-service.jina.ai/).



  Let's build a text-to-image search using CLIP-as-service. Namely, a user can input a sentence and the program returns matching images. We'll use the [Totally Looks Like](https://sites.google.com/view/totally-looks-like-dataset) dataset and [DocArray](https://github.com/jina-ai/docarray) package. Note that DocArray is included within `clip-client` as an upstream dependency, so you don't need to install it separately.



  First we load images. You can simply pull them from Jina Cloud:

  ```python
  from docarray import DocumentArray

  da = DocumentArray.pull('ttl-original', show_progress=True, local_cache=True)
  ```

  <details>
  <summary>or download TTL dataset, unzip, load manually</summary>

  Alternatively, you can go to [Totally Looks Like](https://sites.google.com/view/totally-looks-like-dataset) official website, unzip and load images:

  ```python
  from docarray import DocumentArray

  da = DocumentArray.from_files(['left/*.jpg', 'right/*.jpg'])
  ```

  </details>

  The dataset contains 12,032 images, so it may take a while to pull. Once done, you can visualize it and get the first taste of those images:

  ```python
  da.plot_image_sprites()
  ```

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/ttl-image-sprites.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="50%">
  </p>



  Start the server with `python -m clip_server`. Let's say it's at `0.0.0.0:51000` with `GRPC` protocol (you will get this information after running the server).

  Create a Python client script:

  ```python
  from clip_client import Client

  c = Client(server='grpc://0.0.0.0:51000')

  da = c.encode(da, show_progress=True)
  ```

  Depending on your GPU and client-server network, it may take a while to embed 12K images. In my case, it took about two minutes.

  <details>
  <summary>Download the pre-encoded dataset</summary>

  If you're impatient or don't have a GPU, waiting can be Hell. In this case, you can simply pull our pre-encoded image dataset:

  ```python
  from docarray import DocumentArray

  da = DocumentArray.pull('ttl-embedding', show_progress=True, local_cache=True)
  ```

  </details>



  Let's build a simple prompt to allow a user to type sentence:

  ```python
  while True:
      vec = c.encode([input('sentence> ')])
      r = da.find(query=vec, limit=9)
      r[0].plot_image_sprites()
  ```



  Now you can input arbitrary English sentences and view the top-9 matching images. Search is fast and instinctive. Let's have some fun:

  <table>
  <tr>
  <th> "a happy potato" </th>
  <th> "a super evil AI" </th>
  <th> "a guy enjoying his burger" </th>
  </tr>
  <tr>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/a-happy-potato.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="100%">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/a-super-evil-AI.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="100%">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/a-guy-enjoying-his-burger.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="100%">
  </p>

  </td>
  </tr>
  </table>


  <table>
  <tr>
  <th> "professor cat is very serious" </th>
  <th> "an ego engineer lives with parent" </th>
  <th> "there will be no tomorrow so lets eat unhealthy" </th>
  </tr>
  <tr>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/professor-cat-is-very-serious.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="100%">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/an-ego-engineer-lives-with-parent.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="100%">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/there-will-be-no-tomorrow-so-lets-eat-unhealthy.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" width="100%">
  </p>

  </td>
  </tr>
  </table>

  Let's save the embedding result for our next example:

  ```python
  da.save_binary('ttl-image')
  ```



  We can also switch the input and output of the last program to achieve image-to-text search. Precisely, given a query image find the sentence that best describes the image.

  Let's use all sentences from the book "Pride and Prejudice".

  ```python
  from docarray import Document, DocumentArray

  d = Document(uri='https://www.gutenberg.org/files/1342/1342-0.txt').load_uri_to_text()
  da = DocumentArray(
      Document(text=s.strip()) for s in d.text.replace('\r\n', '').split('.') if s.strip()
  )
  ```

  Let's look at what we got:

  ```python
  da.summary()
  ```

  ```text
              Documents Summary

    Length                 6403
    Homogenous Documents   True
    Common Attributes      ('id', 'text')

                       Attributes Summary

    Attribute   Data type   #Unique values   Has empty value
   ──────────────────────────────────────────────────────────
    id          ('str',)    6403             False
    text        ('str',)    6030             False
  ```



  Now encode these 6,403 sentences, it may take 10 seconds or less depending on your GPU and network:

  ```python
  from clip_client import Client

  c = Client('grpc://0.0.0.0:51000')

  r = c.encode(da, show_progress=True)
  ```

  <details>
  <summary>Download the pre-encoded dataset</summary>

  Again, for people who are impatient or don't have a GPU, we have prepared a pre-encoded text dataset:

  ```python
  from docarray import DocumentArray

  da = DocumentArray.pull('ttl-textual', show_progress=True, local_cache=True)
  ```

  </details>



  Let's load our previously stored image embedding, randomly sample 10 image Documents, then find top-1 nearest neighbour of each.

  ```python
  from docarray import DocumentArray

  img_da = DocumentArray.load_binary('ttl-image')

  for d in img_da.sample(10):
      print(da.find(d.embedding, limit=1)[0].text)
  ```



  Fun time! Note, unlike the previous example, here the input is an image and the sentence is the output. All sentences come from the book "Pride and Prejudice".

  <table>
  <tr>
  <td>
  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/Besides,-there-was-truth-in-his-looks.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>


  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/Gardiner-smiled.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/what’s-his-name.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/By-tea-time,-however,-the-dose-had-been-enough,-and-Mr.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>

  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/You-do-not-look-well.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>
  </tr>
  <tr>
  <td>Besides, there was truth in his looks</td>
  <td>Gardiner smiled</td>
  <td>what’s his name</td>
  <td>By tea time, however, the dose had been enough, and Mr</td>
  <td>You do not look well</td>
  </tr>
  </table>

  <table>
  <tr>
  <td>
  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/“A-gamester!”-she-cried.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>


  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/If-you-mention-my-name-at-the-Bell,-you-will-be-attended-to.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/Never-mind-Miss-Lizzy’s-hair.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>
  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/Elizabeth-will-soon-be-the-wife-of-Mr.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>

  <td>

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/I-saw-them-the-night-before-last.png?raw=true" alt="Visualization of the image sprite of Totally looks like dataset" height="100px">
  </p>

  </td>
  </tr>
  <tr>
  <td>“A gamester!” she cried</td>
  <td>If you mention my name at the Bell, you will be attended to</td>
  <td>Never mind Miss Lizzy’s hair</td>
  <td>Elizabeth will soon be the wife of Mr</td>
  <td>I saw them the night before last</td>
  </tr>
  </table>





  From `0.3.0` CLIP-as-service adds a new `/rank` endpoint that re-ranks cross-modal matches according to their joint likelihood in CLIP model. For example, given an image Document with some predefined sentence matches as below:

  ```python
  from clip_client import Client
  from docarray import Document

  c = Client(server='grpc://0.0.0.0:51000')
  r = c.rank(
      [
          Document(
              uri='.github/README-img/rerank.png',
              matches=[
                  Document(text=f'a photo of a {p}')
                  for p in (
                      'control room',
                      'lecture room',
                      'conference room',
                      'podium indoor',
                      'television studio',
                  )
              ],
          )
      ]
  )

  print(r['@m', ['text', 'scores__clip_score__value']])
  ```

  ```text
  [['a photo of a television studio', 'a photo of a conference room', 'a photo of a lecture room', 'a photo of a control room', 'a photo of a podium indoor'],
  [0.9920725226402283, 0.006038925610482693, 0.0009973491542041302, 0.00078492151806131, 0.00010626466246321797]]
  ```

  One can see now `a photo of a television studio` is ranked to the top with `clip_score` score at `0.992`. In practice, one can use this endpoint to re-rank the matching result from another search system, for improving the cross-modal search quality.

  <table>
  <tr>
  <td>
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/rerank.png?raw=true" alt="Rerank endpoint image input" height="150px">
  </td>
  <td>
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/rerank-chart.svg?raw=true" alt="Rerank endpoint output">
  </td>
  </tr>
  </table>



  In the [DALL·E Flow](https://github.com/jina-ai/dalle-flow) project, CLIP is called for ranking the generated results from DALL·E. [It has an Executor wrapped on top of `clip-client`](https://github.com/jina-ai/dalle-flow/blob/main/executors/rerank/executor.py), which calls `.arank()` - the async version of `.rank()`:

  ```python
  from clip_client import Client
  from jina import Executor, requests, DocumentArray


  class ReRank(Executor):
      def __init__(self, clip_server: str, **kwargs):
          super().__init__(**kwargs)
          self._client = Client(server=clip_server)

      @requests(on='/')
      async def rerank(self, docs: DocumentArray, **kwargs):
          return await self._client.arank(docs)
  ```

  <p align="center">
  <img src="https://github.com/jina-ai/clip-as-service/blob/main/.github/README-img/client-dalle.png?raw=true" alt="CLIP-as-service used in DALLE Flow" width="300px">
  </p>

  Intrigued? That's only scratching the surface of what CLIP-as-service is capable of. [Read our docs to learn more](https://clip-as-service.jina.ai).

  <!-- start support-pitch -->


  - Join our [Discord community](https://discord.jina.ai) and chat with other community members about ideas.
  - Watch our [Engineering All Hands](https://youtube.com/playlist?list=PL3UBBWOUVhFYRUa_gpYYKBqEAkO4sxmne) to learn Jina's new features and stay up-to-date with the latest AI techniques.
  - Subscribe to the latest video tutorials on our [YouTube channel](https://youtube.com/c/jina-ai)



  CLIP-as-service is backed by [Jina AI](https://jina.ai) and licensed under [Apache-2.0](./LICENSE). [We are actively hiring](https://jobs.jina.ai) AI engineers, solution engineers to build the next neural search ecosystem in open-source.

  <!-- end support-pitch -->


pkgId: eb85e54d6cf93fe195dc47385f2ed8be12598d016cf7ee94482ee94eaf535e6a
name: python-clip-files
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: clip-files copies.
url: https://github.com/basnijholt/clip-files
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clip-files-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ![](https://media.githubusercontent.com/media/basnijholt/nijho.lt/main/content/project/clip-files/featured.jpg)

  ![Build](https://github.com/basnijholt/clip-files/actions/workflows/pytest.yml/badge.svg)
  [![Coverage](https://img.shields.io/codecov/c/github/basnijholt/clip-files)](https://codecov.io/gh/basnijholt/clip-files)
  [![GitHub](https://img.shields.io/github/stars/basnijholt/clip-files.svg?style=social)](https://github.com/basnijholt/clip-files/stargazers)
  [![PyPI](https://img.shields.io/pypi/v/clip-files.svg)](https://pypi.python.org/pypi/clip-files)
  [![License](https://img.shields.io/github/license/basnijholt/clip-files)](https://github.com/basnijholt/clip-files/blob/main/LICENSE)
  [![Downloads](https://img.shields.io/pypi/dm/clip-files)](https://pypi.python.org/pypi/clip-files)
  ![Open Issues](https://img.shields.io/github/issues-raw/basnijholt/clip-files)

  Introducing `clip-files` - a simple yet useful command-line utility to gather files with a specific extension, format them with their full path, and copy their contents to your clipboard with a token count for GPT-4 usage!
  Makes it simple to paste in your entire project into e.g., ChatGPT or Claude.ai, now that massive token limits are available.

  <details><summary><b><u>[ToC]</u></b> 📚</summary>

  <!-- START doctoc generated TOC please keep comment here to allow auto update -->
  <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->

  - [:star2: Features](#star2-features)
  - [:books: Usage](#books-usage)
  - [:bulb: Examples](#bulb-examples)
  - [:hammer_and_wrench: Installation](#hammer_and_wrench-installation)
  - [:file_folder: Supported File Types](#file_folder-supported-file-types)
  - [:1234: Token Counting](#1234-token-counting)
  - [:heart: Support and Contributions](#heart-support-and-contributions)

  <!-- END doctoc generated TOC please keep comment here to allow auto update -->

  </details>



  * 📋 Collect files with a specific extension and copy their formatted contents to your clipboard.
  * 📁 Prepend each file with `# File: full_path_here` for clarity.
  * 🧮 Calculate and display the total number of tokens used, compatible with GPT-4 tokenization.
  * 🔄 Easily handle and process multiple files in various directories.



  To use `clip-files`, simply provide the directory to search and the file extension you want to collect:

  ```bash
  clip-files --help
  ```
  Shows the help message:

  <!-- CODE:BASH:START -->
  <!-- echo '```bash' -->
  <!-- clip-files --help -->
  <!-- echo '```' -->
  <!-- CODE:END -->

  <!-- OUTPUT:START -->
  <!-- ⚠️ This content is auto-generated by `markdown-code-runner`. -->
  ```bash
  usage: clip-files [-h] [--initial-file INITIAL_FILE]
                    [--files FILES [FILES ...]]
                    [folder] [extension]

  Collect files with a specific extension or specific files, format them for clipboard, and count tokens.

  There are two main ways to use clip-files:

  1. Collecting all files with a specific extension in a folder:
     `clip-files FOLDER EXTENSION`
     Examples:
     - `clip-files . .py`  # all Python files in current directory
     - `clip-files src .txt`  # all text files in src directory
     - `clip-files docs .md --initial-file instructions.txt`  # with custom instructions

  2. Collecting specific files (can be of different types):
     `clip-files --files FILE [FILE ...]`
     Examples:
     - `clip-files --files src/*.py tests/*.py`  # using shell wildcards
     - `clip-files --files src/main.py docs/README.md`  # different file types
     - `clip-files --files src/*.py --initial-file instructions.txt`  # with custom instructions

  Note: When using wildcards (e.g., *.py), your shell will expand them before passing to clip-files.

  positional arguments:
    folder                The folder to search for files.
    extension             The file extension to look for (e.g., .py, .txt).

  options:
    -h, --help            show this help message and exit
    --initial-file INITIAL_FILE
                          A file containing initial instructions to prepend to
                          the clipboard content. Default is an empty string.
    --files FILES [FILES ...]
                          Specific file paths to include (e.g., --files
                          path/to/file1.py path/to/file2.md). If not provided,
                          all files with the specified extension are included.
  ```

  <!-- OUTPUT:END -->

  `clip-files` will traverse the specified folder, gather files with the desired extension, format them with their paths, and copy the results to your clipboard along with the token count.



  > [!TIP]
  > Pro-tip! Just use `uv` to run `clip-files` without installing it.
  > For example, `uv run clip-files --files *.py` will run `clip-files` in an temporary environment.

  There are two main ways to use `clip-files`:

  1. Collecting all files with a specific extension in a folder:

  ```bash

  clip-files . .py


  clip-files documents .txt


  clip-files src .py --initial-file instructions.txt
  ```

  2. Collecting specific files (can be of different types):

  ```bash

  clip-files --files src/main.py tests/test_app.py


  clip-files --files src/*.py tests/*.py


  clip-files --files src/*.py docs/*.md config/*.json


  clip-files --initial-file instructions.txt --files src/*.py
  ```

  Note: When using wildcards (e.g., `*.py`), your shell will expand them before passing to `clip-files`.



  To install `clip-files`, use pip:

  ```bash
  pip install clip-files
  ```

  Alternatively, clone the repository:

  ```bash
  git clone https://github.com/basnijholt/clip-files.git
  cd clip-files
  pip install .
  ```

  Or download the script directly:

  ```bash
  wget https://raw.githubusercontent.com/basnijholt/clip-files/main/clip_files.py
  ```
  and run it using:

  ```bash
  python clip_files.py --help
  ```



  `clip-files` supports any file type as long as you provide the correct file extension. Common examples include:

  - `.py` for Python files
  - `.txt` for text files
  - `.md` for Markdown files



  `clip-files` integrates with the `tiktoken` library to calculate tokens as they would be counted in GPT-4. This helps in understanding the cost and feasibility of processing the collected text with GPT-4 models.

  The script will display the total token count after copying the formatted content to the clipboard.



  We welcome feedback and contributions! If you encounter any issues or have suggestions for improvements, please file an issue on our GitHub repository. Contributions via pull requests are also appreciated.

  Happy collecting and clipping! 📋📁🎉


pkgId: efa599c896a1fc780726015ef8c613151649338c373334c8208a4dd0b5b2bba1
name: python-clip-interrogator
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Generate a prompt from an image
url: https://github.com/pharmapsychotic/clip-interrogator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clip-interrogator-0.6.0-1.src.rpm
checksum_type: sha256
description:
  *Want to figure out what a good prompt might be to create new images like an existing one? The **CLIP Interrogator** is here to get you answers!*



  🆕 Now available as a [Stable Diffusion Web UI Extension](https://github.com/pharmapsychotic/clip-interrogator-ext)! 🆕

  <br>

  Run Version 2 on Colab, HuggingFace, and Replicate!

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pharmapsychotic/clip-interrogator/blob/main/clip_interrogator.ipynb) [![Generic badge](https://img.shields.io/badge/🤗-Open%20in%20Spaces-blue.svg)](https://huggingface.co/spaces/pharma/CLIP-Interrogator) [![Replicate](https://replicate.com/pharmapsychotic/clip-interrogator/badge)](https://replicate.com/pharmapsychotic/clip-interrogator) [![Lambda](https://img.shields.io/badge/%CE%BB-Lambda-blue)](https://cloud.lambdalabs.com/demos/ml/CLIP-Interrogator)

  <br>


  Version 1 still available in Colab for comparing different CLIP models

  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/pharmapsychotic/clip-interrogator/blob/v1/clip_interrogator.ipynb)




  The **CLIP Interrogator** is a prompt engineering tool that combines OpenAI's [CLIP](https://openai.com/blog/clip/) and Salesforce's [BLIP](https://blog.salesforceairesearch.com/blip-bootstrapping-language-image-pretraining/) to optimize text prompts to match a given image. Use the resulting prompts with text-to-image models like [Stable Diffusion](https://github.com/CompVis/stable-diffusion) on [DreamStudio](https://beta.dreamstudio.ai/) to create cool art!




  Create and activate a Python virtual environment
  ```bash
  python3 -m venv ci_env
  (for linux  ) source ci_env/bin/activate
  (for windows) .\ci_env\Scripts\activate
  ```

  Install with PIP
  ```

  pip3 install torch torchvision --extra-index-url https://download.pytorch.org/whl/cu117


  pip install clip-interrogator==0.5.5
  ```

  You can then use it in your script
  ```python
  from PIL import Image
  from clip_interrogator import Config, Interrogator
  image = Image.open(image_path).convert('RGB')
  ci = Interrogator(Config(clip_model_name="ViT-L-14/openai"))
  print(ci.interrogate(image))
  ```

  CLIP Interrogator uses OpenCLIP which supports many different pretrained CLIP models. For the best prompts for
  Stable Diffusion 1.X use `ViT-L-14/openai` for clip_model_name. For Stable Diffusion 2.0 use `ViT-H-14/laion2b_s32b_b79k`



  The `Config` object lets you configure CLIP Interrogator's processing.
  * `clip_model_name`: which of the OpenCLIP pretrained CLIP models to use
  * `cache_path`: path where to save precomputed text embeddings
  * `download_cache`: when True will download the precomputed embeddings from huggingface
  * `chunk_size`: batch size for CLIP, use smaller for lower VRAM
  * `quiet`: when True no progress bars or text output will be displayed

  On systems with low VRAM you can call `config.apply_low_vram_defaults()` to reduce the amount of VRAM needed (at the cost of some speed and quality). The default settings use about 6.3GB of VRAM and the low VRAM settings use about 2.7GB.

  See the [run_cli.py](https://github.com/pharmapsychotic/clip-interrogator/blob/main/run_cli.py) and [run_gradio.py](https://github.com/pharmapsychotic/clip-interrogator/blob/main/run_gradio.py) for more examples on using Config and Interrogator classes.




  ```python
  from clip_interrogator import Config, Interrogator, LabelTable, load_list
  from PIL import Image

  ci = Interrogator(Config(blip_model_type=None))
  image = Image.open(image_path).convert('RGB')
  table = LabelTable(load_list('terms.txt'), 'terms', ci)
  best_match = table.rank(ci.image_to_features(image), top_count=1)[0]
  print(best_match)
  ```


pkgId: 0167652982e69dab7018855d7711de3b117a526259f1a2b72da4360e97902a57
name: python-clip-util
arch: src
version: 0.1.28
epoch: 0
release: 1
summary: Clipboard utilities for use with Python.
url: https://github.com/AceofSpades5757/clip-util
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clip-util-0.1.28-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/clip-util?color=darkred)](https://pypi.org/project/clip-util/)
  [![Read the Docs](https://img.shields.io/readthedocs/clip-util)](https://clip-util.readthedocs.io/en/latest/)
  [![Tests](https://github.com/AceofSpades5757/clip-util/actions/workflows/test.yml/badge.svg)](https://github.com/AceofSpades5757/clip-util/actions/workflows/test.yml)

  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/clip-util?label=Python%20Version&logo=python&logoColor=yellow)](https://pypi.org/project/clip-util/)
  [![PyPI - License](https://img.shields.io/pypi/l/clip-util?color=green)](https://github.com/AceofSpades5757/clip-util/blob/main/LICENSE)

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



  Package for accessing the clipboard with Python.



  `pip install clip-util`



  _Windows Only_

  Allows you to set text, RTF, and HTML to the clipboard on Windows. Any other format can also be specified using the format type integer, specified by Windows.



  - Text
  - HTML
  - RTF





  Will open and close every time the values are set, or retrieved. It's better to use a context manager.

  ```python
  from clipboard import Clipboard


  clipboard = Clipboard()


  clipboard["text"] = "Hello World!"

  clipboard.set_clipboard("Hello World!")


  text = clipboard["text"]

  text = clipboard.get_clipboard("text")


  clipboard["html"] = "<h1>Hello World</h1>"
  ```




  ```python
  from clipboard import Clipboard


  with Clipboard() as clipboard:

      
      clipboard["text"] = "Hello World!"
      
      clipboard.set_clipboard("Hello World!")

      
      text = clipboard["text"]
      
      text = clipboard.get_clipboard("text")

      
      clipboard["html"] = "<h1>Hello World</h1>"
  ```



  You can use `clip-util` to access the clipboard formats directly.

  `ClipboardFormat`: Enum for clipboard formats.

  `ClipboardFormat.CF_HTML`: Represents HTML format.

  `ClipboardFormat.CF_RTF`: Represents RTF format.

  ```python
  from clipboard import Clipboard
  from clipboard import ClipboardFormat
  from clipboard import get_format_name


  with Clipboard() as clipboard:

      
      format_ids: list[int] = clipboard.available_formats()

      
      
      formats: list[ClipboardFormat] = []
      format_id: int
      for format_id in format_ids:
          if format_id in ClipboardFormat:
              format_: ClipboardFormat = ClipboardFormat(format_id)
              formats.append(format_)
          else:
              
              pass

      
      format_names: list[str] = []
      format_id: int
      for format_id in format_ids:
          name: str = get_format_name(format_id)
          format_names.append(name)

      
      
      
      
      formats: list[ClipboardFormat] = []
      format_names: list[str] = []
      format_name: str
      for format_name in [f.name for f in formats]:
          if format_name in ClipboardFormat:
              format_: ClipboardFormat = ClipboardFormat[format_name]
              name: str = format_.name
              formats.append(format_)
              format_names.append(name)
          else:
              
              pass
  ```



  You can even get the content of all available formats currently in the clipboard.

  ```python
  from clipboard import get_available_formats
  from clipboard import get_format_name
  from clipboard import get_clipboard


  available: list[int] = get_available_formats()
  print(f"{available=}")

  for format_id in available:
      name: str = get_format_name(format_id)
      content: str = get_clipboard(format_id)
      print(f"{format_id=}", f"{name=}, {content=}")
  ```

rpm_license:
  MIT License  Copyright © 2022 Kyle L. Davis  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: abf4c40bd35c460b822d1c1a07414ceabfedbb8d2bf99e321a1735e919dd6446
name: python-clipboard
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A cross platform clipboard operation library of Python. Works for Windows, Mac and Linux.
url: https://github.com/terryyin/clipboard
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipboard-0.0.4-1.src.rpm
checksum_type: sha256
description:
  A cross platform clipboard operation library of Python. Works for Windows, Mac and Linux.
  Well, as I was trying to implement this, I realize that everything is included in pyperclip already: https://pypi.python.org/pypi/pyperclip/
  But anyway, `clipboard` is a better name. You are free to choose:-) I might add more features to it.
  Usage:
     import clipboard
     clipboard.copy("abc")  # now the clipboard content will be string "abc"
     text = clipboard.paste()  # text will have the content of clipboard


pkgId: 947f98bc45aaf10173dab279ee8ae71104379070ae2c005fb124f02599bc8712
name: python-clipkeeper
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A Windows-based clipboard history manager
url: https://github.com/wittiness/clipkeeper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipkeeper-0.1.5-1.src.rpm
checksum_type: sha256
description:
  - **Real-Time Monitoring:** Automatically capture clipboard content (text and images) as you work.
  - **Persistent Storage:** Save clipboard history securely in a local SQLite database for easy retrieval.
  - **Searchable History:** Locate previous entries with a keyword-based search system.

  - **Responsive Design:** Access your clipboard history via a clean, user-friendly web interface.
  - **Real-Time Updates:** See new clipboard items appear instantly, without refreshing the page.
  - **Integrated Management:** Easily copy or delete clipboard items directly from the interface.

  - **History Display:** View your clipboard history in the terminal.
  - **Search Utility:** Search for specific items using patterns or keywords.
  - **Management Tools:** Clear clipboard history or copy specific entries with ease.

  - **Local-Only Storage:** Data is stored on your machine, ensuring complete privacy.


pkgId: 8a905ebac3fe2eca4f5c7c2a6c03c93904a4c09a3463be486fd65490cf4e7ba1
name: python-clipman
arch: src
version: 3.3.1
epoch: 0
release: 1
summary: Python3 module for working with clipboard. Created because pyperclip is discontinued.
url: https://github.com/NikitaBeloglazov/clipman
rpm_license: MPL 2.0 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipman-3.3.1-1.src.rpm
checksum_type: sha256
description:
  <!-- # Copyright (c) 2023 Nikita Beloglazov -->
  <!-- License: Mozilla Public License 2.0 -->

  [![License: Mozilla Public License 2.0](https://img.shields.io/badge/License:_MPL_2.0-blueviolet?logo=googledocs&logoColor=white&style=for-the-badge)](https://mozilla.org/en-US/MPL/2.0)
  [![linting: pylint](https://img.shields.io/badge/Linting:_pylint-success?logo=azurefunctions&logoColor=white&style=for-the-badge)](https://pylint.pycqa.org/en/latest/)
  [![maintainer: NikitaBeloglazov](https://img.shields.io/badge/Maintainer:_.%E2%80%A2%C2%B0%E2%97%8F%E2%9D%A4%EF%B8%8F%20NikitaBeloglazov%20Software%20Foundation%20%E2%9D%A4%EF%B8%8F%E2%97%8F%C2%B0%E2%80%A2.-informational?logoColor=white&style=for-the-badge&logo=github)](https://github.com/NikitaBeloglazov)

  __Python3 module for working with clipboard. Created because pyperclip is discontinued.__

  __Mostly made for [✨ YTCON](https://github.com/NikitaBeloglazov/ytcon)__


  * Easy use and simple architecture by KISS
  * User-friendly
  * No additional modules
  * Supports many engines
  * We use PyLint and we comment all our code
  * Active development
  * Just good dev 😇


  ```python3
  import clipman
  clipman.init() # Just initialize module


  clipman.set("test")


  print(clipman.get())
  Out: 'test'
  ```
  __Also you can use `clipman.copy("ytcon")` and `clipman.paste()` as from pyperclip!:)__

  * If you want to catch all errors from the module, use `clipman.exceptions.ClipmanBaseException`:
  ```python3
  import clipman
  try:
    clipman.init()
    print(clipman.paste())
  except clipman.exceptions.ClipmanBaseException as e:
    print(e)
  ```
  * And if you want to catch specific module error, use its name.





  ```shell
  pip3 install clipman
  ```


  __•‎ 🟩 Linux - FULL SUPPORT, native in KDE__.
  In other cases, some additional dependencies are required

  __•‎ 🟩 Android - FULL SUPPORT in Termux__, some additional deps needed too

  __•‎ 🟩 BSD Systems - Works__ on __FreeBSD / GhostBSD__ and OpenBSD / FuguIta, deps same as Linux

  __•‎ 🟩 Windows - Works__ natively

  __•‎ 🟩 MacOS - Works__ on macOS HighSierra 10.13


  __Unstead zypper you need to use system package manager: pkg, apt, dnf, pacman, etc__

  `- = - = -`


  - Native support. No additional dependencies are needed.

  The only minimum requirement is dbus, and an `dbus-next` module, which will install with clipman as dependency

  KDE Plasma 5 and [KDE Plasma 6](https://kde.org/announcements/megarelease/6/) is supported

  `- = - = -`

  - Install `xsel` or `xclip` package

  Example: _sudo zypper install xsel_ __OR__ _sudo zypper install xclip_

  `- = - = -`

  - Install `wl-clipboard` package

  Example: _sudo zypper install wl-clipboard_

  `- = - = -`

  Clipboard works only in Termux.
  And you need install additional deps in it.
  * Install ```Termux:API``` from F-Droid
  * Run ```pkg install termux-api```
  * Check it - run ```termux-clipboard-get```


  This code is under [Mozilla Public License Version 2.0](/../../blob/main/LICENSE).


  📕 __[!!] If you encouter an error, please read the error text very closely.
  The module is specially written so that errors give you a complete answer even if you a lamer__

  * 🥼 __Pull requests are welcome!__
  * 🌈 Feel free to write Issues! The developer can answer you in the following languages: Ukrainian, English, Russian.
  * Don't forget to attach version (`pip3 show clipman`) and error text with `clipman.init(debug=True)` :)
  * ⏩ To speed up the process write to [maintainer](https://github.com/NikitaBeloglazov)


pkgId: 2498628192bf6bc9627c78bac8a90d5cc12a745fd73c15264065b24b70111d00
name: python-clipped
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Common shortcuts and utils.
url: https://github.com/mmourafiq/clipped
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipped-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![License: Apache 2](https://img.shields.io/badge/License-apache2-green.svg)](LICENSE)
  [![clipped](https://github.com/mmourafiq/clipped/actions/workflows/clipped.yml/badge.svg)](https://github.com/mmourafiq/clipped/actions/workflows/clipped.yml)

  <a href="https://github.com/mmourafiq/clipped"><img src="https://raw.githubusercontent.com/mmourafiq/clipped/master/artifacts/logo/clipped.svg" width="125" height="125" align="right" /></a>



  Common shortcuts and utils for Python and CLI projects.



  ```bash
  pip install clipped
  ```


pkgId: 78da38ba28ab179fe3d9740995f11446ee64de4969a81fdcde2a1f0f8062bea1
name: python-clippersaver-karjakak
arch: src
version: 0.4.3
epoch: 0
release: 1
summary: ClipperSaver will clip everything copied and can be structured for env-var encryption use
url: https://github.com/kakkarja/ClipperSaver
rpm_license: BSD3 License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clippersaver-karjakak-0.4.3-1.src.rpm
checksum_type: sha256
description:
  ```
  pip install clippersaver-karjakak
  ```

  **In console or terminal**
  ```
  clippers
  ```

  **Copied Cells**

  - Selection can be structured from selected first to the last selected.

  **Set as Environment Variables**

  - The selection will be set to a join string and save as Environment variable.

  **Deconstruct**

  - The list of selection saved as json file and archive with password into a created folder.

  **Read the deconstructed file**

  - For viewing

  **Set the deconstructed file to Environment Variable**

  - Setting an Environment Variable from a selected deconstructed file.

  **Delete Archive**

  - Delete a deconstruct file that has been archived.

  **Clear Environment Variable**

  - Delete created variable from ClipperSaver


  - Useful for copying long password, data for api, etc.
  - ClipperSaver will collect the copied data and automatically fill every cells with the copied data.
  - The clipboard will be cleared for every copied data.
  - Suitable for keeping data save with password.
  - Easily useful to set in Environment Variable which data is encrypted.
      - These will be useful for developer.
  - Add deleting selected cells with keyboard shortcut **"Control+d"**.
  - Using decorators from https://pypi.org/project/excptr-karjakak for exception tracing to log file.
      - In case any unusual behaviour, check the log file in "**EXCPTR**" folder in user-path directory.
          - Please create issue with the copy of the log file.

  - https://pypi.org/project/Clien-karjakak/
  - https://pypi.org/project/DecAn-karjakak/


pkgId: fb7f4ae166e4f1136cd8140626142be0b92515bed85a5a47987256e9e9c947b9
name: python-clipping
arch: src
version: 6.0.0
epoch: 0
release: 1
summary: Geometries clipping.
url: https://github.com/lycantropos/clipping/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipping-6.0.0-1.src.rpm
checksum_type: sha256
description:
  [![](https://github.com/lycantropos/clipping/workflows/CI/badge.svg)](https://github.com/lycantropos/clipping/actions/workflows/ci.yml "Github Actions")
  [![](https://readthedocs.org/projects/clip/badge/?version=latest)](https://clip.readthedocs.io/en/latest "Documentation")
  [![](https://codecov.io/gh/lycantropos/clipping/branch/master/graph/badge.svg)](https://codecov.io/gh/lycantropos/clipping "Codecov")
  [![](https://img.shields.io/github/license/lycantropos/clipping.svg)](https://github.com/lycantropos/clipping/blob/master/LICENSE "License")
  [![](https://badge.fury.io/py/clipping.svg)](https://badge.fury.io/py/clipping "PyPI")
  In what follows `python` is an alias for `python3.6` or `pypy3.6`
  or any later version (`python3.7`, `pypy3.7` and so on).

rpm_license:
  MIT License  Copyright (c) 2020 Azat Ibrakov  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: f7a0afbfc333bbcf51e7bb1e20bc337f1105607c000024ceaf0df229447045fc
name: python-clipscope
arch: src
version: 0.1.8
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/clipscope/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipscope-0.1.8-1.src.rpm
checksum_type: sha256
description:
  [Github Repo](https://github.com/Lewington-pitsos/clipscope)



  ```python
  import PIL
  from clipscope import ConfiguredViT, TopKSAE

  device='cpu'
  filename_in_hf_repo = "22_resid/1200013184.pt"
  sae = TopKSAE.from_pretrained(checkpoint=filename_in_hf_repo, device=device)

  locations = [(22, 'resid')]
  transformer = ConfiguredViT(locations, device=device)

  input = PIL.Image.new("RGB", (224, 224), (0, 0, 0)) # black image for testing

  activations = transformer.all_activations(input)[locations[0]] # (1, 257, 1024)
  assert activations.shape == (1, 257, 1024)

  activations = activations[:, 0] # just the cls token



  print('activations shape', activations.shape)

  output = sae.forward_verbose(activations)

  print('output keys', output.keys())

  print('latent shape', output['latent'].shape) # (1, 65536)
  print('reconstruction shape', output['reconstruction'].shape) # (1, 1024)
  ```


pkgId: b85805d1f3875e2ab55178b40f33c91972533b10e8aa6fb180ff9e5eef883a34
name: python-clipstick
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: A pydantic cli creation tool based on Pydantic models.
url: https://github.com/sander76/clipstick
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipstick-0.6.1-1.src.rpm
checksum_type: sha256
description:
  ![coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/sander76/a25f1e6bfcb3b085ffe05f520b56e43c/raw/covbadge.json)
  [![PyPI - Version](https://img.shields.io/pypi/v/clipstick.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/clipstick/)
  [![code style - black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://github.com/ambv/black)

  <!-- begin index -->

  Create your cli using Pydantic models.

  Define a pydantic model as you would normally do, pass it to clipstick and you get a cli including subcommands, nice docstrings and validations based on typing and pydantic validators.



  `pip install clipstick`





  Create a pydantic model as you would normally do.

  ```python
  from pydantic import BaseModel

  from clipstick import parse


  class MyName(BaseModel):
      """What is my name.

      In case you forgot I will repeat it x times.
      """

      name: str
      """Your name."""

      age: int = 24
      """Your age"""

      repeat_count: int = 10
      """How many times to repeat your name."""

      def main(self):
          for _ in range(self.repeat_count):
              print(f"Hello: {self.name}, you are {self.age} years old")


  if __name__ == "__main__":
      model = parse(MyName)
      model.main()

  ```

  That's it. The clipstick parser will convert this into a command line interface based on the properties assigned to the model, the provided typing and docstrings.

  So `python examples/name.py -h` gives you nicely formatted (and colored) output:

  ![help_output](https://raw.githubusercontent.com/sander76/clipstick/main/docs/_images/name-help.svg)

  And use your cli `python examples/name.py superman --repeat-count 4`:

  ![usage output](https://raw.githubusercontent.com/sander76/clipstick/main/docs/_images/name-output.svg)

  The provided annotations define the type to which your arguments need to be converted.
  If you provide a value which cannot be converted you will be presented with a nice error:

  `python examples/name.py superman --age too-old`

  ![wrong age](https://raw.githubusercontent.com/sander76/clipstick/main/docs/_images/name-wrong-age.svg)

  > The inclusion of the `def main(self)` method is not a requirement. `clipstick` generates a pydantic model based on provided cli arguments and gives it back to you for your further usage. Using `def main()` is one of the options to further process it.



  There are many other tools out there that do kind of the same,
  but they all don't do quite exactly what I want.

  The goal of clipstip is to use pydantic to model your cli by leveraging:

  - The automatic casting of input variables.
  - The powerful validation capabilities.
  - Docstrings as cli documentation.
  - No other mental model required than Typing and Pydantic.

  Clipstick is inspired by [tyro](https://brentyi.github.io/tyro/), which is excellent and more versatile than this tool. But in my opionion its primary focus is not building a cli tool along the lines of Argparse or Click but more on composing complex objects from the command line. Making tyro behave like a "traditional" cli requires additional `Annotation` flags, which I don't want.

  Some other similar tools don't support pydantic v2, so I decided to create my own. Next to that I wanted to try and build my own parser instead of using `Argparse` because... why not.

  <!-- end index -->

  For more information visit the [documentation](https://sander76.github.io/clipstick/index.html)



  Pull requests are very much appreciated!
  Some guidance:

  - Fork this repo and use this to create your branch based on the `dev` branch.
  - This project makes use of **Poetry**. `Poetry install` to install everything
      need for development.
  - This project makes use of **Nox**. `nox -s test` and `nox -s quality` are your friends here.
  - Please update the `CHANGELOG.md` file with your changes under `## [Unreleased]` section.
  - When finished, point your pull-request towards the `dev` dev branch.

  Thanks!


pkgId: 240516ecaf4e03d9c08e364d6794ff5c362f1706f633acf0a1c6e71ca8c87619
name: python-clipt
arch: src
version: 1.0.15
epoch: 0
release: 1
summary: clipt makes graphs using matplotlib from the command line
url: https://bitbucket.org/stephenwasilewski/clipt
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clipt-1.0.15-1.src.rpm
checksum_type: sha256
description:
  Clipt (command line interface plotting tool) uses clasp and matplotlib
  to aid in plotting data files using matplotlib directly from the command
  line using a extensive set of options.  See the clasp documentation for
  imformation about using config files.
  https://clipt.readthedocs.io/
  Clipt was built using clasp: https://clasp.readthedocs.io/
  which in turn depends on click: https://palletsprojects.com/p/click/


pkgId: 6d29cbb162a468a20b7274ee1322da2f9ebd4c0d9982a4a33536ecc48dff2bea
name: python-clique
arch: src
version: 2.0.0
epoch: 0
release: 1
summary: Manage collections with common numerical component
url: https://gitlab.com/4degrees/clique
rpm_license: Apache License (2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clique-2.0.0-1.src.rpm
checksum_type: sha256
description:
  Clique


  Manage collections with common numerical component.

  .. code-block:: python

      >>> import os
      >>> import clique
      >>> collections, remainder = clique.assemble(os.listdir('.'))
      >>> for collection in collections:
      ...     print(collection)
      file.%04d.jpg [1-5, 8, 10-15]
      file.%04d.dpx [1-15]


  *************
  Documentation
  *************

  Full documentation can be found at http://clique.readthedocs.org

  *************
  Issue tracker
  *************

  Found a bug? Have an idea on how to make the tool better?

  Post it at https://gitlab.com/4degrees/clique/issues

  *********************
  Copyright and license
  *********************

  Copyright (c) 2013 Martin Pengelly-Phillips

  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
  this work except in compliance with the License. You may obtain a copy of the
  License in the LICENSE.txt file, or 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: c687a0ed4b7c4d7108181096e16917795d23a90618b490b7b6603489368d97a1
name: python-clique-ml
arch: src
version: 0.0.2
epoch: 0
release: 1
url: https://pypi.org/project/clique-ml/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clique-ml-0.0.2-1.src.rpm
checksum_type: sha256
summary:
  A selective ensemble for predictive models that tests new additions to prevent downgrades in performance.

description:
  While working on the Kaggle competition, [Optiver - Trading at the Close](https://github.com/whitgroves/optiver-trading-at-the-close), I developed some code that I want to repackage here.

  This code was written against CUDA 12.2 and not tested on other versions. Compatability was a hassle, so run `cuda-venv.sh` to setup the virtual environment instead of using `conda` or `pip`.


pkgId: 7752228e0403deb2ef9d4be6b5ea1de00679730740ccbab02fc139579ab66c0e
name: python-clir
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: A clear and fast way to store and recover your commands
url: https://github.com/elkinaguas/clir
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clir-0.8.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/clir)](https://github.com/elkinaguas/clir/releases) ![PyPI - Downloads](https://img.shields.io/pypi/dm/clir) ![Total Download](https://static.pepy.tech/badge/clir)

  Clir provides a clear and fast way to store and recover your commands.


  Install `clir` using pip3 and pipx.

  ```bash
  pip3 install clir
  ```

  ```bash
  pipx install clir
  ```


  First of all, initialize clir. This will create the necessary cofig files.
  ```bash
  clir init
  ```

  See all the obption available with
  ```bash
  clir --help
  ```
  ![clir --help](https://raw.githubusercontent.com/elkinaguas/clir/main/docs/img/clir_help.png)

  List your saved commands:
  ```bash
  clir ls
  ```
  ![clir ls](https://raw.githubusercontent.com/elkinaguas/clir/main/docs/img/clir_ls.png)


pkgId: 2f3cf8a86353a34c2a6aa8b8100d8d474308b38ed63710362fe1bbfc10877f53
name: python-clixdev
arch: src
version: 0.3.9.1
epoch: 0
release: 1
summary: https://clix.dev command line tool.
url: https://clix.dev
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clixdev-0.3.9.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License Copyright (c) 2022 Eris Verne 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: 6e69ad4f41404ec147d0c841c9b8e2969f426421438d2b4e5caf218fb619b788
name: python-clize
arch: src
version: 5.0.2
epoch: 0
release: 1
summary: Turn functions into command-line interfaces
url: https://github.com/epsy/clize
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clize-5.0.2-1.src.rpm
checksum_type: sha256
description:
  *****
  Clize
  *****

  .. image:: https://readthedocs.org/projects/clize/badge/?version=stable
     :target: http://clize.readthedocs.io/en/stable/?badge=stable
     :alt: Documentation Status
  .. image:: https://badges.gitter.im/Join%20Chat.svg
     :alt: Join the chat at https://gitter.im/epsy/clize
     :target: https://gitter.im/epsy/clize?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
  .. image:: https://github.com/epsy/clize/actions/workflows/ci.yml/badge.svg?branch=master
     :target: https://github.com/epsy/clize/actions/workflows/ci.yml
  .. image:: https://coveralls.io/repos/epsy/clize/badge.svg?branch=master
     :target: https://coveralls.io/r/epsy/clize?branch=master

  Clize is an argument parser for `Python <https://www.python.org/>`_.  You can
  use Clize as an alternative to ``argparse`` if you want an even easier way to
  create command-line interfaces.

  **With Clize, you can:**

  * Create command-line interfaces by creating functions and passing them to
    `clize.run`.
  * Enjoy a CLI automatically created from your functions' parameters.
  * Bring your users familiar ``--help`` messages generated from your docstrings.
  * Reuse functionality across multiple commands using decorators.
  * Extend Clize with new parameter behavior.

  **Here's an example:**

  .. code-block:: python

      from clize import run

      def hello_world(name=None, *, no_capitalize=False):
          """Greets the world or the given name.

          :param name: If specified, only greet this person.
          :param no_capitalize: Don't capitalize the given name.
          """
          if name:
              if not no_capitalize:
                  name = name.title()
              return 'Hello {0}!'.format(name)
          return 'Hello world!'

      if __name__ == '__main__':
          run(hello_world)

  The python code above can now be used on the command-line as follows:

  .. code-block:: console

      $ pip install clize
      $ python3 hello.py --help
          Usage: hello.py [OPTIONS] name

          Greets the world or the given name.

          Positional arguments:
            name   If specified, only greet this person.

          Options:
            --no-capitalize   Don't capitalize the given name.

          Other actions:
            -h, --help   Show the help
      $ python3 hello.py
      Hello world!
      $ python3 hello.py john
      Hello John!
      $ python3 hello.py dave --no-capitalize
      Hello dave!

  You can find the documentation and tutorials at http://clize.readthedocs.io/


pkgId: fb73aba27d7c8fc1a2edcef8bcc51e784cb697b7bd7b42128d0c4c604540414f
name: python-clj
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Utilities for lazy iterables
url: https://github.com/bfontaine/clj
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clj-0.3.1-1.src.rpm
checksum_type: sha256
description:
  `clj` is a collection of functions to work with lazy iterators in Python.

  It’s a module for those times when you did too much Clojure and came back to Python wondering where are all these
  `distinct`, `drop-while`, `cycle`, `first`, etc.

  The library is oriented toward laziness and performance. Functions are implemented with as little overhead as possible.



      pip install clj

  Since 0.2.0, only Python 3.7+ is supported.



  The library is considered stable and is used in production.



  ```clojure
  ;; Clojure
  (->> coll (map inc) (filter even?) distinct count println)
  ; which expands to:
  (println (count (distinct (filter even? (map inc coll)))))
  ```

  ```python

  from clj import count, distinct, inc, is_even

  print(count(distinct(filter(is_even, map(inc, coll)))))
  ```

  Note that `count()` works on both sequences in generators; in the latter case it doesn’t load everything in memory like
  e.g. `len(list(g))` would do.



  * Lazy by default. All functions should work on arbitrary iterators and return generators.
  * This is Python. We keep Python’s semantics instead of trying to reproduce Clojure in Python (e.g. `0` and `[]` are
    logically true in Clojure but false in Python; `None` is not equivalent to an empty collection).
  * Don’t Reinvent the Wheel. We don’t reimplement built-in functions unless they miss something, like `range` that can’t
    be called without argument to yield an infinite sequence.



  The general naming scheme is: use underscores instead of hyphens; start the function with `is_` if its Clojure
  counterparts ends with a `?`.



  We aim to implement all Clojure functions that operate on sequences
  (see [the list here][seqs]). They all work on iterables and return generators by default (Python’s closest equivalent of
  lazy seqs). We don’t support transducers.

  [seqs]: http://clojure.org/reference/sequences

  | Clojure           | `clj`           | Comment                                                                                                             |
  |-------------------|:----------------|---------------------------------------------------------------------------------------------------------------------|
  | `distinct`        | `distinct`      |                                                                                                                     |
  | `filter`          | `filter`        | Alias to Python’s built-in `filter`.                                                                                |
  | `remove`          | `remove`        |                                                                                                                     |
  | `keep`            | `keep`          |                                                                                                                     |
  | `keep-indexed`    | `keep_indexed`  |                                                                                                                     |
  | `cons`            | `cons`          |                                                                                                                     |
  | `concat`          | `concat`        | Equivalent to `itertools.chain`.                                                                                    |
  | `lazy-cat`        | -               | Use Python’s `itertools.chain`.                                                                                     |
  | `mapcat`          | `mapcat`        |                                                                                                                     |
  | `cycle`           | `cycle`         |                                                                                                                     |
  | `interleave`      | `interleave`    |                                                                                                                     |
  | `interpose`       | `interpose`     |                                                                                                                     |
  | `rest`            | `rest`          |                                                                                                                     |
  | `next`            | -               | Use `rest`.                                                                                                         |
  | `fnext`           | -               | Use `second`.                                                                                                       |
  | `nnext`           | -               | Use `rest(rest(…))`                                                                                                 |
  | `drop`            | `drop`          |                                                                                                                     |
  | `drop-while`      | `drop_while`    | Equivalent to `itertools.dropwhile`.                                                                                |
  | `nthnext`         | -               | Use `drop`.                                                                                                         |
  | `take`            | `take`          |                                                                                                                     |
  | `take-nth`        | `take_nth`      |                                                                                                                     |
  | `take-while`      | `take_while`    | Equivalent to `itertools.takewhile`.                                                                                |
  | `butlast`         | `butlast`       |                                                                                                                     |
  | `drop-last`       | `drop_last`     |                                                                                                                     |
  | `flatten`         | `flatten`       |                                                                                                                     |
  | `reverse`         | `reverse`       |                                                                                                                     |
  | `sort`            | -               | Use Python’s built-in `sort`.                                                                                       |
  | `sort-by`         | -               | Use `sort(…, key=your_function)`.                                                                                   |
  | `shuffle`         | `shuffle`       |                                                                                                                     |
  | `split-at`        | `split_at`      |                                                                                                                     |
  | `split-with`      | `split_with`    |                                                                                                                     |
  | `partition`       | `partition`     | `(partition n step pad coll)` becomes `partition(coll, n, step, pad)`. Only the case `step=n` is supported for now. |
  | `partition-all`   |                 |                                                                                                                     |
  | `partition-by`    | `partition_by`  |                                                                                                                     |
  | `map`             | `map`           | Alias to Python’s built-in `map`.                                                                                   |
  | `pmap`            | -               |                                                                                                                     |
  | `replace`         | `replace`       |                                                                                                                     |
  | `reductions`      | `reductions`    | `(reductions f i c)` becomes `reductions(f, c, i)`.                                                                 |
  | `map-indexed`     | `map_indexed`   |                                                                                                                     |
  | `seque`           | -               |                                                                                                                     |
  | `first`           | `first`         | `None` is not a valid parameter.                                                                                    |
  | `ffirst`          | `ffirst`        | `None` is not a valid parameter.                                                                                    |
  | `nfirst`          | `nfirst`        |                                                                                                                     |
  | `second`          | `second`        |                                                                                                                     |
  | `nth`             | `nth`           |                                                                                                                     |
  | `last`            | `last`          |                                                                                                                     |
  | `rand-nth`        | -               | Use Python’s `random.choice`.                                                                                       |
  | `zipmap`          | `zipmap`        |                                                                                                                     |
  | `into`            | -               |                                                                                                                     |
  | `reduce`          | -               | Use Python’s `functools.reduce`.                                                                                    |
  | `set`             | -               | Use Python’s `set`.                                                                                                 |
  | `vec`             | -               | Use Python’s `list`.                                                                                                |
  | `into-array`      | -               | Use Python’s `list`.                                                                                                |
  | `to-array-2d`     | -               |                                                                                                                     |
  | `frequencies`     | -               | Use Python’s `collections.Counter`.                                                                                 |
  | `group-by`        | `group_by`      |                                                                                                                     |
  | `apply`           | -               | Use the `f(*args)` construct.                                                                                       |
  | `not-empty`       | -               |                                                                                                                     |
  | `some`            | `some`          |                                                                                                                     |
  | `seq?`            | `is_seq`        |                                                                                                                     |
  | `every?`          | `every`         |                                                                                                                     |
  | `not-every?`      | `not_every`     |                                                                                                                     |
  | `not-any?`        | `not_any`       |                                                                                                                     |
  | `empty?`          | -               |                                                                                                                     |
  | `empty`           | `empty`         |                                                                                                                     |
  | `doseq`           | -               | Use `for … in`.                                                                                                     |
  | `dorun`           | `dorun`         |                                                                                                                     |
  | `doall`           | -               | Use Python’s `list`.                                                                                                |
  | `realized?`       | -               |                                                                                                                     |
  | `seq`             | -               | Use Python’s `list`.                                                                                                |
  | `vals`            | -               | Use Python’s `dict.values`.                                                                                         |
  | `keys`            | -               | Use Python’s `dict.keys`.                                                                                           |
  | `rseq`            | -               |                                                                                                                     |
  | `subseq`          |                 |                                                                                                                     |
  | `rsubseq`         |                 |                                                                                                                     |
  | `repeatedly`      | `repeatedly`    |                                                                                                                     |
  | `iterate`         | `iterate`       |                                                                                                                     |
  | `repeat`          | `repeat`        | `(repeat n x)` becomes `repeat(x, n)`. Equivalent to `itertools.repeat`.                                            |
  | `range`           | `range`         | Prefer Python’s `range` for everything but infinite generators.                                                     |
  | `line-seq`        | -               | Loop over an `io.BufferedReader`.                                                                                   |
  | `resultset-seq`   | -               |                                                                                                                     |
  | `re-seq`          | -               | Use Python’s `re.finditer`.                                                                                         |
  | `tree-seq`        | `tree_seq`      |                                                                                                                     |
  | `file-seq`        | -               | Use Python’s `os.walk`.                                                                                             |
  | `xml-seq`         | -               |                                                                                                                     |
  | `iterator-seq`    | -               |                                                                                                                     |
  | `enumeration-seq` | -               |                                                                                                                     |
  | `hash-map`        | -               | Use Python’s `dict`.                                                                                                |
  | `array-map`       | -               | Use Python’s `dict`.                                                                                                |
  | `sorted-map`      | -               | Use `collections.OrderedDict`.                                                                                      |
  | `sorted-map-by`   |                 |                                                                                                                     |
  | `hash-set`        | -               | Use Python’s `set`.                                                                                                 |
  | `set`             | -               | Use Python’s `set`.                                                                                                 |
  | `sorted-set`      |                 |                                                                                                                     |
  | `sorted-set-by`   |                 |                                                                                                                     |
  | `dedupe`          | `dedupe`        |                                                                                                                     |

  We also implemented `count`, which uses Python’s `len` when possible and fallbacks on a `for` loop for other cases.



  We also provide miscellaneous functions as well as functions that work on functions.

  | Clojure           | `clj`           | Comment                          |
  |-------------------|:----------------|----------------------------------|
  | `identity`        | `identity`      |                                  |
  | `partial`         | -               | Use Python’s `functools.partial` |
  | `comp`            | `comp`          |                                  |
  | `complement`      | `complement`    |                                  |
  | `constantly`      | `constantly`    |                                  |
  | `juxt`            | `juxt`          |                                  |
  | `distinct?`       | `is_distinct`   |                                  |

  | Clojure           | `clj`           | Comment                          |
  |-------------------|:----------------|----------------------------------|
  | `inc`             | `inc`           |                                  |
  | `dec`             | `dec`           |                                  |


pkgId: 8176b46bd35365f6b8bde2aec7259072aecedc2dc66df44416011fc026b71cae
name: python-clj
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Utilities for lazy iterables
url: https://github.com/bfontaine/clj
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clj-0.4.0-1.src.rpm
checksum_type: sha256
description:
  `clj` is a collection of functions to work with lazy iterators in Python.

  It’s a module for those times when you did too much Clojure and came back to Python wondering where are all these
  `distinct`, `drop-while`, `cycle`, `first`, etc.

  The library is oriented toward laziness and performance. Functions are implemented with as little overhead as possible.



      pip install clj

  Python requirement:
  * 0.4.x: Python 3.9+
  * 0.3.x: Python 3.7+
  * 0.2.x: Python 3.7+
  * 0.1.x: Python 2.7, 3.3+



  The library is considered stable and is used in production.



  ```clojure
  ;; Clojure
  (->> coll (map inc) (filter even?) distinct count println)
  ; which expands to:
  (println (count (distinct (filter even? (map inc coll)))))
  ```

  ```python

  from clj import count, distinct, inc, is_even

  print(count(distinct(filter(is_even, map(inc, coll)))))
  ```

  Note that `count()` works on both sequences in generators; in the latter case it doesn’t load everything in memory like
  e.g. `len(list(g))` would do.



  * Lazy by default. All functions should work on arbitrary iterators and return generators.
  * This is Python. We keep Python’s semantics instead of trying to reproduce Clojure in Python (e.g. `0` and `[]` are
    logically true in Clojure but false in Python; `None` is not equivalent to an empty collection).
  * Don’t Reinvent the Wheel. We don’t reimplement built-in functions unless they miss something, like `range` that can’t
    be called without argument to yield an infinite sequence.



  The general naming scheme is: use underscores instead of hyphens; start the function with `is_` if its Clojure
  counterparts ends with a `?`.



  We aim to implement all Clojure functions that operate on sequences
  (see [the list here][seqs]). They all work on iterables and return generators by default (Python’s closest equivalent of
  lazy seqs). We don’t support transducers.

  [seqs]: http://clojure.org/reference/sequences

  | Clojure           | `clj`           | Comment                                                                                                             |
  |-------------------|:----------------|---------------------------------------------------------------------------------------------------------------------|
  | `distinct`        | `distinct`      |                                                                                                                     |
  | `filter`          | `filter`        | Alias to Python’s built-in `filter`.                                                                                |
  | `remove`          | `remove`        |                                                                                                                     |
  | `keep`            | `keep`          |                                                                                                                     |
  | `keep-indexed`    | `keep_indexed`  |                                                                                                                     |
  | `cons`            | `cons`          |                                                                                                                     |
  | `concat`          | `concat`        | Equivalent to `itertools.chain`.                                                                                    |
  | `lazy-cat`        | -               | Use Python’s `itertools.chain`.                                                                                     |
  | `mapcat`          | `mapcat`        |                                                                                                                     |
  | `cycle`           | `cycle`         |                                                                                                                     |
  | `interleave`      | `interleave`    |                                                                                                                     |
  | `interpose`       | `interpose`     |                                                                                                                     |
  | `rest`            | `rest`          |                                                                                                                     |
  | `next`            | -               | Use `rest`.                                                                                                         |
  | `fnext`           | -               | Use `second`.                                                                                                       |
  | `nnext`           | -               | Use `rest(rest(…))`                                                                                                 |
  | `drop`            | `drop`          |                                                                                                                     |
  | `drop-while`      | `drop_while`    | Equivalent to `itertools.dropwhile`.                                                                                |
  | `nthnext`         | -               | Use `drop`.                                                                                                         |
  | `take`            | `take`          |                                                                                                                     |
  | `take-nth`        | `take_nth`      |                                                                                                                     |
  | `take-while`      | `take_while`    | Equivalent to `itertools.takewhile`.                                                                                |
  | `butlast`         | `butlast`       |                                                                                                                     |
  | `drop-last`       | `drop_last`     |                                                                                                                     |
  | `flatten`         | `flatten`       |                                                                                                                     |
  | `reverse`         | `reverse`       |                                                                                                                     |
  | `sort`            | -               | Use Python’s built-in `sort`.                                                                                       |
  | `sort-by`         | -               | Use `sort(…, key=your_function)`.                                                                                   |
  | `shuffle`         | `shuffle`       |                                                                                                                     |
  | `split-at`        | `split_at`      |                                                                                                                     |
  | `split-with`      | `split_with`    |                                                                                                                     |
  | `partition`       | `partition`     | `(partition n step pad coll)` becomes `partition(coll, n, step, pad)`. Only the case `step=n` is supported for now. |
  | `partition-all`   |                 |                                                                                                                     |
  | `partition-by`    | `partition_by`  |                                                                                                                     |
  | `map`             | `map`           | Alias to Python’s built-in `map`.                                                                                   |
  | `pmap`            | -               |                                                                                                                     |
  | `replace`         | `replace`       |                                                                                                                     |
  | `reductions`      | `reductions`    | `(reductions f i c)` becomes `reductions(f, c, i)`.                                                                 |
  | `map-indexed`     | `map_indexed`   |                                                                                                                     |
  | `seque`           | -               |                                                                                                                     |
  | `first`           | `first`         | `None` is not a valid parameter.                                                                                    |
  | `ffirst`          | `ffirst`        | `None` is not a valid parameter.                                                                                    |
  | `nfirst`          | `nfirst`        |                                                                                                                     |
  | `second`          | `second`        |                                                                                                                     |
  | `nth`             | `nth`           |                                                                                                                     |
  | `last`            | `last`          |                                                                                                                     |
  | `rand-nth`        | -               | Use Python’s `random.choice`.                                                                                       |
  | `zipmap`          | `zipmap`        |                                                                                                                     |
  | `into`            | -               |                                                                                                                     |
  | `reduce`          | -               | Use Python’s `functools.reduce`.                                                                                    |
  | `set`             | -               | Use Python’s `set`.                                                                                                 |
  | `vec`             | -               | Use Python’s `list`.                                                                                                |
  | `into-array`      | -               | Use Python’s `list`.                                                                                                |
  | `to-array-2d`     | -               |                                                                                                                     |
  | `frequencies`     | -               | Use Python’s `collections.Counter`.                                                                                 |
  | `group-by`        | `group_by`      |                                                                                                                     |
  | `apply`           | -               | Use the `f(*args)` construct.                                                                                       |
  | `not-empty`       | -               |                                                                                                                     |
  | `some`            | `some`          |                                                                                                                     |
  | `seq?`            | `is_seq`        |                                                                                                                     |
  | `every?`          | `every`         |                                                                                                                     |
  | `not-every?`      | `not_every`     |                                                                                                                     |
  | `not-any?`        | `not_any`       |                                                                                                                     |
  | `empty?`          | -               |                                                                                                                     |
  | `empty`           | `empty`         |                                                                                                                     |
  | `doseq`           | -               | Use `for … in`.                                                                                                     |
  | `dorun`           | `dorun`         |                                                                                                                     |
  | `doall`           | -               | Use Python’s `list`.                                                                                                |
  | `realized?`       | -               |                                                                                                                     |
  | `seq`             | -               | Use Python’s `list`.                                                                                                |
  | `vals`            | -               | Use Python’s `dict.values`.                                                                                         |
  | `keys`            | -               | Use Python’s `dict.keys`.                                                                                           |
  | `rseq`            | -               |                                                                                                                     |
  | `subseq`          |                 |                                                                                                                     |
  | `rsubseq`         |                 |                                                                                                                     |
  | `repeatedly`      | `repeatedly`    |                                                                                                                     |
  | `iterate`         | `iterate`       |                                                                                                                     |
  | `repeat`          | `repeat`        | `(repeat n x)` becomes `repeat(x, n)`. Equivalent to `itertools.repeat`.                                            |
  | `range`           | `range`         | Prefer Python’s `range` for everything but infinite generators.                                                     |
  | `line-seq`        | -               | Loop over an `io.BufferedReader`.                                                                                   |
  | `resultset-seq`   | -               |                                                                                                                     |
  | `re-seq`          | -               | Use Python’s `re.finditer`.                                                                                         |
  | `tree-seq`        | `tree_seq`      |                                                                                                                     |
  | `file-seq`        | -               | Use Python’s `os.walk`.                                                                                             |
  | `xml-seq`         | -               |                                                                                                                     |
  | `iterator-seq`    | -               |                                                                                                                     |
  | `enumeration-seq` | -               |                                                                                                                     |
  | `hash-map`        | -               | Use Python’s `dict`.                                                                                                |
  | `array-map`       | -               | Use Python’s `dict`.                                                                                                |
  | `sorted-map`      | -               | Use `collections.OrderedDict`.                                                                                      |
  | `sorted-map-by`   |                 |                                                                                                                     |
  | `hash-set`        | -               | Use Python’s `set`.                                                                                                 |
  | `set`             | -               | Use Python’s `set`.                                                                                                 |
  | `sorted-set`      |                 |                                                                                                                     |
  | `sorted-set-by`   |                 |                                                                                                                     |
  | `dedupe`          | `dedupe`        |                                                                                                                     |

  We also implemented `count`, which uses Python’s `len` when possible and fallbacks on a `for` loop for other cases.



  We also provide miscellaneous functions as well as functions that work on functions.

  | Clojure           | `clj`           | Comment                          |
  |-------------------|:----------------|----------------------------------|
  | `identity`        | `identity`      |                                  |
  | `partial`         | -               | Use Python’s `functools.partial` |
  | `comp`            | `comp`          |                                  |
  | `complement`      | `complement`    |                                  |
  | `constantly`      | `constantly`    |                                  |
  | `juxt`            | `juxt`          |                                  |
  | `distinct?`       | `is_distinct`   |                                  |

  | Clojure           | `clj`           | Comment                          |
  |-------------------|:----------------|----------------------------------|
  | `inc`             | `inc`           |                                  |
  | `dec`             | `dec`           |                                  |


pkgId: 810e36bc589ffc1560745ced9c956c47f6fa1dfca54d6735b26358d9c45fbf33
name: python-clkhash
arch: src
version: 0.18.3
epoch: 0
release: 1
summary: Encoding utility to create Cryptographic Linkage Keys
url: https://github.com/data61/clkhash
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clkhash-0.18.3-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img alt="Clkhash Logo" src="./docs/_static/logo.svg" width="250" />
  </p>

  <div align="center">

  [![codecov](https://codecov.io/gh/data61/clkhash/branch/main/graph/badge.svg)](https://codecov.io/gh/data61/clkhash)
  [![Documentation Status](https://readthedocs.org/projects/clkhash/badge/?version=latest)](http://clkhash.readthedocs.io/en/latest/?badge=latest)
  [![Unit Testing](https://github.com/data61/clkhash/actions/workflows/unittests.yml/badge.svg)](https://github.com/data61/clkhash/actions/workflows/unittests.yml)
  [![Typechecking](https://github.com/data61/clkhash/actions/workflows/typechecking.yml/badge.svg)](https://github.com/data61/clkhash/actions/workflows/typechecking.yml)
  [![Downloads](https://pepy.tech/badge/clkhash)](https://pepy.tech/project/clkhash)

  </div>

  **clkhash** is a Python implementation of cryptographic linkage key hashing as described by _Rainer Schnell, Tobias Bachteler, and Jörg Reiher_ in
  [A Novel Error-Tolerant Anonymous Linking Code](https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3549247).



  Install clkhash with all dependencies using pip:

      pip install clkhash




  [https://clkhash.readthedocs.io](https://clkhash.readthedocs.io/en/latest/)




  To hash a CSV file of entities using the default schema:

  ```python
  from clkhash import clk, randomnames
  fake_pii_schema = randomnames.NameList.SCHEMA
  clks = clk.generate_clk_from_csv(open('fake-pii-out.csv','r'), 'secret', fake_pii_schema)
  ```



  See [Anonlink Client](https://github.com/data61/anonlink-client) for a command line interface to clkhash.



  Clkhash, and the wider Anonlink project is designed, developed and supported by
  [CSIRO's Data61](https://www.data61.csiro.au). If you use any part of this library in your research, please
  cite it using the following BibTex entry::

      @misc{Anonlink,
        author = {CSIRO's Data61},
        title = {Anonlink Private Record Linkage System},
        year = {2017},
        publisher = {GitHub},
        journal = {GitHub Repository},
        howpublished = {\url{https://github.com/data61/clkhash}},
      }


pkgId: cebba6b8605007a133081e0a2f562d379ed27f60e39d7f8c5d6da81f3035f917
name: python-clldmpg
arch: src
version: 4.3.1
epoch: 0
release: 1
summary: Python library supporting development of CLLD apps maintained by MPI EVA
url: https://github.com/clld/clldmpg
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clldmpg-4.3.1-1.src.rpm
checksum_type: sha256
description:
  Python library providing common functionality for CLLD apps maintained in affiliation
  with the MPG.
  Provides an MPG specific pyramid app scaffold and a pyramid package to be included by
  a clld app.
  Note: The `templates` directory provided by this package must be specified in an app's `appconf.ini`
  in the correct position to make template lookup work, e.g.
  ```ini
  [mako]
  directories_list = concepticon:templates clldmpg:templates clld:web/templates
  ```


pkgId: 96adc2d1527d1c48ddf879386112726553b675628e0db9e4c909849f62898472
name: python-clldutils
arch: src
version: 3.22.2
epoch: 0
release: 1
summary: Utilities for programmatic data curation
url: https://github.com/clld/clldutils
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clldutils-3.22.2-1.src.rpm
checksum_type: sha256
description:
  Utilities for programmatic data curation

  [![Build Status](https://github.com/clld/clldutils/workflows/tests/badge.svg)](https://github.com/clld/clldutils/actions?query=workflow%3Atests)
  [![Documentation Status](https://readthedocs.org/projects/clldutils/badge/?version=latest)](https://clldutils.readthedocs.io/en/latest/?badge=latest)
  [![PyPI](https://img.shields.io/pypi/v/clldutils.svg)](https://pypi.python.org/pypi/clldutils)




  Install from PyPI running
  ```shell
  pip install clldutils
  ```



  Originally, `clldutils` started out as a library for functionality often used in [clld](https://github.com/clld/clld)
  web apps. Over time, it turned into a toolbox for various data curation tasks, with a focus on cross-linguistic
  data (as reflected by modules such as `clldutils.iso_639_3` or `clldutils.sfm`).

  Design goals are
  - wide applicability of the included functionality
  - small number of dependencies, thus wide installability




  Documentation of the package is at https://clldutils.readthedocs.io/en/latest/index.html


pkgId: 9d505a02cb07ff1a104d5df3ce363c5110281418ebbbe273705fa2ffbeb0ed96
name: python-clmm
arch: src
version: 1.14.4
epoch: 0
release: 1
summary: A comprehensive package for galaxy cluster weak lensing
url: https://pypi.org/project/clmm/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clmm-1.14.4-1.src.rpm
checksum_type: sha256
description:
  [![Build and Check](https://github.com/LSSTDESC/CLMM/workflows/Build%20and%20Check/badge.svg)](https://github.com/LSSTDESC/CLMM/actions?query=workflow%3A%22Build+and+Check%22)
  [![Coverage Status](https://coveralls.io/repos/github/LSSTDESC/CLMM/badge.svg?branch=main)](https://coveralls.io/github/LSSTDESC/CLMM?branch=main)

  The LSST-DESC Cluster Lensing Mass Modeling (CLMM) code is a DESC tool consisting of a Python library for performing galaxy cluster mass reconstruction from weak lensing observables. CLMM is associated with Key Tasks _DC1 SW+RQ_ and _DC2 SW_ of the LSST-DESC [Science Roadmap](https://lsstdesc.org/sites/default/files/DESC_SRM_V1_4.pdf) pertaining to absolute and relative mass calibration.
  <!---CLMM is descended from [clmassmod](https://github.com/deapplegate/clmassmod) but distinguished by its modular structure and scope, which encompasses both simulated data sets with a known truth and observed data from which we aim to discover the truth.--->
  The documentation of the code can be found [here](http://lsstdesc.org/CLMM/) and the overview of the code can be found [here](OVERVIEW.md).
  The journal paper that describes the development and validation of `CLMM` v1.0 can be found [here](https://ui.adsabs.harvard.edu/abs/2021MNRAS.508.6092A/abstract). If you make use of the ideas or software here, please cite that paper and provide a
  link to this repository: https://github.com/LSSTDESC/CLMM. Please follow the guidelines listed below to install, use and contribute to CLMM.


  1. [Installing CLMM](#installing)
  2. [Using CLMM](#using)
  3. [Contributing to CLMM](#contributing)
  5. [Contact](#contact)
  6. [Acknowledgements](#acknowledgements)





  CLMM requires Python version 3.8 or later.  CLMM has the following dependencies:

  - [NumPy](https://www.numpy.org/) (v1.17 or later)
  - [SciPy](https://scipy.org/) (v1.6 or later)
  - [Astropy](https://www.astropy.org/) (v4.0 or later for units and cosmology dependence)
  (Please avoid Astropy v5.0 since there is bug breaking CCL backend. It has been fixed in Astropy v5.0.1.)
  - [Matplotlib](https://matplotlib.org/) (for plotting and going through tutorials)

  ```
    pip install numpy scipy astropy matplotlib
  ```

  For the theoretical predictions of the signal, CLMM relies on existing libraries and **at least one of the following must be installed as well**:

  - [cluster-toolkit](https://cluster-toolkit.readthedocs.io/en/latest/)
  - [CCL](https://ccl.readthedocs.io/en/latest/) (versions between 2.7.1.dev10+gf81b59a4 and 3)
  - [NumCosmo](https://numcosmo.github.io/) (v0.19 or later)


  (See the [INSTALL documentation](INSTALL.md) for more detailed installation instructions.)

  For developers, you will also need to install:

  - [pytest](https://docs.pytest.org/en/latest/) (3.x or later for testing)
  - [Sphinx](https://www.sphinx-doc.org/en/master/usage/installation.html) (for documentation)

  These are also pip installable:
  ```
    pip install pytest sphinx sphinx_rtd_theme
  ```
  Note, the last item, `sphinx_rtd_theme` is to make the docs.



  To install CLMM you currently need to build it from source:

  ```
    git clone https://github.com/LSSTDESC/CLMM.git
    cd CLMM
    python setup.py install --user   # Add --user flag to install it locally
  ```
  See the [INSTALL documentation](INSTALL.md) for more detailed installation instructions.

  To run the tests you can do:

    `pytest`



  This code has been released by DESC, although it is still under active
  development. You are welcome to re-use the code, which is open source and available under
  terms consistent with our
  [LICENSE](https://github.com/LSSTDESC/CLMM/blob/main/LICENSE) ([BSD
  3-Clause](https://opensource.org/licenses/BSD-3-Clause)). In this case,
  don't forget to reference the [paper](https://ui.adsabs.harvard.edu/abs/2021MNRAS.508.6092A/abstract)
  and the [repository](https://github.com/LSSTDESC/CLMM).
  If you use CLMM for a project, please see the guidelines below, depending on your case.

  **DESC Projects**: External contributors and DESC members wishing to
  use CLMM for DESC projects should consult with the DESC Clusters analysis
  working group (CL WG) conveners, ideally before the work has started, but
  definitely before any publication or posting of the work to the arXiv.

  **Non-DESC Projects by DESC members**: If you are in the DESC
  community, but planning to use CLMM in a non-DESC project, it would be
  good practice to contact the CL WG co-conveners and/or the CLMM Topical
  Team leads as well (see Contact section).  A desired outcome would be for your
  non-DESC project concept and progress to be presented to the working group,
  so working group members can help co-identify tools and/or ongoing development
  that might mutually benefit your non-DESC project and ongoing DESC projects.

  **External Projects by Non-DESC members**: If you are not from the DESC
  community, you are also welcome to contact CLMM Topical Team leads to introduce
  your project and share feedback.


  For free use of the `NumCosmo` library, the `NumCosmo` developers
  require that the `NumCosmo` publication be cited: NumCosmo: Numerical
  Cosmology, S. Dias Pinto Vitenti and M. Penna-Lima, Astrophysics
  Source Code Library, record ascl:1408.013.  See citation info
  [here](https://ui.adsabs.harvard.edu/abs/2014ascl.soft08013D/exportcitation).
  The `NumCosmo` repository can be found [here](https://github.com/NumCosmo/NumCosmo).

  For free use of the `CCL` library, the `CCL` developers require that
  the `CCL` publication be cited.  See details
  [here](https://github.com/LSSTDESC/CCL).

  The `Cluster Toolkit` documentation can be found
  [here](https://cluster-toolkit.readthedocs.io/en/latest/#).

  The data for the notebook test_coordinate.ipynb is available at https://www.dropbox.com/scl/fo/dwsccslr5iwb7lnkf8jvx/AJkjgFeemUEHpHaZaHHqpAg?rlkey=efbtsr15mdrs3y6xsm7l48o0r&st=xb58ap0g&dl=0



  You are welcome to contribute to the code. To do so, please follow the guidelines described [here](CONTRIBUTING.md).
  If you are not part of the DESC CLMM topical team, it is good to also contact us (see below).



  If you have comments, questions, or feedback, please [write us an
  issue](https://github.com/LSSTDESC/CLMM/issues).

  The current leads of the LSST DESC CLMM Topical Team are Michel Aguena
  (m-aguena, aguena@apc.in2p3.fr) and Marina Ricci (mricci,
  marina.ricci@apc.in2p3.fr)




  The DESC acknowledges ongoing support from the Institut National de
  Physique Nucl\'eaire et de Physique des Particules in France; the
  Science \& Technology Facilities Council in the United Kingdom; and
  the Department of Energy, the National Science Foundation, and the
  LSST Corporation in the United States.  DESC uses resources of the
  IN2P3 Computing Center (CC-IN2P3--Lyon/Villeurbanne - France) funded
  by the Centre National de la Recherche Scientifique; the National
  Energy Research Scientific Computing Center, a DOE Office of Science
  User Facility supported by the Office of Science of the U.S.
  Department of Energy under Contract No. DE-AC02-05CH11231; STFC DiRAC
  HPC Facilities, funded by UK BIS National E-infrastructure capital
  grants; and the UK particle physics grid, supported by the GridPP
  Collaboration.  This work was performed in part under DOE Contract
  DE-AC02-76SF00515.

  The authors express gratitude to the LSSTC for the 2018 and 2019
  Enabling Science grants, hosted by CMU and RUB respectively, that
  supported the development of `CLMM` and its developer community.  CA
  acknowledges support from the LSA Collegiate Fellowship at the
  University of Michigan, the Leinweber Foundation, and DoE Award
  DE-FOA-0001781.  AIM acknowledges support from the Max Planck Society
  and the Alexander von Humboldt Foundation in the framework of the Max
  Planck-Humboldt Research Award endowed by the Federal Ministry of
  Education and Research. During the completion of this work, AIM was
  advised by David W. Hogg and supported by National Science Foundation
  grant AST-1517237.  CS acknowledges support from the Agencia Nacional
  de Investigaci\'on y Desarrollo (ANID) through FONDECYT grant no.
  11191125.  AvdL, RH, LB, and HF acknowledge support by the US
  Department of Energy under award DE-SC0018053.  SF acknowledges
  support from DOE grant DE-SC0010010.  HM is supported by the Jet
  Propulsion Laboratory, California Institute of Technology, under a
  contract with the National Aeronautics and Space Administration.


pkgId: 36b0aad080df836e6be74fece66b4619468c41226862fa8ce73935370d0238e7
name: python-clmm
arch: src
version: 1.14.40
epoch: 0
release: 1
summary: A comprehensive package for galaxy cluster weak lensing
url: https://pypi.org/project/clmm/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clmm-1.14.40-1.src.rpm
checksum_type: sha256
description:
  [![Build and Check](https://github.com/LSSTDESC/CLMM/workflows/Build%20and%20Check/badge.svg)](https://github.com/LSSTDESC/CLMM/actions?query=workflow%3A%22Build+and+Check%22)
  [![Coverage Status](https://coveralls.io/repos/github/LSSTDESC/CLMM/badge.svg?branch=main)](https://coveralls.io/github/LSSTDESC/CLMM?branch=main)
  [![Documentation](https://readthedocs.org/projects/clmm/badge/?version=latest)](http://lsstdesc.org/CLMM/)
  [![DOI](https://img.shields.io/badge/DOI-10.3847%2F1538--4365%2Fab1658-B31B1B.svg)](https://doi.org/10.1093/mnras/stab2764)

  The LSST-DESC Cluster Lensing Mass Modeling (CLMM) code is a DESC tool consisting of a Python library for performing galaxy cluster mass reconstruction from weak lensing observables. CLMM is associated with Key Tasks _DC1 SW+RQ_ and _DC2 SW_ of the LSST-DESC [Science Roadmap](https://lsstdesc.org/sites/default/files/DESC_SRM_V1_4.pdf) pertaining to absolute and relative mass calibration.
  <!---CLMM is descended from [clmassmod](https://github.com/deapplegate/clmassmod) but distinguished by its modular structure and scope, which encompasses both simulated data sets with a known truth and observed data from which we aim to discover the truth.--->
  The documentation of the code can be found [here](http://lsstdesc.org/CLMM/) and the overview of the code can be found [here](OVERVIEW.md).
  The journal paper that describes the development and validation of `CLMM` v1.0 can be found [here](https://ui.adsabs.harvard.edu/abs/2021MNRAS.508.6092A/abstract). If you make use of the ideas or software here, please cite that paper and provide a
  link to this repository: https://github.com/LSSTDESC/CLMM. Please follow the guidelines listed below to install, use and contribute to CLMM.


  1. [Installing CLMM](#installing)
  2. [Using CLMM](#using)
  3. [Contributing to CLMM](#contributing)
  5. [Contact](#contact)
  6. [Acknowledgements](#acknowledgements)



  CLMM can be installed with `pip` or `conda`.
  There commands will install most of the dependencies for CLMM,
  with the exception of the backend to be used on theoretical predictions,
  check [this](#backends) section for details.

  For a `pip` installation, run:

  ```bash
      pip install clmm
  ```

  For a `conda` installation, run:

  ```bash
      conda install -c conda-forge clmm
  ```

  We highly recommend you make a new conda environment for the installation of CLMM,
  see [INSTALL documentation](INSTALL.md) for instructions on how to do it.



  CLMM requires Python version greater than 3.8 and at maximum 3.12.



  CLMM has the following dependencies:

  - [NumPy](https://www.numpy.org/) (v1.17 or later)
  - [SciPy](https://scipy.org/) (v1.6 or later)
  - [Astropy](https://www.astropy.org/) (v4.0 or later for units and cosmology dependence)
  (Please avoid Astropy v5.0 since there is bug breaking CCL backend. It has been fixed in Astropy v5.0.1.)
  - [Matplotlib](https://matplotlib.org/) (for plotting and going through tutorials)
  - [Healpy](https://pypi.org/project/healpy/)
  - [qp](https://pypi.org/project/qp-prob/) (Higher python versions than 3.12 may have conflicts with this package for different system distributions)

  ```
    pip install numpy scipy astropy matplotlib healpy qp-prob
  ```



  For the theoretical predictions of the signal, CLMM relies on existing libraries and **at least one of the following must be installed as well**:

  - [cluster-toolkit](https://cluster-toolkit.readthedocs.io/en/latest/)
  - [CCL](https://ccl.readthedocs.io/en/latest/) (versions between 2.7.1.dev10+gf81b59a4 and 3)
  - [NumCosmo](https://numcosmo.github.io/) (v0.19 or later)


  (See the [INSTALL documentation](INSTALL.md) for more detailed installation instructions.)



  For developers, you will also need to install:

  - [pytest](https://docs.pytest.org/en/latest/) (3.x or later for testing)
  - [Sphinx](https://www.sphinx-doc.org/en/master/usage/installation.html) (for documentation)

  These are also pip installable:
  ```
    pip install pytest sphinx sphinx_rtd_theme
  ```
  Note, the last item, `sphinx_rtd_theme` is to make the docs.



  To install CLMM manually, you need to build it from source:

  ```
    git clone https://github.com/LSSTDESC/CLMM.git
    cd CLMM
    python setup.py install --user   # Add --user flag to install it locally
  ```
  See the [INSTALL documentation](INSTALL.md) for more detailed installation instructions.

  To run the tests you can do:

    `pytest`



  This code has been released by DESC, although it is still under active
  development. You are welcome to re-use the code, which is open source and available under
  terms consistent with our
  [LICENSE](https://github.com/LSSTDESC/CLMM/blob/main/LICENSE) ([BSD
  3-Clause](https://opensource.org/licenses/BSD-3-Clause)). In this case,
  don't forget to reference the [paper](https://ui.adsabs.harvard.edu/abs/2021MNRAS.508.6092A/abstract)
  and the [repository](https://github.com/LSSTDESC/CLMM).
  If you use CLMM for a project, please see the guidelines below, depending on your case.

  **DESC Projects**: External contributors and DESC members wishing to
  use CLMM for DESC projects should consult with the DESC Clusters analysis
  working group (CL WG) conveners, ideally before the work has started, but
  definitely before any publication or posting of the work to the arXiv.

  **Non-DESC Projects by DESC members**: If you are in the DESC
  community, but planning to use CLMM in a non-DESC project, it would be
  good practice to contact the CL WG co-conveners and/or the CLMM Topical
  Team leads as well (see Contact section).  A desired outcome would be for your
  non-DESC project concept and progress to be presented to the working group,
  so working group members can help co-identify tools and/or ongoing development
  that might mutually benefit your non-DESC project and ongoing DESC projects.

  **External Projects by Non-DESC members**: If you are not from the DESC
  community, you are also welcome to contact CLMM Topical Team leads to introduce
  your project and share feedback.


  For free use of the `NumCosmo` library, the `NumCosmo` developers
  require that the `NumCosmo` publication be cited: NumCosmo: Numerical
  Cosmology, S. Dias Pinto Vitenti and M. Penna-Lima, Astrophysics
  Source Code Library, record ascl:1408.013.  See citation info
  [here](https://ui.adsabs.harvard.edu/abs/2014ascl.soft08013D/exportcitation).
  The `NumCosmo` repository can be found [here](https://github.com/NumCosmo/NumCosmo).

  For free use of the `CCL` library, the `CCL` developers require that
  the `CCL` publication be cited.  See details
  [here](https://github.com/LSSTDESC/CCL).

  The `Cluster Toolkit` documentation can be found
  [here](https://cluster-toolkit.readthedocs.io/en/latest/#).

  The data for the notebook test_coordinate.ipynb is available at https://www.dropbox.com/scl/fo/dwsccslr5iwb7lnkf8jvx/AJkjgFeemUEHpHaZaHHqpAg?rlkey=efbtsr15mdrs3y6xsm7l48o0r&st=xb58ap0g&dl=0



  You are welcome to contribute to the code. To do so, please follow the guidelines described [here](CONTRIBUTING.md).
  If you are not part of the DESC CLMM topical team, it is good to also contact us (see below).



  If you have comments, questions, or feedback, please [write us an
  issue](https://github.com/LSSTDESC/CLMM/issues).

  The current leads of the LSST DESC CLMM Topical Team are Michel Aguena
  (m-aguena, aguena@apc.in2p3.fr) and Marina Ricci (mricci,
  marina.ricci@apc.in2p3.fr)




  The DESC acknowledges ongoing support from the Institut National de
  Physique Nucl\'eaire et de Physique des Particules in France; the
  Science \& Technology Facilities Council in the United Kingdom; and
  the Department of Energy, the National Science Foundation, and the
  LSST Corporation in the United States.  DESC uses resources of the
  IN2P3 Computing Center (CC-IN2P3--Lyon/Villeurbanne - France) funded
  by the Centre National de la Recherche Scientifique; the National
  Energy Research Scientific Computing Center, a DOE Office of Science
  User Facility supported by the Office of Science of the U.S.
  Department of Energy under Contract No. DE-AC02-05CH11231; STFC DiRAC
  HPC Facilities, funded by UK BIS National E-infrastructure capital
  grants; and the UK particle physics grid, supported by the GridPP
  Collaboration.  This work was performed in part under DOE Contract
  DE-AC02-76SF00515.

  The authors express gratitude to the LSSTC for the 2018 and 2019
  Enabling Science grants, hosted by CMU and RUB respectively, that
  supported the development of `CLMM` and its developer community.  CA
  acknowledges support from the LSA Collegiate Fellowship at the
  University of Michigan, the Leinweber Foundation, and DoE Award
  DE-FOA-0001781.  AIM acknowledges support from the Max Planck Society
  and the Alexander von Humboldt Foundation in the framework of the Max
  Planck-Humboldt Research Award endowed by the Federal Ministry of
  Education and Research. During the completion of this work, AIM was
  advised by David W. Hogg and supported by National Science Foundation
  grant AST-1517237.  CS acknowledges support from the Agencia Nacional
  de Investigaci\'on y Desarrollo (ANID) through FONDECYT grant no.
  11191125.  AvdL, RH, LB, and HF acknowledge support by the US
  Department of Energy under award DE-SC0018053.  SF acknowledges
  support from DOE grant DE-SC0010010.  HM is supported by the Jet
  Propulsion Laboratory, California Institute of Technology, under a
  contract with the National Aeronautics and Space Administration.


pkgId: cdc49e55f610751eca5fb4c8e154c95730e2004f06237d433c7cbd385da4bf14
name: python-cloci
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Co-occurrence Locus and Orthologous Cluster Identifier
url: https://github.com/xonq/cloci
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cloci-0.3.1-1.src.rpm
checksum_type: sha256
description:
  ![*CLOCI*](https://raw.githubusercontent.com/xonq/cloci/master/etc/abstract.png)

  <br />


  The most common gene cluster detection algorithms focus on canonical “core”
  biosynthetic functions many gene clusters encode, while overlooking uncommon or
  unknown cluster classes. These overlooked clusters are a potential source of
  novel natural products and comprise an untold portion of overall gene cluster
  repertoires. Unbiased, function-agnostic detection algorithms therefore provide
  an opportunity to reveal novel classes of gene clusters and more broadly define
  genome organization. *CLOCI* (Co-occurrence Locus and Orthologous Cluster
  Identifier) is an algorithm that identifies gene clusters using multiple
  proxies of selection for coordinated gene evolution. In the process, *CLOCI*
  circumscribes loci into homologous locus groups, which is an extension of
  orthogroups to the locus-level. Our approach generalizes gene cluster detection and gene cluster family circumscription, improves detection of multiple known functional classes, and unveils noncanonical gene clusters. *CLOCI* is suitable for genome-enabled specialized metabolite mining, and presents an easily tunable approach for delineating gene cluster families and homologous loci.

  <br />


  Please see the [wiki](https://github.com/xonq/cloci/wiki/Home) for installation
  and usage instructions.

  <br />


  Zachary Konkel, Laura Kubatko, Jason C Slot, CLOCI: unveiling cryptic fungal
  gene clusters with generalized detection, *Nucleic Acids Research*, 2024;, gkae625, https://doi.org/10.1093/nar/gkae625

rpm_license:
  GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.  A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.  The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.  An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU Affero General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Remote Network Interaction; Use with the GNU General Public License.  Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  CLOCI Copyright (C) 2023  Zachary Konkel, Jason Slot  This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.  You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.


pkgId: 9b3e377610c8f7a072442ddcf6232ccd6ead59fd457005c725d2a088557621e6
name: python-clodius
arch: src
version: 0.20.1
epoch: 0
release: 1
summary: Tile generation for big data
url: https://pypi.org/project/clodius/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clodius-0.20.1-1.src.rpm
checksum_type: sha256
description:
  [![Python](https://img.shields.io/pypi/v/clodius)](https://pypi.org/project/clodius)
  [![Build Status](https://travis-ci.org/higlass/clodius.svg?branch=develop)](https://travis-ci.org/higlass/clodius)
  [![Docs](https://img.shields.io/badge/docs-📖-red.svg?colorB=6680ff)](https://docs.higlass.io/data_preparation.html)

  Displaying large amounts of data often requires first turning it into
  not-so-large amounts of data. Clodius is a program and library designed
  to aggregate large datasets to make them easy to display at different
  resolutions.



  Install the clodius package:

  ```shell
  pip install clodius
  ```

  And use it aggregate a bigWig file:

  ```shell
  curl https://raw.githubusercontent.com/hms-dbmi/clodius/develop/test/sample_data/geneAnnotationsExonsUnions.short.bed \
    > /tmp/sample.short.bed
  clodius aggregate bedfile /tmp/sample.short.bed
  ```

  The output files can then be displayed using [higlass-manage](https://github.com/higlass/higlass-manage). For more information about viewing these types of files take a look at the [higlass docs](https://docs.higlass.io).

  [More examples](COMMANDS.md) are available.



  - Non-genomic Rasters
    - [TSV Files](docs/raster/tsv.rst)
  - Genomic Data
    - [Bed Files](docs/genomic/bed.rst)
    - [BedGraph Files](docs/genomic/bedgraph.rst)
    - [Bedpe-like Files](docs/genomic/bedpe.rst)
    - [BigBed Files](docs/genomic/bigbed.rst)
    - [BigWig Files](docs/genomic/bigwig.rst)
    - [Chromosome Sizes](docs/genomic/chromosome-sizes.rst)
    - [Cooler Files](docs/genomic/cooler.rst)
    - [Gene Annotation](docs/genomic/gene-annotation.rst)
    - [HiTile Files](docs/genomic/hitile.rst)
    - [Multivec Files](docs/genomic/multivec.rst)




  The recommended way to develop `clodius` is to use a [conda](https://conda.io/docs/intro.html) environment and
  install `clodius` with develop mode:

  ```shell
  pip install -e ".[dev]"
  ```




  The unit tests for clodius can be run using [pytest](https://docs.pytest.org/en/latest/):

  ```shell
  pytest
  ```

  Individual unit tests can be specified by indicating the file and function
  they are defined in:

  ```shell
  pytest test/cli_test.py:test_clodius_aggregate_bedgraph
  ```


pkgId: 0aaebeaeff4efb5a93f9b2710b5bc07ee726dfc28084b5ea4e27db15f486b70c
name: python-clonalEvolution
arch: src
version: 2.3.2
epoch: 0
release: 1
summary: Software for simulating clonal evolution.
url: https://github.com/JGil-polsl/clonalEvolution
rpm_license: GNU Affero General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clonalEvolution-2.3.2-1.src.rpm
checksum_type: sha256
description:
  Python software for simulating celluar/microbial clonal evolution with Gillespie algorithm usage



  The simpliest installation:
  ```
  python -m pip install clonalEvolution
  ```

  Usage in python:
  ```
  from microbialClonalEvolution import mainView
  mainView.run()
  ```

  Usage from console:
  ```
  python -m clonalEvolution


  python -m clonalEvolution -h

  ```




  ![general tab](https://user-images.githubusercontent.com/110567171/185866346-14d7ae9e-6e87-42ed-8afa-baa764d18db6.jpg) \

  file name - used in multiple functions: saving files, plots, parameters; specify name of file (according to windows acceptable characters), data files will have cycle number (name_number.csv/.txt) \
  file path - used in multiple functions: saving files, plots, parameters; specify absolute path to folder where simulation data should be saved \
  file description - 'TODO' add description in params/data file about simulation specyfied by user \
  \
  clone diagram - button, fire the muller plot creation. It is needed to specify path with muller plot data generated from simulaiton \
  file structure (file-name_muller_plot_'binned'_data.txt):

  ```
  clone, cells, previous clone
  (0, 5000, 0)
  ```

  mutations histograms - button, fire the VAF plot creation for all clones in specified file. File is needed to be one of generated simulation data \
  file structure (file-name_cycle.csv/.txt):

  ```
  ,Clone number,Cells number,Mean fitness,Mean mutation number,Driver mutation list,Passener mutation list,Previous clone number
  0,0,5000,1,0,[],[],0
  ```


  ![generated tab](https://user-images.githubusercontent.com/110567171/185866348-65f4044f-e12d-46e4-99f8-0de815d5e4ba.jpg) \
  select which files should be saved automaticaly after one cycle specified in parameters (skip). Not all types works for both algorithm versions 'TODO'



  ![parameters](https://user-images.githubusercontent.com/110567171/185866353-a148e844-0aeb-4352-b64e-b1f9062dae39.jpg)



  ![plot](https://user-images.githubusercontent.com/110567171/185866356-aa3da5fe-0942-45dc-b6a9-829d5f40c856.jpg)



  ![threads](https://user-images.githubusercontent.com/110567171/185866359-1eceb813-d664-4f96-abd7-66c702ff2a16.jpg)



  ![main controls](https://user-images.githubusercontent.com/110567171/185866351-c42f006e-8023-470e-8210-1adf54d5cac3.jpg)



  GNU GENERAL PUBLIC LICENSE  Version 3, 29 June 2007

   Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
   Everyone is permitted to copy and distribute verbatim copies
   of this license document, but changing it is not allowed.

   

   Cellular/Microbial Clonal Evolution simulations basing on Gillespie algorithm.
      Copyright (C) 2022 by Jarosław Gil

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.



  Jarosław Gil, Silesian Univeristy of Technology, Department of Computer Graphics, Vision and Digital Systems.


