# packages

pkgId: 3fc39c220be04f466dd97d88efc439adf30d9738c0d29ccd7eba92fd806f2767
name: python-clea
arch: src
version: 0.1.0rc4
epoch: 0
release: 1
summary: Framework for writing CLI application quickly
url: https://pypi.org/project/clea/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clea-0.1.0rc4-1.src.rpm
checksum_type: sha256
description:
  Clea is uses type annotations to generate the command/group defintions and parse the arguments at the runtime. To start with clea run

  ```
  pip3 install clea
  ```

  Define you first command using

  ```python
  from typing_extensions import Annotated

  from clea.params import Integer
  from clea.wrappers import command

  @command
  def add(
      n1: Annotated[int, Integer()],
      n2: Annotated[int, Integer()],
  ) -> None:
      """Add two numbers"""

      print(f"Total {n1 + n2}")
  ```

  Invoke the command at runtime using

  ```python
  from clea.runner import run

  if __name__ == "__main__":
      run(cli=add)
  ```

  > The example is taken from [add.py](examples/add.py) in the examples folder.

  You can check the command definition using

  ```bash
  $ python add.py --help

  Usage: add [OPTIONS] N1 N2

          Add two numbers

  Options:

      --help                        Show help and exit.
  ```

  Execute the command using

  ```bash
  $ python add.py 2 3

  Total 5
  ```

  Read more about the usage of clea in the [docs](https://angrybayblade.github.io/clea/)


pkgId: 2e11ac5d02ec1efe8935edabf05e65af85b1555d75696a708a220435480b5751
name: python-clean-business-chart
arch: src
version: 0.2.19
epoch: 0
release: 1
url: https://github.com/marcelw1323/clean_business_chart
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clean-business-chart-0.2.19-1.src.rpm
checksum_type: sha256
summary:
  Clean Business Chart is a Python package for IBCS-like charts based on matplotlib. Currently a column chart with waterfall and a barchart with waterfall are supported.


pkgId: 530ecb8ee66158b107ec00634f84b61806de0a83c1fdafbf48d9469a0de10776
name: python-clean-python
arch: src
version: 0.18.0
epoch: 0
release: 1
summary: Clean architecture in Python
url: https://pypi.org/project/clean-python/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clean-python-0.18.0-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/nens/clean-python/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/nens/clean-python/actions/workflows/test.yml)

  ``clean-python`` contains abstractions for *clean architecture* in Python

  It is independent of frameworks and has asyncio at its core.

  The terminology used is consistently derived from the "Big Blue Book" (Domain Driven Design by E. Evans, 2004). Software consists of one or more modules, each having four layers: presentation, application, domain, and infrastructure. Each layer has its own responsibilities, in short:

  - presentation: show information to the user and interpret the user's commands.
  - application: implement use cases that direct the domain objects.
  - domain: all domain concepts and rules; this layer is the heart of the software.
  - infrastructure: generic capabilities that support the higher layers

  A big inspiration for this was the ``easy`` typescript framework by S. Hoogendoorn and others
  (https://github.com/thisisagile/easy).



  The main goals of using layered architecture is isolating the domain-specific concepts from
  other functions related only to software technology. In this way:

  - The knowledge embedded in the domain is distilled and can more easily be
    understood and changed.
  - Developers are able to quickly grasp the code base because it uses
    a consistent structure and naming system.
  - Depenencies are reduced resulting in a higher maintainability.
  - Unittests can be made more easily (increasing reliability).


  Layers are loosly coupled with dependencies in only one direction: presentation > application > infrastructure > domain. In other words: the number of dependencies of the software's core business are as limited as possible.

  A module may only depend on another module though its infrastructure layer. See ``InternalGateway``.

  This library was initially developed as a web backend using FastAPI. Its core dependency is ``pydantic``,
  for strict type parsing and validation. Optional dependencies may be added as needed.





  The domain layer is where the model lives. The domain model is a set of concepts; the domain layer
  is the manifestation of that model. Concepts in the domain model must have a 1:1 representation in the
  code and vice versa.

  THe layer does not depend on all other layers. Interaction with the infrastructure layer may be done
  using dependency injection from the application layer. It is allowable to have runtime dependencies on the
  infrastructure layer to set for instance default ``Gateway`` implementations.

  There are 5 kinds of objects in this layer:

  - *Entity*: Types that have an identity (all attributes of an instance may change- but the instance is still the same)
    Entities have an ``id`` and default fields associated with state changes ()``created_at``, ``updated_at``).
  - *ValueObject*: Types that have no identity (these are just complex values like a datetime).
  - *DomainService*: Important domain operations that aren't natural to model as objects. A service is stateless.
  - *Repository*: A repository is responsible for persistence (``add`` / ``get`` / ``filter``). This needs
    a *Gateway* to interface with e.g. a database; an instance of a *Gateway* is typically injected into a
    Repository from the application layer.
  - *DomainEvent*: A domain event may be emitted to signal a state change.

  Associations between objects are hard. Especially many-to-many relations. We approach this by grouping objects
  into *aggregates*. An aggregate is a set of objects that change together / have the same lifecycle (e.g. delete together). One entity is the aggregate root; we call this the ``RootEntity``. A ``ChildEntity`` occurs only very
  rarely; mostly a nested object derive its identity from a ``RootEntity``.

  All change and access goes through the repository of a ``RootEntity``. The ``RootEntity`` can be a complicated
  nested object; how to map this to an SQL database is the issue of the infrastructure layer.



  An infrastructure layer primarily contains ``Gateway`` objects that interface with a single external resource.
  The ``Gateway`` implements persistence methods to support the domain and application layers. Much of the implementation will be in frameworks or other dependencies.

  The methods of a ``Gateway`` may directly return a domain object, or return a dictionary with built-in types (``Json``).

  Other gateway examples are: email sending and logstash logging.



  The application layer defines the use cases of the application. Example use cases are `create_user` or `list_user_roles`. These methods have nothing to do with a REST API or command-line interface; this is
  the business of the presentation layer.

  In addition to directing the domain objects, an application layer method could trigger other behavior
  like logging or triggering other applications. At first, it may as well be just a single function call.

  This layer is kept thin. It directs domain objects, and possibly interacts with other systems
  (for instance by sending a message through the infrastructure layer). The application layer should
  not contain fundamental domain rules.



  The presentation layer shows information to the user and interprets the user's commands.
  Its main job is to get the application-layer use cases to be usable for an actual user.

  The currently only option in ``clean-python`` is a REST API using FastAPI.



  The primary objective of compartimentalizing code into modules is to prevent cognitive overload.
  The modules divide the domain layer, everything else follows. There should be low coupling
  between modules and high cohesion whithin a module. Modules are first and foremost a conceptual
  structure.

  In Python, a module should be implemented with a single .py file or a folder of .py files (respectively
  called modules and packages).

  Modules have a public API (presentation layer) and encapsulate their database. Only in this way
  the internal consistency can be guaranteed by the module's domain layer.

  Our current approach is to have 1 *aggregate* (whose root is implemented as a ``RootEntity``) per module.



  ``clean-python`` can be installed with:

      $ pip install clean-python

  Optional dependencies can be added with:

      $ pip install clean-python[sql,fastapi]


pkgId: 670684482cfef747e8105d4cd0da9117724122f21e917cad04330553e47153b6
name: python-clean-text
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Functions to preprocess and normalize text.
url: https://pypi.org/project/clean-text/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clean-text-0.6.0-1.src.rpm
checksum_type: sha256
description:
  User-generated content on the Web and in social media is often dirty. Preprocess your scraped data with `clean-text` to create a normalized text representation. For instance, turn this corrupted input:

  ```txt
  A bunch of \\u2018new\\u2019 references, including [Moana](https://en.wikipedia.org/wiki/Moana_%282016_film%29).


  »Yóù àré     rïght &lt;3!«
  ```

  into this clean output:

  ```txt
  A bunch of 'new' references, including [moana](<URL>).

  "you are right <3!"
  ```

  `clean-text` uses [ftfy](https://github.com/LuminosoInsight/python-ftfy), [unidecode](https://github.com/takluyver/Unidecode) and numerous hand-crafted rules, i.e., RegEx.



  To install the GPL-licensed package [unidecode](https://github.com/takluyver/Unidecode) alongside:

  ```bash
  pip install clean-text[gpl]
  ```

  You may want to abstain from GPL:

  ```bash
  pip install clean-text
  ```

  NB: This package is named `clean-text` and not `cleantext`.

  If [unidecode](https://github.com/takluyver/Unidecode) is not available, `clean-text` will resort to Python's [unicodedata.normalize](https://docs.python.org/3.7/library/unicodedata.html#unicodedata.normalize) for [transliteration](https://en.wikipedia.org/wiki/Transliteration).
  Transliteration to closest ASCII symbols involes manually mappings, i.e., `ê` to `e`.
  `unidecode`'s mapping is superiour but unicodedata's are sufficent.
  However, you may want to disable this feature altogether depending on your data and use case.

  To make it clear: There are **inconsistencies** between processing text with or without `unidecode`.



  ```python
  from cleantext import clean

  clean("some input",
      fix_unicode=True,               # fix various unicode errors
      to_ascii=True,                  # transliterate to closest ASCII representation
      lower=True,                     # lowercase text
      no_line_breaks=False,           # fully strip line breaks as opposed to only normalizing them
      no_urls=False,                  # replace all URLs with a special token
      no_emails=False,                # replace all email addresses with a special token
      no_phone_numbers=False,         # replace all phone numbers with a special token
      no_numbers=False,               # replace all numbers with a special token
      no_digits=False,                # replace all digits with a special token
      no_currency_symbols=False,      # replace all currency symbols with a special token
      no_punct=False,                 # remove punctuations
      replace_with_punct="",          # instead of removing punctuations you may replace them
      replace_with_url="<URL>",
      replace_with_email="<EMAIL>",
      replace_with_phone_number="<PHONE>",
      replace_with_number="<NUMBER>",
      replace_with_digit="0",
      replace_with_currency_symbol="<CUR>",
      lang="en"                       # set to 'de' for German special handling
  )
  ```

  Carefully choose the arguments that fit your task. The default parameters are listed above.

  You may also only use specific functions for cleaning. For this, take a look at the [source code](https://github.com/jfilter/clean-text/blob/main/cleantext/clean.py).



  So far, only English and German are fully supported.
  It should work for the majority of western languages.
  If you need some special handling for your language, feel free to contribute. 🙃



  There is also **scikit-learn** compatible API to use in your pipelines.
  All of the parameters above work here as well.

  ```bash
  pip install clean-text[gpl,sklearn]
  pip install clean-text[sklearn]
  ```

  ```python
  from cleantext.sklearn import CleanTransformer

  cleaner = CleanTransformer(no_punct=False, lower=False)

  cleaner.transform(['Happily clean your text!', 'Another Input'])
  ```



  [Use poetry.](https://python-poetry.org/)



  If you have a **question**, found a **bug** or want to propose a new **feature**, have a look at the [issues page](https://github.com/jfilter/clean-text/issues).

  **Pull requests** are especially welcomed when they fix bugs or improve the code quality.

  If you don't like the output of `clean-text`, consider adding a [test](https://github.com/jfilter/clean-text/tree/main/tests) with your specific input and desired output.





  -   https://github.com/pudo/normality
  -   https://github.com/davidmogar/cucco
  -   https://github.com/lyeoni/prenlp
  -   https://github.com/s/preprocessor
  -   https://github.com/artefactory/NLPretext
  -   https://github.com/cbaziotis/ekphrasis



  -   https://github.com/chartbeat-labs/textacy
  -   https://github.com/jbesomi/texthero



  -   https://github.com/vi3k6i5/flashtext
  -   https://github.com/ddelange/retrie



  -   https://github.com/scrapinghub/dateparser



  -   https://github.com/facebookresearch/cc_net



  Built upon the work by [Burton DeWilde](https://github.com/bdewilde) for [Textacy](https://github.com/chartbeat-labs/textacy).



  Apache


pkgId: a7e4cbd14d0797f69b6475b7be9547a4a61c7ee8d0e26d93deb58b845f8d7938
name: python-clean_ioc
arch: src
version: 1.9.0
epoch: 0
release: 1
summary: An IOC Container for Python 3.10+
url: https://peter-daly.github.io/clean_ioc/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clean_ioc-1.9.0-1.src.rpm
checksum_type: sha256
description:
  A simple dependency injection library for python that requires nothing of your application code (except that you use typing).


  Read the [docs](https://peter-daly.github.io/clean_ioc/) to find out more.




  There are 4 basic modes of registering a new set of classes



  ```python

  class UserRepository(abc.ABC):
      @abc.abstractmethod
      def add(self, user):
          pass

  class InMemoryUserRepository(UserRepository):

      def __init__(self):
          self.users = []

      def add(self, user):
          
          self.users.append(user)

  class SqlAlchemyUserRepository(UserRepository):

      def __init__(self):
          
          pass

      def add(self, user):
          
          pass

  container = Container()
  container.register(UserRepository, InMemoryUserRepository)


  repository = container.resolve(UserRepository) # This will return an InMemoryUserRepository

  ```



  ```python

  class ClientDependency:
      def get_int(self):
          return 10

  class Client:
      def __init__(self, dep: ClientDependency):
          self.dep = dep

      def get_number(self):
          return self.dep.get_int()


  container = Container()
  container.register(ClientDependency)
  container.register(Client)

  client = container.resolve(Client)

  client.get_number() # returns 10

  ```



  ```python

  class ClientDependency:
      def get_int(self):
          return 10

  class Client:
      def __init__(self, dep: ClientDependency):
          self.dep = dep

      def get_number(self):
          return self.dep.get_int()

  def client_factory(dep: ClientDependency):
      return Client(dep=dep)


  container = Container()
  container.register(ClientDependency)
  container.register(Client, factory=client_factory)

  client = container.resolve(Client)

  client.get_number() # returns 10

  ```




  ```python

  class ClientDependency:
      def __init__(self, num):
          self.num = num

      def get_int(self):
          return self.num

  class Client:
      def __init__(self, dep: ClientDependency):
          self.dep = dep

      def get_number(self):
          return self.dep.get_int()

  client_dependency = ClientDependency(num=10)

  container = Container()
  container.register(ClientDependency, instance=client_dependency)
  container.register(Client)

  client = container.resolve(Client)

  client.get_number() # returns 10

  ```


pkgId: bfea70ab884dbb37d52cbe9e202fdab85fe61ba71b7a3b9e559b880a095b7bc5
name: python-cleanchausie
arch: src
version: 1.17.8
epoch: 0
release: 1
summary: Data validation and transformation library for Python. Successor to CleanCat.
url: http://github.com/closeio/cleanchausie
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanchausie-1.17.8-1.src.rpm
checksum_type: sha256
description:
  CleanChausie is a data validation and transformation library for Python. It is a successor to CleanCat.

  Check out the [docs](https://closeio.github.io/cleanchausie/)!

  *Interested in working on projects like this? [`Close`](https://close.com) is looking for [great engineers](https://jobs.close.com) to join our team.*

  Key features:

  - Operate on/with type-checked objects that have good IDE/autocomplete support
  - Annotation-based declarations for simple fields
  - Composable/reusable fields and field validation logic
  - Support (but not require) passing around a context (to avoid global state)
    - Context pattern is compatible with explicit sqlalchemy-based session management. i.e. pass in a session when validating
  - Cleanly support intra-schema field dependencies (i.e. one field can depend on the validated value of another)
  - Explicit nullability/omission parameters
  - Errors returned for multiple fields at a time, with field attribution



  This is a short example of how a schema might be used to support a flask
  endpoint. More detailed examples can be found in the
  [docs](https://closeio.github.io/cleanchausie/).

  ```python
  from typing import List
  from cleanchausie import (
    clean, ListField, URLField, EmailField, field, ValidationError, Schema
  )
  from flask import app, request, jsonify

  class JobApplication(Schema):
    first_name: str
    last_name: str
    email: str = field(EmailField())
    urls: List[str] = field(ListField(URLField(default_scheme='http://')))

  @app.route('/job_application', methods=['POST'])
  def test_view():
    result = clean(JobApplication, request.json)
    if isinstance(result, ValidationError):
      return jsonify(result.serialize()), 400

    
    assert isinstance(result, JobApplication)
    name = f'{result.first_name} {result.last_name}'
  ```



  - Make sure to thoroughly review and test the code changes.
  - Prepare for a new release
    - Update the package version within `cleanchausie/__init__.py`.
    - Add a changelog entry for the new version.
    - Merge to master
  - Dispatch a new "build and release" workflow action within the github actions tab.

  The resulting workflow will build and publish the new version to PyPi.


pkgId: e90517dff4a2b339175624a9561d35d79cc48a150329bbc2184b566348f412bf
name: python-cleanco
arch: src
version: 2.3
epoch: 0
release: 1
summary: Python library to process company names
url: https://github.com/psolin/cleanco
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanco-2.3-1.src.rpm
checksum_type: sha256
description:
  ![Python package](https://github.com/psolin/cleanco/workflows/Python%20package/badge.svg)
  ![CodeQL](https://github.com/psolin/cleanco/workflows/CodeQL/badge.svg)



  This is a Python package that processes company names, providing cleaned versions of the
  names by stripping away terms indicating organization type (such as "Ltd." or "Corp").

  Using a database of organization type terms, It also provides an utility to deduce the
  type of organization, in terms of US/UK business entity types (ie. "limited liability
  company" or "non-profit").

  Finally, the system uses the term information to suggest countries the organization could
  be established in. For example, the term "Oy" in company name suggests it is established
  in Finland, whereas "Ltd" in company name could mean UK, US or a number of other
  countries.


  Just use 'pip install cleanco' if you have pip installed (as most systems do). Or download the zip distribution from this site, unzip it and then:

  * Mac: `cd` into it, and enter `sudo python setup.py install` along with your system password.
  * Windows: Same thing but without `sudo`.


  Let's look at some sample code. To get the base name of a business without legal suffix:

      >>> from cleanco import basename
      >>> business_name = "Some Big Pharma, LLC"
      >>> basename(business_name)
      >>> 'Some Big Pharma'

  Note that sometimes a name may have e.g. two different suffixes after one another. The cleanco
  term data covers many of these, but you may want to run `basename()` twice on the name, just in case.

  If you want to use your custom terms, please see  `custom_basename()` that also provides some other ways to adjust how base name is produced.

  To get the business type or country:

      >>> from cleanco import typesources, matches
      >>> classification_sources = typesources()
      >>> matches("Some Big Pharma, LLC", classification_sources)
      ['Limited Liability Company']

  To get the possible countries of jurisdiction:

      >>> from cleanco import countrysources, matches
      >>> classification_sources = countrysources()
      >>> matches("Some Big Pharma, LLC", classification_sources) ´
      ['United States of America', 'Philippines']



  See the issue tracker. If you find a bug or have enhancement suggestion or question, please file an issue and provide a PR if you can. For example, some of the company suffixes may be incorrect or there may be suffixes missing.

  To run tests, simply install the package and run `python setup.py test`. To run tests on multiple Python versions, install `tox` and run it (see the provided tox.ini).



  - Wikipedia's [Types of Business Entity article](http://en.wikipedia.org/wiki/Types_of_business_entity), where I spent hours of research.
  - Contributors: [Petri Savolainen](https://github.com/petri)


pkgId: 5ddf40dcca9cedc392b2618cb64c19f31c2f54dd368f76f6aeb4a369df7286c6
name: python-cleancourt
arch: src
version: 0.8.3
epoch: 0
release: 1
summary: a library for cleaning court docket entries
url: https://pypi.org/project/cleancourt/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleancourt-0.8.3-1.src.rpm
checksum_type: sha256
description:
  wayne enterprise|10
  wayne enterprises|2
  wayn enterprises|4
  lexcorp | 10
  lexco | 5
  lex corp. | 4
  Would output the following dictionary:
  ```json
  {
  "wayne enterprises" : "wayne enterprise",
  "wayn enterprises" : "wayne enterprise",
  "lexco" : "lexcorp",
  "lex corp." : "lexcorp"
  }
  ```

  The check_spaces is currently applied as a final step in the name standardization process. That is, check_spaces is intended to be run once all other methods have been completed.
  The function takes in a Pandas DataFrame and returns a dictionary of key-value pairs in which the key is a particular entry in the DataFrame and the associated value is a linked name found to contain the exact same characters, except for spaces.
  As with other functions in this library, the method for determining which value should be linked in the dataset is to select the value that appears the most in the dataset.
  As an example consider the following dataset, which has grouped the original dataset by the raw name, counted the number of occurrences in the dataset, and also computed the equivalent name with no spaces:


pkgId: 754d6f16d1924d3e2afddcfba7a3701846c8ae08580eb2f949ffdf0e8d7a9525
name: python-cleandoc
arch: src
version: 0.0.14
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/jkrist2696/cleandoc
rpm_license: GPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleandoc-0.0.14-1.src.rpm
checksum_type: sha256
description:
  Python package leveraging [doq](https://pypi.org/project/doq/), [black](https://pypi.org/project/black/), [pylint](https://pypi.org/project/pylint/), [mypy](https://pypi.org/project/mypy/) and [sphinx](https://pypi.org/project/Sphinx/) to automatically clean and document python code.



  ```
  pip install cleandoc
  ```





  cleandoc [-h] [-file FILE] [-dir DIR] [-write] [-ignore] [-noclean] [-nodoc] [-release]

  optional arguments:
  * -h, --help
      * show this help message and exit
  * -file FILE,-f FILE
      * Python (.py) file to clean
  * -dir DIR, -d DIR
      * Directory containing Python (.py) files to clean and/or document
  * -write, -w
      * Flag to write changes to files in-place
  * -ignore, -i
      * Flag to continue through warnings
  * -noclean, -nc
      * Flag to prevent cleaning of py files
  * -nodoc, -nd
      * Flag to prevent html doc creation
  * -release RELEASE, -r RELEASE
      * Release or version number of documentation (X.Y.Z)



  * Example below can be ran as a standalone code example
  * Example includes standard Python packages shutil, os, and webbrowser
  * In-line usage of cleandoc is shown when calling "cd."
  * Recommended use case is running "cleandoc_all"  on your python module folders

  ```



  import shutil
  import webbrowser
  import cleandoc as cd
  import os  # this import should be before cleandoc, pylint will complain

  def example_fxn_1()->str:
      """
      Set a variable that get flagged by Pylint
      """
      ISSUE_2 = 0 # pylint complains because variables in functions should be snake or lowercase
      ISSUE_2 = "setting a previous int to a string now. Mypy will complain"
      return ISSUE_2


  if __name__=="__main__":
      
      maindir = os.path.dirname(os.path.abspath(__file__))
      srcpath = os.path.join(maindir, "src")
      os.mkdir(srcpath)
      dirpath = os.path.join(srcpath, "readme_test")
      os.mkdir(dirpath)
      scriptpath = os.path.join(maindir, "src", "readme_test", os.path.basename(os.path.abspath(__file__)))
      shutil.copyfile(os.path.abspath(__file__), scriptpath)

      print("\n\n>>> Cleaning One Python File <<<\n")
      cd.clean_pyfile(scriptpath, write=True)
      print("\n\n>>> Cleaning All Python Files in Directory <<<\n")
      cd.clean_all(dirpath, ignore=True, write=False, skip=True)
      print("\n\n>>> Cleaning All and Generating HTML Docs <<<\n")
      try:
          
          
          cd.cleandoc_all(dirpath, ignore=False, write=True, release="0.0.1")
      except SyntaxWarning as error:
          print(f"syntax warning:\n\n{error}")
      print("\n\n>>> Generating HTML Documents with Sphinx <<<\n")
      webpage = cd.gen_docs(dirpath, changed=True, release="0.0.1")

      issue_1 = "This string line is way too long. Why did you need to type this all in one line? Black is going to try to shorten this and pylint will complain. Pylint also complains because constaints in main script should be all uppercase."
      ISSUE_2 = example_fxn_1()
      ISSUE_3 = ["really","long","list","so","black","reformats","it","and","turns","the","one","line","list","into","multi","line"]

      
      shutil.rmtree(srcpath)
      webbrowser.open(webpage)
  ```



  Download "docs" folder or [check preview](https://htmlpreview.github.io/?https://github.com/jkrist2696/cleandoc/blob/main/docs/index.html).



  Message me on Github.



  [GNU GPLv3](https://choosealicense.com/licenses/gpl-3.0/)



  (c) 2023, Jason Krist


pkgId: 5a07d5e644db6f35455679885aebf0a78d632ef48bd359c760722ad84deaf877
name: python-cleaning-scripts
arch: src
version: 0.2.31
epoch: 0
release: 1
url: https://github.com/arkhn/cleaning-scripts
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleaning-scripts-0.2.31-1.src.rpm
checksum_type: sha256
summary:
  Python scripts used in the FHIR integration pipeline to clean input data for different external sources.

description:
  [![Arkhn](https://img.shields.io/badge/ARKHN-CORE-000000.svg?style=for-the-badge&logo=data:image/png;base64,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)](https://arkhn.org/)
  [![GitHub license](https://img.shields.io/badge/LICENSE-APACHE2-blue.svg?style=for-the-badge)](https://github.com/arkhn/cleaning-scripts/blob/master/LICENSE)

  This is a repository of Python scripts used in the FHIR integration pipeline to clean input data for different external sources.



  There are 4 types of scripts:

  - `scripts/custom` User defined scripts to perform specific tasks like cleaning a Patient phone number for example
  - `scripts/utils` Basic scripts (like capitalize, test if empty, etc.)
  - `scripts/logic` (Beta) Scripts that operate like logic statement and take other scripts as argument

  `scripts/custom` can be extended by users, either by completing new scripts or by adding new ones when no one is addressing their needs. This is done using the API.



  We have reported several issues with the label `Good first issue` which can be a good way to start! You can also join our [Slack](https://join.slack.com/t/arkhn/shared_invite/enQtNTc1NDE5MDIxMDU3LWZmMzUwYWIwN2U0NGI1ZjM2MjcwNTAyZDZhNzcyMWFiYjJhNTIxNWQ1MWY4YmRiM2VhMDY4MDkzNGU5MTQ4ZWM) to contact us if you have trouble or questions :)

  If you're enthusiastic about our project, :star: it to show your support! :heart:


pkgId: 1d3613d556fa594d2e14fea4f2a523d06f0c4cd974b0120c0081ddb2f7403efc
name: python-cleanlab
arch: src
version: 2.7.0
epoch: 0
release: 1
url: https://cleanlab.ai
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanlab-2.7.0-1.src.rpm
checksum_type: sha256
summary:
  The standard package for data-centric AI, machine learning with label errors, and automatically finding and fixing dataset issues in Python.

description:
  While this open-source package **finds** data issues, its utility depends on you having: a good existing ML model + an interface to efficiently **fix** these issues in your dataset. Providing all these pieces, [Cleanlab Studio](https://cleanlab.ai/blog/data-centric-ai/) is a Data Curation platform to **find and fix** problems in any {image, text, tabular} dataset. Cleanlab Studio [automatically](https://cleanlab.ai/blog/data-centric-ai/) runs optimized algorithms from this package on top of **AutoML & Foundation** models fit to your data, and presents detected issues (+ AI-suggested fixes) in an intelligent [data correction interface](https://www.youtube.com/playlist?list=PLn_2rr2ltYqA1uAC0AnRbPyY-wWVf1aeg).
  **[Try it for free!](https://cleanlab.ai/signup/)** Adopting Cleanlab Studio enables users of this package to:
  - Work 100x faster (1 min to analyze your raw data with **zero** code or ML work; optionally use [Python API](https://help.cleanlab.ai/tutorials/))
  - Produce better-quality data (10x more [types of issues](https://help.cleanlab.ai/guide/concepts/cleanlab_columns/) auto detected & **corrected** via built-in AI)
  - Accomplish more (auto-label data, deploy ML instantly, audit LLM inputs/outputs, moderate content, ...)
  - Monitor incoming data and detect issues in real-time (integrate your data pipeline on an [Enterprise plan](https://cleanlab.ai/sales/))
  <p align="center">
    <img src="https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/ml-with-cleanlab-studio.png" alt="The modern AI pipeline automated with Cleanlab Studio">
  </p>

  This cleanlab package runs on Python 3.8+ and supports Linux, macOS, as well as Windows.
  - Get started [here](https://docs.cleanlab.ai/)! Install via `pip` or `conda`.
  - Developers who install the bleeding-edge from source should refer to [this master branch documentation](https://docs.cleanlab.ai/master/index.html).
  **Practicing data-centric AI can look like this:**
  1. Train initial ML model on original dataset.
  2. Utilize this model to diagnose data issues (via cleanlab methods) and improve the dataset.
  3. Train the same model on the improved dataset.
  4. Try various modeling techniques to further improve performance.
  Most folks jump from Step 1 → 4, but you may achieve big gains without *any* change to your modeling code by using cleanlab!
  Continuously boost performance by iterating Steps 2 → 4 (and try to evaluate with *cleaned* data).
  ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/flowchart.png)

  All features of cleanlab work with **any dataset** and **any model**. Yes, any model: PyTorch, Tensorflow, Keras, JAX, HuggingFace, OpenAI, XGBoost, scikit-learn, etc.
  cleanlab is useful across a wide variety of Machine Learning tasks. Specific tasks this data-centric AI package offers dedicated functionality for include:
  1. [Binary and multi-class classification](https://docs.cleanlab.ai/stable/tutorials/indepth_overview.html)
  2. [Multi-label classification](https://docs.cleanlab.ai/stable/tutorials/multilabel_classification.html) (e.g. image/document tagging)
  3. [Token classification](https://docs.cleanlab.ai/stable/tutorials/token_classification.html) (e.g. entity recognition in text)
  4. [Regression](https://docs.cleanlab.ai/stable/tutorials/regression.html) (predicting numerical column in a dataset)
  5. [Image segmentation](https://docs.cleanlab.ai/stable/tutorials/segmentation.html) (images with per-pixel annotations)
  6. [Object detection](https://docs.cleanlab.ai/stable/tutorials/object_detection.html) (images with bounding box annotations)
  7. [Classification with data labeled by multiple annotators](https://docs.cleanlab.ai/stable/tutorials/multiannotator.html)
  8. [Active learning with multiple annotators](https://github.com/cleanlab/examples/blob/master/active_learning_multiannotator/active_learning.ipynb) (suggest which data to label or re-label to improve model most)
  9. [Outlier detection](https://docs.cleanlab.ai/stable/tutorials/outliers.html) (identify atypical data that appears out of distribution)
  For other ML tasks, cleanlab can still help you improve your dataset if appropriately applied.
  See our [Example Notebooks](https://github.com/cleanlab/examples) and [Blog](https://cleanlab.ai/blog/).

  Beyond automatically catching [all sorts of issues](https://docs.cleanlab.ai/stable/cleanlab/datalab/guide/issue_type_description.html) lurking in your data, this data-centric AI package helps you deal with **noisy labels** and train more **robust ML models**.
  Here's an example:
  ```python

  cl = cleanlab.classification.CleanLearning(sklearn.YourFavoriteClassifier())

  label_issues = cl.find_label_issues(data, labels)

  cl.fit(data, labels)

  cl.predict(test_data)

  cleanlab.dataset.health_summary(labels, confident_joint=cl.confident_joint)
  ```
  cleanlab **clean**s your data's **lab**els via state-of-the-art *confident learning* algorithms, published in this [paper](https://jair.org/index.php/jair/article/view/12125) and [blog](https://l7.curtisnorthcutt.com/confident-learning). See some of the datasets cleaned with cleanlab at [labelerrors.com](https://labelerrors.com).
  cleanlab is:
  1. **backed by theory** -- with [provable guarantees](https://arxiv.org/abs/1911.00068) of exact label noise estimation, even with imperfect models.
  2. **fast** -- code is parallelized and scalable.
  4. **easy to use** -- one line of code to find mislabeled data, bad annotators, outliers, or train noise-robust models.
  6. **general** -- works with **[any dataset](https://labelerrors.com/)** (text, image, tabular, audio,...) + **any model** (PyTorch, OpenAI, XGBoost,...)
  <br/>
  ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/label-errors-examples.png)
  <p align="center">
  Examples of incorrect given labels in various image datasets <a href="https://l7.curtisnorthcutt.com/label-errors">found and corrected</a> using cleanlab.
  While these examples are from image datasets, this also works for text, audio, tabular data.
  </p>

  cleanlab is based on peer-reviewed research. Here are relevant papers to cite if you use this package:
  <details><summary><a href="https://arxiv.org/abs/1911.00068">Confident Learning (JAIR '21)</a> (<b>click to show bibtex</b>) </summary>
      @article{northcutt2021confidentlearning,
          title={Confident Learning: Estimating Uncertainty in Dataset Labels},
          author={Curtis G. Northcutt and Lu Jiang and Isaac L. Chuang},
          journal={Journal of Artificial Intelligence Research (JAIR)},
          volume={70},
          pages={1373--1411},
          year={2021}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/1705.01936">Rank Pruning (UAI '17)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{northcutt2017rankpruning,
          author={Northcutt, Curtis G. and Wu, Tailin and Chuang, Isaac L.},
          title={Learning with Confident Examples: Rank Pruning for Robust Classification with Noisy Labels},
          booktitle = {Proceedings of the Thirty-Third Conference on Uncertainty in Artificial Intelligence},
          series = {UAI'17},
          year = {2017},
          location = {Sydney, Australia},
          numpages = {10},
          url = {http://auai.org/uai2017/proceedings/papers/35.pdf},
          publisher = {AUAI Press},
      }
  </details>
  <details><summary><a href="https://people.csail.mit.edu/jonasmueller/info/LabelQuality_icml.pdf"> Label Quality Scoring (ICML '22)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{kuan2022labelquality,
          title={Model-agnostic label quality scoring to detect real-world label errors},
          author={Kuan, Johnson and Mueller, Jonas},
          booktitle={ICML DataPerf Workshop},
          year={2022}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2207.03061"> Out-of-Distribution Detection (ICML '22)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{kuan2022ood,
          title={Back to the Basics: Revisiting Out-of-Distribution Detection Baselines},
          author={Kuan, Johnson and Mueller, Jonas},
          booktitle={ICML Workshop on Principles of Distribution Shift},
          year={2022}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2210.03920"> Token Classification Label Errors (NeurIPS '22)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{wang2022tokenerrors,
          title={Detecting label errors in token classification data},
          author={Wang, Wei-Chen and Mueller, Jonas},
          booktitle={NeurIPS Workshop on Interactive Learning for Natural Language Processing (InterNLP)},
          year={2022}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2210.06812"> CROWDLAB for Data with Multiple Annotators (NeurIPS '22)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{goh2022crowdlab,
          title={CROWDLAB: Supervised learning to infer consensus labels and quality scores for data with multiple annotators},
          author={Goh, Hui Wen and Tkachenko, Ulyana and Mueller, Jonas},
          booktitle={NeurIPS Human in the Loop Learning Workshop},
          year={2022}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2301.11856"> ActiveLab: Active learning with data re-labeling (ICLR '23)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{goh2023activelab,
          title={ActiveLab: Active Learning with Re-Labeling by Multiple Annotators},
          author={Goh, Hui Wen and Mueller, Jonas},
          booktitle={ICLR Workshop on Trustworthy ML},
          year={2023}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2211.13895"> Incorrect Annotations in Multi-Label Classification (ICLR '23)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{thyagarajan2023multilabel,
          title={Identifying Incorrect Annotations in Multi-Label Classification Data},
          author={Thyagarajan, Aditya and Snorrason, Elías and Northcutt, Curtis and Mueller, Jonas},
          booktitle={ICLR Workshop on Trustworthy ML},
          year={2023}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2305.15696"> Detecting Dataset Drift and Non-IID Sampling (ICML '23)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{cummings2023drift,
          title={Detecting Dataset Drift and Non-IID Sampling via k-Nearest Neighbors},
          author={Cummings, Jesse and Snorrason, Elías and Mueller, Jonas},
          booktitle={ICML Workshop on Data-centric Machine Learning Research},
          year={2023}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2305.16583"> Detecting Errors in Numerical Data (ICML '23)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{zhou2023errors,
          title={Detecting Errors in Numerical Data via any Regression Model},
          author={Zhou, Hang and Mueller, Jonas and Kumar, Mayank and Wang, Jane-Ling and Lei, Jing},
          booktitle={ICML Workshop on Data-centric Machine Learning Research},
          year={2023}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2309.00832"> ObjectLab: Mislabeled Images in Object Detection Data (ICML '23)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{tkachenko2023objectlab,
          title={ObjectLab: Automated Diagnosis of Mislabeled Images in Object Detection Data},
          author={Tkachenko, Ulyana and Thyagarajan, Aditya and Mueller, Jonas},
          booktitle={ICML Workshop on Data-centric Machine Learning Research},
          year={2023}
      }
  </details>
  <details><summary><a href="https://arxiv.org/abs/2307.05080"> Label Errors in Segmentation Data (ICML '23)</a> (<b>click to show bibtex</b>) </summary>
      @inproceedings{lad2023segmentation,
          title={Estimating label quality and errors in semantic segmentation data via any model},
          author={Lad, Vedang and Mueller, Jonas},
          booktitle={ICML Workshop on Data-centric Machine Learning Research},
          year={2023}
      }
  </details>
  To understand/cite other cleanlab functionality not described above, check out our [additional publications](https://cleanlab.ai/research/).

  - [Example Notebooks demonstrating practical applications of this package](https://github.com/cleanlab/examples)
  - [Cleanlab Blog](https://cleanlab.ai/blog/)
  - [Blog post: Introduction to Confident Learning](https://l7.curtisnorthcutt.com/confident-learning)
  - [NeurIPS 2021 paper: Pervasive Label Errors in Test Sets Destabilize Machine Learning Benchmarks](https://arxiv.org/abs/2103.14749)
  - [Introduction to Data-centric AI (MIT IAP Course 2023)](https://dcai.csail.mit.edu/)
  - [Release notes for past versions](https://github.com/cleanlab/cleanlab/releases)

  * Learn, discuss, and shape the future of cleanlab in our 1000+ member [Slack community](https://cleanlab.ai/slack).
  * Interested in contributing? See the [contributing guide](CONTRIBUTING.md), [development guide](DEVELOPMENT.md), and [ideas on useful contributions](https://github.com/cleanlab/cleanlab/wiki#ideas-for-contributing-to-cleanlab). We welcome your help building a standard open-source platform for data-centric AI!
  * Have questions? Check out [our FAQ](https://docs.cleanlab.ai/stable/tutorials/faq.html), [Github Issues](https://github.com/cleanlab/cleanlab/issues?q=is%3Aissue), or [Slack](https://cleanlab.ai/slack).
  * Need professional help with your Data/AI project? Email us: team@cleanlab.ai <br>
  For instance, we can help you **monitor incoming data and detect issues in real-time**.

  Copyright (c) 2017 Cleanlab Inc.
  cleanlab 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.
  cleanlab 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 [GNU Affero General Public LICENSE](https://github.com/cleanlab/cleanlab/blob/master/LICENSE) for details.
  You can email us to discuss licensing: team@cleanlab.ai

  Commercial licensing is available for teams and enterprises that want to use cleanlab in production workflows, but are unable to open-source their code [as is required by the current license](https://github.com/cleanlab/cleanlab/blob/master/LICENSE). Please email us: team@cleanlab.ai

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


pkgId: def2955f30b1fabd532a95183041a7c0150f3e9f27a030a0912a7d0509958487
name: python-cleanlab-studio
arch: src
version: 2.5.8
epoch: 0
release: 1
summary: Client interface for all things Cleanlab Studio
url: https://github.com/cleanlab/cleanlab-studio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanlab-studio-2.5.8-1.src.rpm
checksum_type: sha256
description:
  Command line and Python library interface to [Cleanlab Studio](https://cleanlab.ai/studio/). Analyze datasets and produce *cleansets* (cleaned datasets) with Cleanlab Studio in a single line of code!

  - [Installation](#installation)
  - [Quickstart](#quickstart)
  - [Advanced Usage](#advanced-usage)
  - [Documentation/Tutorials](https://help.cleanlab.ai/)




  You can install the Cleanlab Studio client [from PyPI][PyPI] with:

  ```bash
  pip install cleanlab-studio
  ```

  If you already have the client installed and wish to upgrade to the latest version, run:

  ```bash
  pip install --upgrade cleanlab-studio
  ```






  ```python
  from cleanlab_studio import Studio


  studio = Studio(<your api key>)


  dataset_id: str = studio.upload_dataset(<your dataset>, <your dataset name>)





  cleanset = studio.download_cleanlab_columns(<your cleanset id>)
  corrected_dataset = studio.apply_corrections(<your cleanset id>, <your dataset>)
  ```

  The Python API offers significantly more functionality than is available in the Cleanlab Studio Web Application. Learn more via the [tutorials](https://help.cleanlab.ai/tutorials/) and [quickstart guide](https://help.cleanlab.ai/guide/quickstart/api/).



  1. If this is your first time using the Cleanlab CLI, authenticate with `cleanlab login`. You can find your API key at https://app.cleanlab.ai/account.
  2. Upload your dataset (image, text, or tabular) using `cleanlab dataset upload`.
  3. Create a project in Cleanlab Studio.
  4. Improve your dataset in Cleanlab Studio (e.g., correct some labels).
  5. Download your cleanset with `cleanlab cleanset download`.

  Learn more about the Cleanlab Studio CLI from the [quickstart guide](https://help.cleanlab.ai/guide/quickstart/cli/).



  Cleanlab Studio supports the following data formats:

  - Text/Tabular
    - CSV
    - JSON
    - XLS/XLSX
    - Pandas DataFrame _(Python library only)_
    - PySpark DataFrame _(Python library only)_
    - more to come!
  - Image
    - CSV (external media)
    - JSON (external media)
    - XLS/XLSX (external media)
    - Pandas DataFrame (external media) _(Python library only)_
    - PySpark DataFrame (external media) _(Python library only)_
    - Simple ZIP upload
    - Metadata ZIP upload
    - more to come!

  Information on how to format your dataset can be found by clicking the tutorial on https://app.cleanlab.ai/upload or in the [Datasets concept guide](https://help.cleanlab.ai/guide/concepts/datasets/). We also provide tutorials for converting certain common Python [image](https://help.cleanlab.ai/tutorials/format_image_data/) or [text](https://help.cleanlab.ai/tutorials/format_text_data/) datasets.







  All schema information will be inferred by default when uploading a dataset through the Python API. We provide some options to override the inferred schema if necessary:

  - To override the dataset modality, supply a `modality` kwarg to `studio.upload_dataset()`. Supported modalities include "text", "tabular", and "image"
  - To override the ID column, supply an `id_column` kwarg to `studio.upload_dataset()`
  - To override column types in your dataset, supply a `schema_overrides` kwarg to `studio.upload_dataset()` in the following format:

  ```
  {
    <name_of_column_to_override>: {
      "data_type": <desired_data_type>,
      "feature_type": <desired_feature_type>,
    },
    ...
  }
  ```



  To specify the column types in your dataset, create a JSON file named `schema.json`. If you would like to edit an inferred schema (rather than starting from scratch) follow these steps:

  1. Kick off a dataset upload using: `cleanlab dataset upload`
  2. Once schema generation is complete, you'll be asked whether you'd like to use our inferred schema. Enter `n` to decline
  3. You'll then be asked whether you'd like to save the inferred schema. Enter `y` to accept. Then enter the filename you'd like to save to (`schema.json` by default)
  4. Edit the schema file as you wish
  5. Kick off a dataset upload again using: `cleanlab dataset upload --schema_path [path to schema file]`

  Your schema file should be formatted as follows:

  ```json
  {
    "metadata": {
      "id_column": "tweet_id",
      "modality": "text",
      "name": "Tweets.csv"
    },
    "fields": {
      "tweet_id": {
        "data_type": "string",
        "feature_type": "identifier"
      },
      "sentiment": {
        "data_type": "string",
        "feature_type": "categorical"
      },
      "sentiment_confidence": {
        "data_type": "float",
        "feature_type": "numeric"
      },
      "retweet_count": {
        "data_type": "integer",
        "feature_type": "numeric"
      },
      "text": {
        "data_type": "string",
        "feature_type": "text"
      },
      "tweet_created": {
        "data_type": "boolean",
        "feature_type": "boolean"
      },
      "tweet_created": {
        "data_type": "string",
        "feature_type": "datetime"
      }
    },
    "version": "0.1.12"
  }
  ```

  This is the schema of a hypothetical dataset `Tweets.csv` that contains tweets, where the column `tweet_id` contains a
  unique identifier for each record. Each column in the dataset is specified under `fields` with its data type and feature
  type.



  **Data type** refers to the type of the field's values: string, integer, float, or boolean.

  Note that the integer type is partially _strict_, meaning floats that are equal to integers (e.g. `1.0`, `2.0`, etc)
  will be accepted, but floats like `0.8` and `1.5` will not. In contrast, the float type is _lenient_, meaning integers
  are accepted. Users should select the float type if the field may include float values. Note too that integers can have
  categorical and identifier feature types, whereas floats cannot.

  For booleans, the list of accepted values are: true/false, t/f, yes/no, 1/0, 1.0/0.0.

  **Feature type** refers to the secondary type of the field, relating to how it is used in a machine learning model, such
  as whether it is:

  - a categorical value
  - a numeric value
  - a datetime value
  - a boolean value
  - text
  - an identifier — a string / integer that identifies some entity
  - a filepath value (only valid for image datasets)

  Some feature types can only correspond to specific data types. The list of possible feature types for each data type is
  shown below

  | Data type | Feature type                                      |
  | :-------- | :------------------------------------------------ |
  | string    | text, categorical, datetime, identifier, filepath |
  | integer   | categorical, datetime, identifier, numeric        |
  | float     | datetime, numeric                                 |
  | boolean   | boolean                                           |

  The `datetime` type should be used for datetime strings, e.g. "2015-02-24 11:35:52 -0800", and Unix timestamps (which
  will be integers or floats). Datetime values must be parseable
  by [polars.from_epoch](https://pola-rs.github.io/polars/py-polars/html/reference/expressions/api/polars.from_epoch.html) for integer/floats or [polars.Expr.str.strptime](https://pola-rs.github.io/polars/py-polars/html/reference/expressions/api/polars.Expr.str.strptime.html) for strings.

  `version` indicates the version of the Cleanlab CLI package version used to generate the schema.



  - [Documentation](https://help.cleanlab.ai/) -- tutorials on how to use Cleanlab Studio and guides to learn key concepts
  - [Blog](https://cleanlab.ai/examples/) -- end-to-end applications, feature announcements, how-it-works explanations, benchmarks
  - [Slack Community](https://cleanlab.ai/slack/) -- ask questions, request features, discuss Data-Centric AI with others
  - Need professional help or want demo? Reach out via email: team@cleanlab.ai

  <p align="center">
    <img src="https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/studio.png" width=80% height=80%>
  </p>

  [PyPI]: https://pypi.org/project/cleanlab-studio/


pkgId: 606d3de4b0f2cdd7379238165190c248fc8bb090443584733f46362603735e52
name: python-cleanpy
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: cleanpy is a CLI tool to remove caches and temporary files that related to Python.
url: https://github.com/thombashi/cleanpy
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanpy-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ``cleanpy`` is a CLI tool to remove caches and temporary files related to Python.
  |PyPI pkg ver| |CI status| |CodeQL|


pkgId: 2668a7b5ad95d61e6f4cbf3b5e8cf78e62da0c46e6ad424f6c2007d4a7b56fef
name: python-cleansort
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A library for cleaning and sorting metadata
url: https://github.com/yourusername/cleansort
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleansort-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A simple and powerful library that helps you clean and organize metadata from websites.



  This library helps you:
  1. Take messy website metadata (like information about books, articles, or journals)
  2. Clean it up by keeping only the important parts (like titles, authors, ISBN numbers)
  3. Organize it neatly by category
  4. Store it in a database for later use





  1. Make sure you have Python installed (version 3.7 or higher):
     - Go to https://www.python.org/downloads/
     - Download and install Python for your operating system
     - Make sure to check "Add Python to PATH" during installation

  2. Install the CleanSort library using pip:
     ```bash
     pip install cleansort
     ```



  1. Clone the repository:
     ```bash
     git clone https://github.com/yourusername/cleansort
     cd cleansort
     ```

  2. Install dependencies:
     ```bash
     pip install -r requirements.txt
     ```




  ```python

  from cleansort import CleanSort


  cleaner = CleanSort()


  metadata = """
  <meta name="title" content="Harry Potter">
  <meta name="author" content="J.K. Rowling">
  <meta name="isbn" content="978-0-7475-3269-9">
  <meta name="source_site" content="books.com">
  """


  result = cleaner.process_metadata(metadata)


  print(result)


  stored_data = cleaner.get_stored_metadata()
  ```



  1. First, start the API server:
     - Open a terminal/command prompt
     - Navigate to your project directory
     - Run:
       ```bash
       python run_server.py
       ```
     - You'll see a message saying the server is running

  2. Now you can use the library from any programming language!


  ```javascript
  // Using fetch in browser or Node.js
  async function processMetadata(metadata) {
      const response = await fetch('http://localhost:5000/process', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ metadata })
      });
      return await response.json();
  }
  ```


  ```java
  // Using Java's HttpClient
  String url = "http://localhost:5000/process";
  String metadata = "<meta name=\"title\" content=\"My Book\">";
  HttpClient client = HttpClient.newHttpClient();
  HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create(url))
      .POST(HttpRequest.BodyPublishers.ofString(
          "{\"metadata\": \"" + metadata + "\"}"))
      .header("Content-Type", "application/json")
      .build();
  ```



  The library can handle metadata about:
  - Books
  - Articles
  - Journals
  - Book chapters

  It looks for these specific pieces of information:
  - Names/titles
  - Author names
  - ISBN numbers
  - Website sources



  1. "Import error when using the library"
     - Make sure you installed the library using pip
     - Check that Python is in your system PATH

  2. "Can't connect to the API"
     - Make sure the server is running (python run_server.py)
     - Check that you're using the correct URL (http://localhost:5000)

  3. "Getting empty results"
     - Check that your metadata follows the expected format
     - Make sure it contains at least one of the supported fields



  If you run into any problems:
  1. Check the Common Problems section above
  2. Look at the example files in the 'examples' directory
  3. Create an issue on GitHub



  MIT License - Feel free to use this library in your projects!


pkgId: 933d03edd00131885d4e5587d7441a3126661fe3c53773a6db4dcb5d6c21c0bf
name: python-cleantext
arch: src
version: 1.1.4
epoch: 0
release: 1
summary: An open-source python package to clean raw text data
url: https://github.com/prasanthg3/cleantext
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleantext-1.1.4-1.src.rpm
checksum_type: sha256
description:
  ``` Python
  import cleantext
  cleantext.clean_words('This is A s$ample !!!! tExt3% to   cleaN566556+2+59*/133')
  ```
  returns,
  ``` Python
  ['sampl', 'text', 'clean']


pkgId: cd54c738b22b37351e4d60a4205b96b68945d9473deaf9d6d3f684d93211755c
name: python-cleanurl
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: Remove clutter from URLs and return a canonicalized version
url: https://github.com/xojoc/cleanurl
rpm_license: AGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanurl-0.1.15-1.src.rpm
checksum_type: sha256
description:
  Remove clutter from URLs and return a canonicalized version


  ```
  pip install cleanurl
  ```
  or if you're using poetry:
  ```
  poetry add cleanurl
  ```


  By default *cleanurl* retuns a cleaned URL without respecting semantics.
  For example:

  ```
  >>> import cleanurl
  >>> r = cleanurl.cleanurl('https://www.xojoc.pw/blog/focus.html?utm_content=buffercf3b2&utm_medium=social&utm_source=snapchat.com&utm_campaign=buffe')
  >>> r.url
  'https://xojoc.pw/blog/focus'
  >>> r.parsed_url
  ParseResult(scheme='https', netloc='xojoc.pw', path='/blog/focus', params='', query='', fragment='')
  ```

  The default parameters are useful if you want to get a *canonical* URL without caring if the resulting URL is still valid.

  If you want to get a clean URL which is still valid call it like this:

  ```
  >>> r = cleanurl.cleanurl('https://www.xojoc.pw/blog/////focus.html', respect_semantics=True)
  >>> r.url
  'https://www.xojoc.pw/blog/focus.html'
  ```

  ```celeanurl.cleanurl``` parameters:

   - ```generic``` -> if True don't use site specific rules
   - ```respect_semantics``` -> if True make sure the returned URL is still valid, altough it may still contain some superfluous elements
   - ```host_remap``` -> whether to remap hosts. Example:
  ```
  >>> import cleanurl
  >>> cleanurl.cleanurl('https://threadreaderapp.com/thread/1453753924960219145', host_remap=True).url
  'https://twitter.com/i/status/1453753924960219145'
  >>> cleanurl.cleanurl('https://threadreaderapp.com/thread/1453753924960219145', host_remap=False).url
  'https://threadreaderapp.com/thread/1453753924960219145'
  ```

  For more examples see the [unit tests](https://github.com/xojoc/cleanurl/blob/main/src/test_cleanurl.py).



  While there are some libraries that handle general cases, this library has website specific rules that more aggresivly normalize urls.


  Initially used for [discu.eu](https://discu.eu).

  [Discussions around the web](https://discu.eu/q/https://github.com/xojoc/cleanurl)


  *cleanurl* was written by [Alexandru Cojocaru](https://xojoc.pw).


  *cleanurl* is [Free Software](https://www.gnu.org/philosophy/free-sw.html) and is released as [AGPLv3](https://github.com/xojoc/cleanurl/blob/main/LICENSE)


pkgId: 690cd477c6cba929677dc449c4ecf3ccdd692da198e1f1e84cff46f4fda1436e
name: python-cleanvid
arch: src
version: 1.7.0
epoch: 0
release: 1
summary: cleanvid is a little script to mute profanity in video files.
url: https://github.com/mmguero/cleanvid
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanvid-1.7.0-1.src.rpm
checksum_type: sha256
description:
  [![Latest Version](https://img.shields.io/pypi/v/cleanvid)](https://pypi.python.org/pypi/cleanvid/) [![Docker Image](https://github.com/mmguero/cleanvid/workflows/cleanvid-build-push-ghcr/badge.svg)](https://github.com/mmguero/cleanvid/pkgs/container/cleanvid)

  **cleanvid** is a little script to mute profanity in video files in a few simple steps:

  1. The user provides as input a video file and matching `.srt` subtitle file. If subtitles are not provided explicitly, they will be extracted from the video file if possible; if not, [`subliminal`](https://github.com/Diaoul/subliminal) is used to attempt to download the best matching `.srt` file.
  2. [`pysrt`](https://github.com/byroot/pysrt) is used to parse the `.srt` file, and each entry is checked against a [list](./src/cleanvid/swears.txt) of profanity or other words or phrases you'd like muted. Mappings can be provided (eg., map "sh*t" to "poop"), otherwise the word will be replaced with *****.
  3. A new "clean" `.srt` file is created. with *only* those phrases containing the censored/replaced objectional language.
  4. [`ffmpeg`](https://www.ffmpeg.org/) is used to create a cleaned video file. This file contains the original video stream, but the specified audio stream is muted during the segments containing objectional language. That audio stream is re-encoded and remultiplexed back together with the video. Optionally, the clean `.srt` file can be embedded in the cleaned video file as a subtitle track.

  You can then use your favorite media player to play the cleaned video file together with the cleaned subtitles.

  As an alternative to creating a new video file, cleanvid can create a simple EDL file (see the [mplayer](http://www.mplayerhq.hu/DOCS/HTML/en/edl.html) or KODI [documentation](https://kodi.wiki/view/Edit_decision_list)) or a custom JSON definition file for [PlexAutoSkip](https://github.com/mdhiggins/PlexAutoSkip).

  **cleanvid** is part of a family of projects with similar goals:

  * 📼 [cleanvid](https://github.com/mmguero/cleanvid) for video files (using [SRT-formatted](https://en.wikipedia.org/wiki/SubRip#Format) subtitles)
  * 🎤 [monkeyplug](https://github.com/mmguero/monkeyplug) for audio and video files (using either [Whisper](https://openai.com/research/whisper) or the [Vosk](https://alphacephei.com/vosk/)-[API](https://github.com/alphacep/vosk-api) for speech recognition)
  * 📕 [montag](https://github.com/mmguero/montag) for ebooks


  Using `pip`, to install the latest [release from PyPI](https://pypi.org/project/cleanvid/):

  ```
  python3 -m pip install -U cleanvid
  ```

  Or to install directly from GitHub:


  ```
  python3 -m pip install -U 'git+https://github.com/mmguero/cleanvid'
  ```



  [cleanvid](./src/cleanvid/cleanvid.py) requires:

  * Python 3
  * [FFmpeg](https://www.ffmpeg.org)
  * [babelfish](https://github.com/Diaoul/babelfish)
  * [delegator.py](https://github.com/kennethreitz/delegator.py)
  * [pysrt](https://github.com/byroot/pysrt)
  * [subliminal](https://github.com/Diaoul/subliminal)

  To install FFmpeg, use your operating system's package manager or install binaries from [ffmpeg.org](https://www.ffmpeg.org/download.html). The Python dependencies will be installed automatically if you are using `pip` to install cleanvid.



  ```
  usage: cleanvid [-h] [-s <srt>] -i <input video> [-o <output video>] [--plex-auto-skip-json <output JSON>] [--plex-auto-skip-id <content identifier>] [--subs-output <output srt>]
                  [-w <profanity file>] [-l <language>] [-p <int>] [-e] [-f] [--subs-only] [--offline] [--edl] [--json] [--re-encode-video] [--re-encode-audio] [-b] [-v VPARAMS] [-a APARAMS]
                  [-d] [--audio-stream-index <int>] [--audio-stream-list] [--threads-input <int>] [--threads-encoding <int>] [--threads <int>]

  options:
    -h, --help            show this help message and exit
    -s <srt>, --subs <srt>
                          .srt subtitle file (will attempt auto-download if unspecified and not --offline)
    -i <input video>, --input <input video>
                          input video file
    -o <output video>, --output <output video>
                          output video file
    --plex-auto-skip-json <output JSON>
                          custom JSON file for PlexAutoSkip (also implies --subs-only)
    --plex-auto-skip-id <content identifier>
                          content identifier for PlexAutoSkip (also implies --subs-only)
    --subs-output <output srt>
                          output subtitle file
    -w <profanity file>, --swears <profanity file>
                          text file containing profanity (with optional mapping)
    -l <language>, --lang <language>
                          language for extracting srt from video file or srt download (default is "eng")
    -p <int>, --pad <int>
                          pad (seconds) around profanity
    -e, --embed-subs      embed subtitles in resulting video file
    -f, --full-subs       include all subtitles in output subtitle file (not just scrubbed)
    --subs-only           only operate on subtitles (do not alter audio)
    --offline             don't attempt to download subtitles
    --edl                 generate MPlayer EDL file with mute actions (also implies --subs-only)
    --json                generate JSON file with muted subtitles and their contents
    --re-encode-video     Re-encode video
    --re-encode-audio     Re-encode audio
    -b, --burn            Hard-coded subtitles (implies re-encode)
    -v VPARAMS, --video-params VPARAMS
                          Video parameters for ffmpeg (only if re-encoding)
    -a APARAMS, --audio-params APARAMS
                          Audio parameters for ffmpeg
    -d, --downmix         Downmix to stereo (if not already stereo)
    --audio-stream-index <int>
                          Index of audio stream to process
    --audio-stream-list   Show list of audio streams (to get index for --audio-stream-index)
    --threads-input <int>
                          ffmpeg global options -threads value
    --threads-encoding <int>
                          ffmpeg encoding options -threads value
    --threads <int>       ffmpeg -threads value (for both global options and encoding)
  ```



  Alternately, a [Dockerfile](./docker/Dockerfile) is provided to allow you to run cleanvid in Docker. You can build the `oci.guero.top/cleanvid:latest` Docker image with [`build_docker.sh`](./docker/build_docker.sh), then run [`cleanvid-docker.sh`](./docker/cleanvid-docker.sh) inside the directory where your video/subtitle files are located.



  If you'd like to help improve cleanvid, pull requests will be welcomed!



  * **Seth Grover** - *Initial work* - [mmguero](https://github.com/mmguero)



  This project is licensed under the BSD 3-Clause License - see the [LICENSE](LICENSE) file for details.



  Thanks to:

  * the developers of [FFmpeg](https://www.ffmpeg.org/about.html)
  * [Mattias Wadman](https://github.com/wader) for his [ffmpeg](https://github.com/wader/static-ffmpeg) image
  * [delegator.py](https://github.com/kennethreitz/delegator.py) developer Kenneth Reitz and contributors
  * [pysrt](https://github.com/byroot/pysrt) developer Jean Boussier and contributors
  * [subliminal](https://github.com/Diaoul/subliminal) developer Antoine Bertin and contributors


pkgId: 4bb66d4a8371ef00a81a0042800364037b3ee7089ef4aa2d60789940965c2960
name: python-cleanvision
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: Find issues in image datasets
url: https://pypi.org/project/cleanvision/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleanvision-0.3.6-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/cleanlab/assets/master/cleanlab/cleanvision_logo_open_source_transparent.png" width=50% height=50%>
  </p>

  <img width="1200" alt="Screen Shot 2023-03-10 at 10 23 33 AM" src="https://user-images.githubusercontent.com/10901697/224394144-bb0e1c85-6851-4828-bcd2-4ed234270a78.png">

  CleanVision automatically detects potential issues in image datasets like images that are: blurry, under/over-exposed, (near) duplicates, etc.
  This data-centric AI package is a quick first step for any computer vision project to find problems in the dataset, which you want to address before applying machine learning.
  CleanVision is super simple -- run the same couple lines of Python code to audit any image dataset!

  [![Read the Docs](https://readthedocs.org/projects/cleanvision/badge/?version=latest)](https://cleanvision.readthedocs.io/en/latest/)
  [![pypi](https://img.shields.io/pypi/v/cleanvision?color=blue)](https://pypi.org/pypi/cleanvision/)
  [![os](https://img.shields.io/badge/platform-noarch-lightgrey)](https://pypi.org/pypi/cleanvision/)
  [![py\_versions](https://img.shields.io/badge/python-3.7%2B-blue)](https://pypi.org/pypi/cleanvision/)
  [![codecov](https://codecov.io/github/cleanlab/cleanvision/branch/main/graph/badge.svg?token=y1N6MluN9H)](https://codecov.io/gh/cleanlab/cleanvision)
  [![Slack Community](https://img.shields.io/static/v1?logo=slack&style=flat&color=white&label=slack&message=community)](https://cleanlab.ai/slack)
  [![Twitter](https://img.shields.io/twitter/follow/CleanlabAI?style=social)](https://twitter.com/CleanlabAI)
  [![Cleanlab Studio](https://raw.githubusercontent.com/cleanlab/assets/master/shields/cl-studio-shield.svg)](https://cleanlab.ai/studio/?utm_source=github&utm_medium=readme&utm_campaign=clostostudio)


  ```shell
  pip install cleanvision
  ```



  Download an example dataset (optional). Or just use any collection of image files you have.

  ```shell
  wget -nc 'https://cleanlab-public.s3.amazonaws.com/CleanVision/image_files.zip'
  ```

  1. Run CleanVision to audit the images.

  ```python
  from cleanvision import Imagelab


  imagelab = Imagelab(data_path="FOLDER_WITH_IMAGES/")


  imagelab.find_issues()


  imagelab.report()
  ```

  2. CleanVision diagnoses many types of issues, but you can also check for only specific issues.

  ```python
  issue_types = {"dark": {}, "blurry": {}}

  imagelab.find_issues(issue_types=issue_types)


  imagelab.report(issue_types=issue_types)
  ```




  - [Tutorial](https://cleanvision.readthedocs.io/en/latest/tutorials/tutorial.html)
  - [Run CleanVision on a HuggingFace dataset](https://cleanvision.readthedocs.io/en/latest/tutorials/huggingface_dataset.html)
  - [Run CleanVision on a Torchvision dataset](https://cleanvision.readthedocs.io/en/latest/tutorials/torchvision_dataset.html)
  - [Example script](https://github.com/cleanlab/cleanvision/blob/main/docs/source/tutorials/run.py) that can be run with: `python examples/run.py --path <FOLDER_WITH_IMAGES>`
  - [Additional example notebooks](https://github.com/cleanlab/cleanvision-examples)
  - [Documentation](https://cleanvision.readthedocs.io/)
  - [Blog Post](https://cleanlab.ai/blog/cleanvision/)
  - [FAQ](https://cleanvision.readthedocs.io/en/latest/faq.html)



  The quality of machine learning models hinges on the quality of the data used to train them, but it is hard to manually identify all of the low-quality data in a big dataset. CleanVision helps you automatically identify common types of data issues lurking in image datasets.

  This package currently detects issues in the raw images themselves, making it a useful tool for any computer vision
  task such as: classification, segmentation, object detection, pose estimation, keypoint detection, [generative modeling](https://openai.com/research/dall-e-2-pre-training-mitigations), etc.
  To detect issues in the labels of your image data, you can instead
  use the [cleanlab](https://github.com/cleanlab/cleanlab/) package.

  In any collection of image files (most [formats](https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html) supported), CleanVision can detect the following types of issues:

  |   | Issue Type       | Description                                                     | Issue Key        | Example                                                                                                                                 |
  |---|------------------|-----------------------------------------------------------------|------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
  | 1 | Exact Duplicates | Images that are identical to each other                         | exact_duplicates | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/exact_duplicates.png)                     |
  | 2 | Near Duplicates  | Images that are visually almost identical                       | near_duplicates  | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/near_duplicates.png)                      |
  | 3 | Blurry           | Images where details are fuzzy (out of focus)                   | blurry           | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/blurry.png)                               |
  | 4 | Low Information  | Images lacking content (little entropy in pixel values)         | low_information  | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/low_information.png)                      |
  | 5 | Dark             | Irregularly dark images (*under*exposed)                        | dark             | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/dark.jpg)                                 |
  | 6 | Light            | Irregularly bright images (*over*exposed)                       | light            | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/light.jpg)                                |
  | 7 | Grayscale        | Images lacking color                                            | grayscale        | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/grayscale.jpg)                            |
  | 8 | Odd Aspect Ratio | Images with an unusual aspect ratio (overly skinny/wide)        | odd_aspect_ratio | ![](https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/odd_aspect_ratio.jpg)                     |
  | 9 | Odd Size         | Images that are abnormally large or small compared to the rest of the dataset | odd_size         | <img src="https://raw.githubusercontent.com/cleanlab/assets/master/cleanvision/example_issue_images/odd_size.png" width=20% height=20%> |

  CleanVision supports Linux, macOS, and Windows and runs on Python 3.7+.



  * The best place to learn is [our Slack community](https://cleanlab.ai/slack). Join the discussion there to see how
    folks are using this library, discuss upcoming features, or ask for private support.

  * Need professional help with CleanVision?  Join our [\#help Slack channel](https://cleanlab.ai/slack) and message us there, or reach out via email: team@cleanlab.ai

  * Interested in contributing? See the [contributing guide](CONTRIBUTING.md). An easy starting point is to
    consider [issues](https://github.com/cleanlab/cleanvision/labels/good%20first%20issue) marked `good first issue` or
    simply reach out in [Slack](https://cleanlab.ai/slack). We welcome your help building a standard open-source library
    for data-centric computer vision!

  * Ready to start adding your own code? See the [development guide](DEVELOPMENT.md).

  * Have an issue? [Search existing issues](https://github.com/cleanlab/cleanvision/issues?q=is%3Aissue)
    or [submit a new issue](https://github.com/cleanlab/cleanvision/issues/new/choose).

  * Have ideas for the future of data-centric computer vision? Check
    out [our active/planned Projects and what we could use your help with](https://github.com/cleanlab/cleanvision/projects).



  Copyright (c) 2022 Cleanlab Inc.

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

  cleanvision 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 [GNU Affero General Public LICENSE](https://github.com/cleanlab/cleanvision/blob/main/LICENSE) for details.

  Commercial licensing is available for enterprise teams that want to use CleanVision in production workflows, but are unable to open-source their code [as is required by the current license](https://github.com/cleanlab/cleanvision/blob/main/LICENSE). Please email us: team@cleanlab.ai


  [issue]: https://github.com/cleanlab/cleanvision/issues/new

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


pkgId: 31e13bd5a221a91ba1d32588894c785e74c2a60a78455e3b56dbb931b58effd7
name: python-clear
arch: src
version: 2.0.0
epoch: 0
release: 1
url: https://github.com/asweigart/clear
rpm_license: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-2.0.0-1.src.rpm
checksum_type: sha256
summary:
  A cross-platform Python module that provides a clear() function which clears the terminal. That's all.

description:
  A cross-platform Python module that provides a clear() function which clears the terminal. That's all.
  To install with pip, run:
      pip install clear
  You can then clear the screen by running:
      from clear import clear
      clear()
  This function runs the one-liner: `os.system('cls' if os.name == 'nt' else 'clear')`
  This module exists as a simpler alternative to defining this function on your own.
  Special thanks to David George for allowing me to use the Clear name on PyPI. The original Clear module ("Command-Line Extract And Rename utility. This provides a media library manager that allows extraction and renaming of media files.") can still be found in the previous releases of this project on PyPI.


pkgId: d7e0513594ffc578efe8ecb3e70d2bec681ea2ace51f234b4ac12d0d7dec14bb
name: python-clear-html
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Clean and normalize HTML.
url: https://pypi.org/project/clear-html/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-html-0.4.1-1.src.rpm
checksum_type: sha256
rpm_license:
  The MIT License (MIT)  Copyright (c) 2023 Zyte Group Ltd  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: c3cfd1bb461690addd6dc75cee93b8e132f338cd4e5743b92e94049c68938605
name: python-clear-screen
arch: src
version: 0.1.14
epoch: 0
release: 1
summary: A simple function for clearing a Python Interpreter/Shell
url: https://pypi.org/project/clear-screen/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-screen-0.1.14-1.src.rpm
checksum_type: sha256
description:
  <br><br>
  <strong>USAGE:</strong>
  <br>
  <code>from clear_screen import clear</code><br>
  <code>clear()</code><br>
  <br>
  Works on Linux, Windows, Mac terminal/shell
  <br>
  Compatible with Python 2 and Python 3
  <br><br>
  <b>DOES NOT WORK WITH THE IDLE INTERPRETER</b>
  <br>
  <hr>


pkgId: 22dea146f31ddf5701c0fcaf26a55c30d1bdf7c80c835ae4066df2c4e6e1973b
name: python-clear-skies
arch: src
version: 1.22.14
epoch: 0
release: 1
summary: A framework for building backends in the cloud
url: https://github.com/cmancone/clearskies
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-skies-1.22.14-1.src.rpm
checksum_type: sha256
description:
  clearskies is a very opinionated Python framework intended for developing microservices in the cloud via declarative programming principles.  It is mainly intended for backend services and so is designed for RESTful API endpoints, queue listeners, scheduled tasks, and the like.



  To install:

  ```
  pip3 install clear-skies
  ```

  Documentation is under construction here:

  [https://clearskies.info](https://clearskies.info)


pkgId: c60a357f32cba9834ccbff46906dcaf7b13ae2c7d30fa50168dbae2d82b0a9a1
name: python-clear-skies-auth-server
arch: src
version: 0.12.11
epoch: 0
release: 1
summary: clearskies bindings for managing an authentication server that issues JWTs
url: https://github.com/cmancone/clearskies-auth-server
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-skies-auth-server-0.12.11-1.src.rpm
checksum_type: sha256
description:
  Contains the handlers needed to manage an authentication server with clearskies.



  ```
  pip install clear-skies-auth-server
  ```

  Click [here for a detailed usage example](https://github.com/cmancone/clearskies-auth-server-example).



  This package provides the various pieces needed to manage an authentication server.  Specifically, it authenticates users and issues signed JSON Web Tokens (JWTs) for other services to validate.  This is intended for use as a stand-alone identity provider (IdP) and so requires a datastore where users (and, if needed, passwords) are validated.  Naturally, the datastore is provided via a clearskies model, and thus this can work with a wide variety of backends.

  In essence, you get to chose which parts of the auth server you need, provide a bit of configuration, and wrap the handlers up in a standard [clearskies SimpleRouting handler](https://clearskies.info/docs/handlers/simple-routing.html).  Naturally, clearskies will auto-generate your OAI3 docs for you.

  Keep in mind that this is the backend API endpoints _only_.  You'll have to provide your own frontend.



  The following handlers are provided by this package to expose the necessary parts of the authorization server:

   1. [generate-keys](#generate-keys)
   2. [jwks](#jwks)
   3. [password_login](#password-login)
   4. [password_less_email_request_login](#password-less-email-request-login)
   5. [password_less_validate_login](#password-less-validate-login)

  Roadmap for 1.0:

   * MFA



  This handler publishes the JSON Web Key Set (JWKS) that is necessary for JWT consumers to validate JWTs created by the service.



  This manages password-based logins.



  For a password-less login system, this allows a user to request a login.  Note that for minimalist systems, an explicit registration step is no longer required.



  Validates the login (and possibly completes registration) for a password-less login system.


pkgId: 9771894661696905c89a5d79d84f77f3c527dde5eca7d5f951aadd49d1288018
name: python-clear-skies-aws
arch: src
version: 1.9.11
epoch: 0
release: 1
summary: clearskies bindings for working in AWS
url: https://github.com/cmancone/clearskies-aws
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-skies-aws-1.9.11-1.src.rpm
checksum_type: sha256
description:
  clearskies bindings for working in AWS, which means additional:

   - backends (DynamoDB, SQS)
   - Secret/environment integrations (parameter store/secret manager)
   - DB connectivity via IAM auth
   - Contexts (ALB, HTTP API Gateway, Rest API Gateway, direct Lambda invocation, lambda+SQS)



  To install:

  ```
  pip3 install clear-skies-aws
  ```



  Anytime you use a context from `clearskies-aws`, the default dependencies are adjust to:

   1. Provide `dynamo_db_backend` as an allowed backend
   2. Configure clearskies to use SSM Parameter Store as the default secrets "manager".

  In both cases you must provide the AWS region for your resources, which you do by setting the `AWS_REGION` environment variable (either in an actual environment variable or in your `.env` file).



  To use the SSM parameter store you just inject the `secrets` variable into your callables:

  ```
  import clearskies_aws

  def parameter_store_demo(secrets):
      return secrets.get('/path/to/parameter')

  execute_demo_in_elb = clearskies_aws.contexts.lambda_elb(parameter_store_demo)

  def lambda_handler(event, context):
      return execute_demo_in_elb(event, context)
  ```

  Also, per default behavior, clearskies can fetch things from your secret manager if specified in your environment/.env file.  For instance, if your database password is stored in parameter store, then you can reference it from your `.env` file with a standard cursor backend:

  ```
  db_host = "path-to-aws.rds"
  db_username = "sql_username"
  db_password = "secret://path/to/password/in/parameter/store"
  db_database = "sql_database_name"
  ```



  If desired, you can swap out the parameter store integration for secret manager.  Just remember that you can configure parameter store to fetch secrets from secret manager, so you might be best off doing that and sticking with the default parameter store integration.  Still, if you want to use secret manager, you just configure it in your application or context:

  ```
  import clearskies_aws

  def secret_manager_demo(secrets):
      return secrets.get('SecretARNFromSecretManager')

  execute_demo_in_elb = clearskies_aws.contexts.lambda_elb(
      parameter_store_demo,
      bindings={'secrets': clearskies_aws.secrets.SecretManager},
  )

  def lambda_handler(event, context):
      return execute_demo_in_elb(event, context)
  ```



  clearskies_aws adds the following contexts:

  | name/import                                                 | Usage                             |
  |-------------------------------------------------------------|-----------------------------------|
  | `clearskies_aws.contexts.lambda_api_gateway`                | Lambdas behind a Rest API Gateway |
  | `clearskies_aws.contexts.lambda_elb`                        | Lambdas behind a simple ELB/ALB   |
  | `clearskies_aws.contexts.lambda_http_gateway`               | Lambdas behind an HTTP Gateway    |
  | `clearskies_aws.contexts.lambda_inocation`                  | Lambdas invoked directly          |
  | `clearskies_aws.contexts.lambda_sqs_standard_partial_batch` | Lambdas attached to an SQS queue  |



  Here's a simple example of using the Lambda+SQS context:

  ```
  import clearskies_aws
  import clearskies

  def process_record(request_data):
      print(request_data)

  process_sqs = clearskies_aws.contexts.lambda_sqs_standard_partial_batch(process_record)
  def lambda_handler(event, context):
      process_sqs(event, context)
  ```

  See [the AWS docs](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html).

  Note that, unlike other contexts, the Lambda+SQS context really only works with a simple callable.  Routing and other handlers don't make much sense here.  Keep in mind that, before invoking the Lambda, AWS may batch up records together in arbitrary ways.  The context will take care of this and will invoke your callable once **for each record in the AWS event** - not once for the event.  `request_data` will be populated with the actual message for the event.  In addition, it assumes that a JSON message was sent to the queue, so `request_data` will be an object/list/etc, rather than a string.  This is intended to be used with [partial batching](https://docs.aws.amazon.com/lambda/latest/dg/with-sqs.html#services-sqs-batchfailurereporting).  Therefore, if your function raises an error, the context will catch it, return a failure response for the cooresponding message, and then continue processing any other messages in the batch.



  To use the SQS backend just declare it for your model, set the table name to return the queue url, and execute a "create" operation to send data to the queue.  Note that the SQS backend is write-only: you can "create" records (resulting in a message being sent to the queue), but you can't read data back out.  The way the queue system in SQS works is just too different than a standard database for that to make sense in the context of a clearskies model.

  ```

  import clearskies_aws
  import clearskies
  from collections import OrderedDict

  class Product(clearskies.Model):
      def __init__(self, sqs_backend, columns):
          super().__init__(sqs_backend, columns)

      @classmethod
      def table_name(cls):
          return 'https://sqs.us-east-1.amazonaws.com/123456789012/test-queue'

      def columns_configuration(self):
          return OrderedDict([
              clearskies.column_types.string('name'),
              clearskies.column_types.string('description'),
          ])

  def send_to_queue(products):
      for i in range(10):
          products.create({
              'name': 'test',
              'description': str(i),
          })

  cli = clearskies_aws.contexts.cli(
      send_to_queue,
      binding_classes=[Product],
  )
  if __name__ == '__main__':
      cli()
  ```



  For non-serverless RDS databases, AWS supports login via IAM.  You have to provide a few additional details in your environment to make this work:

  | name                     | value                                                                                                                 |
  |--------------------------|-----------------------------------------------------------------------------------------------------------------------|
  | `AWS_REGION`             | The region your database is in (e.g. `us-east-1`)                                                                     |
  | `db_endpoint`            | The endpoint from your database (available in RDS)                                                                    |
  | `db_username`            | The username to use to connect                                                                                        |
  | `db_database`            | The name of the database                                                                                              |
  | `ssl_ca_bundle_filename` | Path to the appropriate SSL bundle (see https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/UsingWithRDS.SSL.html) |

  and then you have to enable it in your application/context configuration:

  ```
  import clearskies_aws

  def cursor_via_iamdb_auth(cursor):
      print('I connected successfully!')

  execute_demo_in_elb = clearskies_aws.contexts.lambda_elb(
      cursor_via_iamdb_auth,
      additional_configs=[clearskies_aws.di.IAMDBAuth]
  )

  def lambda_handler(event, context):
      return execute_demo_in_elb(event, context)
  ```

  Of course normally you wouldn't want to interact with it directly.  Adding `IAMDBAuth` to your `additional_configs` and setting up the necessary environemnt variables will be sufficient that any models that use the `cursor_backend` will connect via IAM DB Auth, rather than using hard-coded passwords.



  Coming shortly


pkgId: b067530616843889acaf114fb0b55e7880902eb79b92c6f9c02cdf8037a2d4c1
name: python-clear-skies-stripe
arch: src
version: 0.9.21
epoch: 0
release: 1
summary: clearskies bindings for working with Stripe
url: https://github.com/cmancone/clearskies-stripe
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-skies-stripe-0.9.21-1.src.rpm
checksum_type: sha256
description:
  clearskies bindings for working with [Stripe](https://stripe.com/).  Mostly this means handlers and actions to control the flow of data to and from stripe.



  To install:

  ```
  pip install clear-skies-stripe
  ```





  This module has a variety of actions and handlers which take care of the stripe integration.  However, before you can use any of them, you must setup the stripe module with clearskies and tell it how to authenticate to Stripe.  The module assumes that your Stripe API key is stored in your secret manager, so you just have to tell it the path to the API key in your secret manager.

  **IMPORTANT**: This module is designed to fetch your Stripe API key only when needed and will automatically re-fetch the key from the secrets manager in the event of an authentication failure.  As a result, you can rotate your Stripe API key at anytime: just drop the new API key in your secret manager and your running processes will automatically find it and use it without needing to restart/rebuild/relaunch the application.

  In the following example, we configure a clearskies application to use AWS Secrets Manager for the storage of secrets, and then we tell the Stripe integration to fetch its api key from `/path/to/stripe/(api|publishable)/key` in AWS Secrets Manager.  Of course, you can use any secrets manager you want: just swap out `secrets` in the dependency injection configuration.

  ```
  import clearskies
  import clearskies_stripe
  import clearskies_aws

  application = clearskies.Application(
      SomeHandler,
      {
          "your": "application config",
      },
      bindings={
          "stripe": clearskies_stripe.di.stripe(
              "/path/to/stripe/api/key",
              "/path/to/stripe/publishable/key",
          ),
          "secrets": clearskies_aws.secrets.SecretsManager,
      },
  )
  ```



  To use any of the models you must import the `clearskies_stripe` module into your application (you still have to configure authentication per the above):

  ```
  import clearskies
  import clearskies_stripe
  import clearskies_aws

  application = clearskies.Application(
      SomeHandler,
      {
          "your": "application config",
      },
      binding_modules=[
          clearskies_stripe,
      ],
      bindings={
          "stripe": clearskies_stripe.di.stripe(
              "/path/to/stripe/api/key",
              "/path/to/stripe/publishable/key",
          ),
          "secrets": clearskies_aws.secrets.SecretsManager,
      },
  )
  ```



  This module comes with a limited selection of models.  The columns available in each model match those published via the Stripe API.

  | Model               | DI name               | Stripe Docs |
  |---------------------|-----------------------|-------------|
  | StripeCustomer      | stripe_customer       | TBD |
  | StripePayment       | stripe_payment        | TBD |
  | StripePaymentMethod | stripe_payment_method | TBD |



  This handler creates a SetupIntent and returns the details of it, as well as the publishable key.  You can specify any of the parameters for the [create call].  In addition, you can provide `parameters_callable` which can change all the parameters that will be passed to the create call, and you can also provide `output_callable` which changes the response from the handler.  By default, the handler returns the full details of the response from the create call, as well as your publishable key.



  Here are the list of allowed configurations for this handler (on top of the standard handler configs).  All configs are optional.  With the exception of the callables (described below), all configuration options will be passed along as-is in the call to `stripe.setup_intents.create()`.  See [the stripe docs](https://docs.stripe.com/api/setup_intents/create) for more details:

  | Name                           | Type        |
  |--------------------------------|-------------|
  | `automatic_payment_methods`    | `dict`      |
  | `confirm`                      | `bool`      |
  | `description`                  | `str`       |
  | `metadata`                     | `dict`      |
  | `payment_method`               | `str`       |
  | `usage`                        | `str`       |
  | `attach_to_self`               | `bool`      |
  | `confirmation_token`           | `str`       |
  | `flow_directions`              | `list[str]` |
  | `mandate_data`                 | `dict`      |
  | `on_behalf_of`                 | `str`       |
  | `payment_method_configuration` | `str`       |
  | `payment_method_data,`         | `dict`      |
  | `payment_method_options`       | `dict`      |
  | `payment_method_types`         | `list[str]` |
  | `return_url`                   | `str`       |
  | `single_use`                   | `dict`      |
  | `use_stripe_sdk`               | `bool`      |
  | `parameters_callable`          | `Callable`  |
  | `output_callable`              | `Callable`  |



  The `parameters_callable` is provided with the following kwargs
  | Name                 | Type                                   | Value |
  |----------------------|----------------------------------------|-------|
  | `input_output`       | `clearskies.input_outputs.InputOutput` | The input output object for the request |
  | `routing_data`       | `dict`                                 | Any named routing parameters |
  | `request_data`       | `dict`                                 | The contents of the JSON request body |
  | `authorization_data` | `dict`                                 | Any authorization data for logged in users |
  | `context_specifics`  | `dict`                                 | Any additional data provided by the context the application is running under |

  It should return a dictionary, which will be passed along in the SDK call to `setup_intents.create()`.  If the parameters callable returns a parameter that is also specified in the handler configuration, the return value from the parameters callable takes preference.



  The `output_callable` will be provided the response from the `setup_intents.create()` call and can make additional changes.  Note that this function **MUST** return a dictionary.  If `output_callable` is defined then it's response will be returned to the user as-is, which means that only the data returned by the callable will be sennt along to the client.

  The `output_callable` is provided with the following kwargs:

  | Name                 | Type                                   | Value |
  |----------------------|----------------------------------------|-------|
  | `response`           | `dict`                                 | The response from the `setup_intents.create()` call |
  | `input_output`       | `clearskies.input_outputs.InputOutput` | The input output object for the request |
  | `routing_data`       | `dict`                                 | Any named routing parameters |
  | `request_data`       | `dict`                                 | The contents of the JSON request body |
  | `authorization_data` | `dict`                                 | Any authorization data for logged in users |
  | `context_specifics`  | `dict`                                 | Any additional data provided by the context the application is running under |



  Here's an example of using the CreateSetupIntent handler.  This example assumes that the stripe customer id is stored in the JWT in the key `stripe_customer_id`, and so it uses that fact in conjunction with the `parameters_callable` to set the customer id on the setup intent:

  ```
  import clearskies
  import clearskies_stripe
  import clearskies_aws

  def add_stripe_customer(self, authorization_data):
      return {"customer": authorization_data["stripe_customer_id"]}

  application = clearskies.Application(
      clearskies.handlers.SimpleRouting,
      {
          "authentication": clearskies.authentication.jwks("https://example.com/.well-known/jwks.json"),
          "routes": [
              {
                  "path": "/setup_intent",
                  "methods": "POST",
                  "handler_class": clearskies_stripe.handlers.CreateSetupIntent,
                  "handler_config": {
                      "usage": "off_session",
                      "parameters_callable": add_stripe_customer,
                  },
              },
          ],
      },
      bindings={
          "stripe": clearskies_stripe.di.stripe(
              "/path/to/stripe/api/key/in/secrets/manager",
              "/path/to/stripe/publishable/key/in/secrets/manager",
          ),
          "secrets": clearskies_aws.secrets.SecretsManager,
      },
  )

  in_wsgi = clearskies_aws.contexts.wsgi(application)
  def application(env, start_response):
      return in_wsgi(env, start_response)

  in_lambda = clearskies_aws.contexts.lambda_elb(application)
  def lambda_handler(event, context):
      return in_lambda(env, start_response)
  ```

  You would then execute and expect something like this:

  ```
  $ curl 'https://your-application/setup_intent' -X POST | jq
  ```


pkgId: d0ccb4a4ffd6458a38964a908bcfbec6c9442562a69071e72a20bbb6c7060132
name: python-clear-street-studio-sdk
arch: src
version: 0.1.0a14
epoch: 0
release: 1
summary: The official Python library for the studio-sdk API
url: https://github.com/clear-street/studio-sdk-python
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clear-street-studio-sdk-0.1.0a14-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/clear-street-studio-sdk.svg)](https://pypi.org/project/clear-street-studio-sdk/)

  The Studio SDK Python library provides convenient access to the Studio SDK REST API from any Python 3.8+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [docs.clearstreet.io](https://docs.clearstreet.io/studio). The full API of this library can be found in [api.md](https://github.com/clear-street/studio-sdk-python/tree/main/api.md).



  ```sh

  pip install --pre clear-street-studio-sdk
  ```



  The full API of this library can be found in [api.md](https://github.com/clear-street/studio-sdk-python/tree/main/api.md).

  ```python
  import os
  from studio_sdk import StudioSDK

  client = StudioSDK(
      bearer_token=os.environ.get(
          "STUDIO_SDK_BEARER_TOKEN"
      ),  # This is the default and can be omitted
      
      environment="sandbox",
  )

  entity = client.entities.retrieve(
      "<your_entity_id>",
  )
  print(entity.entity_id)
  ```

  While you can provide a `bearer_token` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `STUDIO_SDK_BEARER_TOKEN="My Bearer Token"` to your `.env` file
  so that your Bearer Token is not stored in source control.



  Simply import `AsyncStudioSDK` instead of `StudioSDK` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from studio_sdk import AsyncStudioSDK

  client = AsyncStudioSDK(
      bearer_token=os.environ.get(
          "STUDIO_SDK_BEARER_TOKEN"
      ),  # This is the default and can be omitted
      
      environment="sandbox",
  )


  async def main() -> None:
      entity = await client.entities.retrieve(
          "<your_entity_id>",
      )
      print(entity.entity_id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `studio_sdk.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `studio_sdk.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `studio_sdk.APIError`.

  ```python
  import studio_sdk
  from studio_sdk import StudioSDK

  client = StudioSDK()

  try:
      client.entities.retrieve(
          "<your_entity_id>",
      )
  except studio_sdk.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except studio_sdk.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except studio_sdk.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from studio_sdk import StudioSDK


  client = StudioSDK(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).entities.retrieve(
      "<your_entity_id>",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from studio_sdk import StudioSDK


  client = StudioSDK(
      
      timeout=20.0,
  )


  client = StudioSDK(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).entities.retrieve(
      "<your_entity_id>",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/clear-street/studio-sdk-python/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `STUDIO_SDK_LOG` to `info`.

  ```shell
  $ export STUDIO_SDK_LOG=info
  ```

  Or to `debug` for more verbose logging.



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from studio_sdk import StudioSDK

  client = StudioSDK()
  response = client.entities.with_raw_response.retrieve(
      "<your_entity_id>",
  )
  print(response.headers.get('X-My-Header'))

  entity = response.parse()  # get the object that `entities.retrieve()` would have returned
  print(entity.entity_id)
  ```

  These methods return an [`APIResponse`](https://github.com/clear-street/studio-sdk-python/tree/main/src/studio_sdk/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/clear-street/studio-sdk-python/tree/main/src/studio_sdk/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.entities.with_streaming_response.retrieve(
      "<your_entity_id>",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from studio_sdk import StudioSDK, DefaultHttpxClient

  client = StudioSDK(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/clear-street/studio-sdk-python/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import studio_sdk
  print(studio_sdk.__version__)
  ```



  Python 3.8 or higher.



  See [the contributing documentation](https://github.com/clear-street/studio-sdk-python/tree/main/./CONTRIBUTING.md).


pkgId: 182545307c336acb696fb345ff57443c8303187807ea9c6a09fb754cefcd88eb
name: python-clearedge
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://pypi.org/project/clearedge/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clearedge-0.1.17-1.src.rpm
checksum_type: sha256
description:
  Clearedge is a Python package designed to simplify the process of extracting raw text and metadata from documents. You can use it to retrieve not only the text but also valuable metadata including titles, subheadings, page numbers, file names, bounding box (bbox) coordinates, and chunk types. Whether you're working on document analysis, data extraction projects, or building a RAG app with LLM, Clearedge provides a straightforward and efficient solution.



  - Text Extraction: Extract raw text from documents (currently supports pdf only. other file types coming soon).
  - Metadata Retrieval: Obtain metadata such as subheadings, page numbers, file names, bounding boxes and more.
  - Bounding Box Coordinates: Access bbox coordinates for text chunks, enabling spatial analysis of text placement within documents.
  - Chunk Type Identification: Identify types of text chunks (e.g., table, text and more) for advanced content analysis.
  - Support for Multiple Formats (coming soon): Compatible with popular document formats, ensuring broad usability.





  To install clearedge, you will need Python 3.8 or later.

  Since we use Tesseract, you will need extra dependencies.

  For MacOS users, you need to run:
  ```shell
  brew install tesseract
  ```

  For ubuntu users, you need to run:
  ```shell
  sudo apt install tesseract-ocr
  ```



  You can then install the latest release of the package using [pypi](https://pypi.org/project/clearedge/) as follows:

  ```bash
  pip install clearedge
  ```



  Here's a simple example to get you started with clearedge:

  ```python
  from clearedge.reader.pdf import process_pdf


  chunks = process_pdf('/path/to/your/document.pdf', use_ocr=True) # do not add use_ocr for faster processing. output is less accurate without ocr.


  for chunk in chunks:
      text, metadata = chunk.text, chunk.metadata
      print(text) # Accessing extracted text
      print(metadata.to_dict()) # Accessing metadata
  ```



  For more detailed information on all the features and functionalities of Clearedge, please refer to the official documentation (coming soon).



  Contributions to Clearedge are welcome! If you have suggestions for improvements or bug fixes, please feel free to:
  Open an issue to discuss what you would like to change.
  Submit pull requests for us to review.



  If you wish to cite this project, feel free to use this [BibTeX](http://www.bibtex.org/) reference:

  ```bibtex
  @misc{clearedge2024,
      title={clearedge: RAG preprocessor},
      author={Clearedge AI},
      year={2024},
      publisher = {GitHub},
      howpublished = {\url{https://github.com/Clearedge-AI/clearedge}}
  }
  ```



  Clearedge is released under the Apache 2.0 License. See the [`LICENSE`](https://github.com/Clearedge-AI/clearedge?tab=Apache-2.0-1-ov-file#readme) file for more details.



  This project was inspired by the need for a simple, yet comprehensive tool for document analysis and metadata extraction. We thank all contributors and users for their support and feedback. Clearedge aims to be a valuable tool for developers, researchers, and anyone involved in processing and analyzing document content. We hope it simplifies your projects and helps you achieve your goals more efficiently.


pkgId: 8bec6a1543a73a846c2dace01ae5cbcdf0a9d0fd341ca563792bb32f001bdcef
name: python-cleip
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: Cleip Python SDK
url: https://cleip.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleip-0.0.1-1.src.rpm
checksum_type: sha256
description:
  The official Python SDK for Cleip - a powerful data management and analytics platform.



  You can install the Cleip Python SDK using pip:


pkgId: 9b31c840a8fe9a179435195db89ee0f0236bd6b69c83122b86e6c974a4beb849
name: python-clelandlab-quick
arch: src
version: 0.3.3
epoch: 0
release: 1
summary: QuICK is a useful wrap of QICK.
url: https://github.com/clelandlab/quick
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clelandlab-quick-0.3.3-1.src.rpm
checksum_type: sha256
description:
  QuICK is a useful wrap of [QICK](https://github.com/openquantumhardware/qick).

  <div>
    <a style="margin: 0.25rem;" href="https://clelandlab-quick.readthedocs.io/en/latest/"><img src="https://img.shields.io/readthedocs/clelandlab-quick?style=for-the-badge&logo=readthedocs&logoColor=white"></a>
    <a style="margin: 0.25rem;" href="https://pypi.org/project/clelandlab-quick/"><img src="https://img.shields.io/pypi/v/clelandlab-quick?style=for-the-badge&logo=pypi&logoColor=white"></a>
    <a style="margin: 0.25rem;" href="https://github.com/clelandlab/quick"><img src="https://img.shields.io/github/stars/clelandlab/quick?style=for-the-badge&logo=github"></a>
  </div>



  QuICK has several layers of complexity.

  - `quick.auto` Automation of Qubit Measurements
  - `quick.experiment` Experiment Routines for Qubit Measurements
  - `quick.Mercator` Mercator Protocol for Pulse Sequence Program
  - `qick` the QICK firmware

  ![](https://clelandlab-quick.readthedocs.io/en/latest/Images/overview.png)


pkgId: 1d28b57d2e7a126b77e4c65ad3a387dd6910e8dca0dbbe48a4225a330721ea2b
name: python-cleo
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Cleo allows you to create beautiful and testable command-line interfaces.
url: https://github.com/python-poetry/cleo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleo-2.1.0-1.src.rpm
checksum_type: sha256
description:
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)](https://python-poetry.org/)
  [![Tests](https://github.com/python-poetry/cleo/actions/workflows/tests.yml/badge.svg)](https://github.com/python-poetry/cleo/actions/workflows/tests.yml)
  [![PyPI version](https://img.shields.io/pypi/v/cleo)](https://pypi.org/project/cleo/)

  Create beautiful and testable command-line interfaces.



  - [Documentation](http://cleo.readthedocs.io)
  - [Issue Tracker](https://github.com/python-poetry/cleo/issues)



  To make a command that greets you from the command line, create
  `greet_command.py` and add the following to it:

  ```python
  from cleo.commands.command import Command
  from cleo.helpers import argument, option

  class GreetCommand(Command):
      name = "greet"
      description = "Greets someone"
      arguments = [
          argument(
              "name",
              description="Who do you want to greet?",
              optional=True
          )
      ]
      options = [
          option(
              "yell",
              "y",
              description="If set, the task will yell in uppercase letters",
              flag=True
          )
      ]

      def handle(self):
          name = self.argument("name")

          if name:
              text = f"Hello {name}"
          else:
              text = "Hello"

          if self.option("yell"):
              text = text.upper()

          self.line(text)
  ```

  You also need to create the file `application.py` to run at the command line which
  creates an `Application` and adds commands to it:

  ```python


  from greet_command import GreetCommand

  from cleo.application import Application


  application = Application()
  application.add(GreetCommand())

  if __name__ == "__main__":
      application.run()
  ```

  Test the new command by running the following

  ```bash
  $ python application.py greet John
  ```

  This will print the following to the command line:

  ```text
  Hello John
  ```

  You can also use the `--yell` option to make everything uppercase:

  ```bash
  $ python application.py greet John --yell
  ```

  This prints:

  ```text
  HELLO JOHN
  ```




  Whenever you output text, you can surround the text with tags to color
  its output. For example:

  ```python

  self.line("<info>foo</info>")


  self.line("<comment>foo</comment>")


  self.line("<question>foo</question>")


  self.line("<error>foo</error>")
  ```

  The closing tag can be replaced by `</>`, which revokes all formatting
  options established by the last opened tag.

  It is possible to define your own styles using the `add_style()` method:

  ```python
  self.add_style("fire", fg="red", bg="yellow", options=["bold", "blink"])
  self.line("<fire>foo</fire>")
  ```

  Available foreground and background colors are: `black`, `red`, `green`,
  `yellow`, `blue`, `magenta`, `cyan` and `white`.

  And available options are: `bold`, `underscore`, `blink`, `reverse` and
  `conceal`.

  You can also set these colors and options inside the tag name:

  ```python

  self.line("<fg=green>foo</>")


  self.line("<fg=black;bg=cyan>foo</>")


  self.line("<bg=yellow;options=bold>foo</>")
  ```



  Cleo has four verbosity levels. These are defined in the `Output` class:

  | Mode                     | Meaning                            | Console option    |
  | ------------------------ | ---------------------------------- | ----------------- |
  | `Verbosity.QUIET`        | Do not output any messages         | `-q` or `--quiet` |
  | `Verbosity.NORMAL`       | The default verbosity level        | (none)            |
  | `Verbosity.VERBOSE`      | Increased verbosity of messages    | `-v`              |
  | `Verbosity.VERY_VERBOSE` | Informative non essential messages | `-vv`             |
  | `Verbosity.DEBUG`        | Debug messages                     | `-vvv`            |

  It is possible to print a message in a command for only a specific
  verbosity level. For example:

  ```python
  if Verbosity.VERBOSE <= self.io.verbosity:
      self.line(...)
  ```

  There are also more semantic methods you can use to test for each of the
  verbosity levels:

  ```python
  if self.output.is_quiet():
      

  if self.output.is_verbose():
      
  ```

  You can also pass the verbosity flag directly to `line()`.

  ```python
  self.line("", verbosity=Verbosity.VERBOSE)
  ```

  When the quiet level is used, all output is suppressed.



  The most interesting part of the commands are the arguments and options
  that you can make available. Arguments are the strings - separated by
  spaces - that come after the command name itself. They are ordered, and
  can be optional or required. For example, add an optional `last_name`
  argument to the command and make the `name` argument required:

  ```python
  class GreetCommand(Command):
      name = "greet"
      description = "Greets someone"
      arguments = [
          argument(
              "name",
              description="Who do you want to greet?",
          ),
          argument(
              "last_name",
              description="Your last name?",
              optional=True
          )
      ]
      options = [
          option(
              "yell",
              "y",
              description="If set, the task will yell in uppercase letters",
              flag=True
          )
      ]
  ```

  You now have access to a `last_name` argument in your command:

  ```python
  last_name = self.argument("last_name")
  if last_name:
      text += f" {last_name}"
  ```

  The command can now be used in either of the following ways:

  ```bash
  $ python application.py greet John
  $ python application.py greet John Doe
  ```

  It is also possible to let an argument take a list of values (imagine
  you want to greet all your friends). For this it must be specified at
  the end of the argument list:

  ```python
  class GreetCommand(Command):
      name = "greet"
      description = "Greets someone"
      arguments = [
          argument(
              "names",
              description="Who do you want to greet?",
              multiple=True
          )
      ]
      options = [
          option(
              "yell",
              "y",
              description="If set, the task will yell in uppercase letters",
              flag=True
          )
      ]
  ```

  To use this, just specify as many names as you want:

  ```bash
  $ python application.py greet John Jane
  ```

  You can access the `names` argument as a list:

  ```python
  names = self.argument("names")
  if names:
      text = "Hello " + ", ".join(names)
  ```




  Unlike arguments, options are not ordered (meaning you can specify them
  in any order) and are specified with two dashes (e.g. `--yell` - you can
  also declare a one-letter shortcut that you can call with a single dash
  like `-y`). Options are _always_ optional, and can be setup to accept a
  value (e.g. `--dir=src`) or simply as a boolean flag without a value
  (e.g. `--yell`).

  > _Tip_: It is also possible to make an option _optionally_ accept a value (so
  > that `--yell` or `--yell=loud` work). Options can also be configured to
  > accept a list of values.

  For example, add a new option to the command that can be used to specify
  how many times in a row the message should be printed:

  ```python
  class GreetCommand(Command):
      name = "greet"
      description = "Greets someone"
      arguments = [
          argument(
              "name",
              description="Who do you want to greet?",
              optional=True
          )
      ]
      options = [
          option(
              "yell",
              "y",
              description="If set, the task will yell in uppercase letters",
              flag=True
          ),
          option(
              "iterations",
              description="How many times should the message be printed?",
              default=1
          )
      ]
  ```

  Next, use this in the command to print the message multiple times:

  ```python
  for _ in range(int(self.option("iterations"))):
      self.line(text)
  ```

  Now, when you run the task, you can optionally specify a `--iterations`
  flag:

  ```bash
  $ python application.py greet John
  $ python application.py greet John --iterations=5
  ```

  The first example will only print once, since `iterations` is empty and
  defaults to `1`. The second example will print five times.

  Recall that options don\'t care about their order. So, either of the
  following will work:

  ```bash
  $ python application.py greet John --iterations=5 --yell
  $ python application.py greet John --yell --iterations=5
  ```




  Cleo provides several tools to help you test your commands. The most
  useful one is the `CommandTester` class. It uses a special IO class to
  ease testing without a real console:

  ```python
  from greet_command import GreetCommand

  from cleo.application import Application
  from cleo.testers.command_tester import CommandTester


  def test_execute():
      application = Application()
      application.add(GreetCommand())

      command = application.find("greet")
      command_tester = CommandTester(command)
      command_tester.execute()

      assert "..." == command_tester.io.fetch_output()
  ```

  The `CommandTester.io.fetch_output()` method returns what would have
  been displayed during a normal call from the console.
  `CommandTester.io.fetch_error()` is also available to get what you have
  been written to the stderr.

  You can test sending arguments and options to the command by passing
  them as a string to the `CommandTester.execute()` method:

  ```python
  from greet_command import GreetCommand

  from cleo.application import Application
  from cleo.testers.command_tester import CommandTester


  def test_execute():
      application = Application()
      application.add(GreetCommand())

      command = application.find("greet")
      command_tester = CommandTester(command)
      command_tester.execute("John")

      assert "John" in command_tester.io.fetch_output()
  ```

  You can also test a whole console application by using the
  `ApplicationTester` class.



  If a command depends on another one being run before it, instead of
  asking the user to remember the order of execution, you can call it
  directly yourself. This is also useful if you want to create a \"meta\"
  command that just runs a bunch of other commands.

  Calling a command from another one is straightforward:

  ```python
  def handle(self):
      return_code = self.call("greet", "John --yell")
      return return_code
  ```

  If you want to suppress the output of the executed command, you can use
  the `call_silent()` method instead.



  Cleo supports automatic (tab) completion in `bash`, `zsh` and `fish`.

  By default, your application will have a `completions` command. To register these completions for your application, run one of the following in a terminal (replacing `[program]` with the command you use to run your application):

  ```bash

  [program] completions bash | sudo tee /etc/bash_completion.d/[program].bash-completion


  [program] completions bash > $(brew --prefix)/etc/bash_completion.d/[program].bash-completion


  mkdir ~/.zfunc
  echo "fpath+=~/.zfunc" >> ~/.zshrc
  [program] completions zsh > ~/.zfunc/_[program]


  [program] completions zsh > $(brew --prefix)/share/zsh/site-functions/_[program]


  [program] completions fish > ~/.config/fish/completions/[program].fish
  ```


pkgId: b1b65dc3e7e3c6cbe3795e13f317e9fba6de74a076ff6bbe703f6994f5b2250a
name: python-cleosim
arch: src
version: 0.16.0
epoch: 0
release: 1
summary: Cleo: the Closed-Loop, Electrophysiology, and Optogenetics experiment simulation testbed
url: https://cleosim.readthedocs.io
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleosim-0.16.0-1.src.rpm
checksum_type: sha256
description:
  <h1 style="font-size: 1em;">Cleo: the Closed-Loop, Electrophysiology, and Optophysiology experiment simulation testbed
  </h1>

  [![Tests](https://github.com/kjohnsen/cleosim/actions/workflows/test.yml/badge.svg)](https://github.com/kjohnsen/cleosim/actions/workflows/test.yml)
  [![Documentation Status](https://readthedocs.org/projects/cleosim/badge/?version=latest)](https://cleosim.readthedocs.io/latest/?badge=latest)
  [![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)
  [![DOI](https://zenodo.org/badge/262130097.svg)](https://zenodo.org/doi/10.5281/zenodo.7036270)


  <h1>
  <p align="center">
    <img
        style="display: block;
               width: 50%;"
        src="https://user-images.githubusercontent.com/19983357/187561700-100b853a-d226-4039-a580-1d798b00f9e4.png"
        alt="Cleo: the Closed-Loop, Electrophysiology, and Optophysiology experiment simulation testbed">
    </img>
  </p>
  </h1>


  Hello there!
  Cleo has the goal of bridging theory and experiment for mesoscale neuroscience, facilitating electrode recording, optogenetic stimulation, and closed-loop experiments (e.g., real-time input and output processing) with the [Brian 2](https://brian2.readthedocs.io/en/stable/) spiking neural network simulator.
  We hope users will find these components useful for prototyping experiments, innovating methods, and testing observations about a hypotheses *in silico*, incorporating into spiking neural network models laboratory techniques ranging from passive observation to complex model-based feedback control.
  Cleo also serves as an extensible, modular base for developing additional recording and stimulation modules for Brian simulations.

  This package was developed by [Kyle Johnsen](https://kjohnsen.org) and Nathan Cruzado under the direction of [Chris Rozell](https://siplab.gatech.edu) at Georgia Institute of Technology.
  See the preprint [here](https://www.biorxiv.org/content/10.1101/2023.01.27.525963).

  <p align="center">
    <img
        style="display: block;
               width: 90%;"
        src="https://raw.githubusercontent.com/siplab-gt/cleo/master/docs/_static/cleo-overview-table.png"
        alt="Overview table of Cleo's closed-loop control, ephys, and ophys features">
    </img>
  </p>


  Cleo allows for flexible I/O processing in real time, enabling the simulation of closed-loop experiments such as event-triggered or feedback control.
  The user can also add latency to the stimulation to study the effects of computation delays.



  Cleo provides functions for configuring electrode arrays and placing them in arbitrary locations in the simulation.
  The user can then specify parameters for probabilistic spike detection or a spike-based LFP approximation developed by [Teleńczuk et al., 2020](https://www.sciencedirect.com/science/article/pii/S0165027020302946).


  By modeling light propagation and opsins, Cleo enables users to flexibly add photostimulation to their model.
  Both a four-state Markov state model of opsin kinetics is available, as well as a minimal proportional current option for compatibility with simple neuron models.
  Cleo also accounts for opsin action spectra to model the effects of multi-light/wavelength/opsin crosstalk and heterogeneous expression.
  Parameters are for multiple opsins, and blue optic fiber (1P) and infrared spot (for 2P) illumination.



  Users can also inject a microscope into their model, selecting neurons on the specified plane of imaging or elsewhere, with signal and noise strength determined by indicator expression levels and position with respect to the focal plane.
  The calcium indicator model of [Song et al., 2021](https://www.sciencedirect.com/science/article/pii/S0165027021001084) is implemented, with parameters included for GCaMP6 variants.


  Just use pip to install&mdash;the name on PyPI is `cleosim`:
  ```bash
  pip install cleosim
  ```

  Then head to the [overview section of the documentation](https://cleosim.readthedocs.io/latest/overview.html) for a more detailed discussion of motivation, structure, and basic usage.


  Those using Cleo to simulate closed-loop control experiments may be interested in software developed for the execution of real-time, *in-vivo* experiments.
  Developed by members of [Chris Rozell](https://siplab.gatech.edu)'s and [Garrett Stanley](https://stanley.gatech.edu/)'s labs at Georgia Tech, the [CLOCTools repository](https://cloctools.github.io) can serve these users in two ways:

  1. By providing utilities and interfaces with experimental platforms for moving from simulation to reality.
  2. By providing performant control and estimation algorithms for feedback control.
  Although Cleo enables closed-loop manipulation of network simulations, it does not include any advanced control algorithms itself.
  The `ldsCtrlEst` library implements adaptive linear dynamical system-based control while the `hmm` library can generate and decode systems with discrete latent states and observations.

  <p align="center">
    <img
        style="display: block;
               width: 100%;"
        src="https://raw.githubusercontent.com/siplab-gt/cleo/master/docs/_static/cloctools_and_cleo.png"
        alt="CLOCTools and Cleo">
    </img>
  </p>


  [**Cleo: A testbed for bridging model and experiment by simulating closed-loop stimulation, electrode recording, and optophysiology**](https://www.biorxiv.org/content/10.1101/2023.01.27.525963)<br>
  K.A. Johnsen, N.A. Cruzado, Z.C. Menard, A.A. Willats, A.S. Charles, and C.J. Rozell. *bioRxiv*, 2023.

  [**CLOC Tools: A Library of Tools for Closed-Loop Neuroscience**](https://github.com/cloctools/tools-for-neuro-control-manuscript)<br>
  A.A. Willats, M.F. Bolus, K.A. Johnsen, G.B. Stanley, and C.J. Rozell. *In prep*, 2023.

  [**State-Aware Control of Switching Neural Dynamics**](https://github.com/awillats/state-aware-control)<br>
  A.A. Willats, M.F. Bolus, C.J. Whitmire, G.B. Stanley, and C.J. Rozell. *In prep*, 2023.

  [**Closed-Loop Identifiability in Neural Circuits**](https://github.com/awillats/clinc)<br>
  A. Willats, M. O'Shaughnessy, and C. Rozell. *In prep*, 2023.

  [**State-space optimal feedback control of optogenetically driven neural activity**](https://www.biorxiv.org/content/10.1101/2020.06.25.171785v2)<br>
  M.F. Bolus, A.A. Willats, C.J. Rozell and G.B. Stanley. *Journal of Neural Engineering*, 18(3), pp. 036006, March 2021.

  [**Design strategies for dynamic closed-loop optogenetic neurocontrol in vivo**](https://iopscience.iop.org/article/10.1088/1741-2552/aaa506)<br>
  M.F. Bolus, A.A. Willats, C.J. Whitmire, C.J. Rozell and G.B. Stanley. *Journal of Neural Engineering*, 15(2), pp. 026011, January 2018.


pkgId: 63486d3ff98fa6124b7948e1aaa4f1ea54e04000119f4c2afbd0dc585e03ddc8
name: python-clerk-backend-api
arch: src
version: 1.3.0
epoch: 0
release: 1
summary: Python Client SDK for clerk.dev
url: https://github.com/clerk/clerk-sdk-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clerk-backend-api-1.3.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <a href="https://clerk.com?utm_source=github&utm_medium=clerk_javascript" target="_blank" rel="noopener noreferrer">
      <picture>
        <source media="(prefers-color-scheme: dark)" srcset="https://images.clerk.com/static/logo-dark-mode-400x400.png">
        <img src="https://images.clerk.com/static/logo-light-mode-400x400.png" height="100">
      </picture>
    </a>
     <p>The most comprehensive User Management Platform</p>
     <a href="https://clerk.com/docs/reference/backend-api"><img src="https://img.shields.io/static/v1?label=Docs&message=API Ref&color=000000&style=for-the-badge" /></a>
    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" /></a>
  </div>
  <br></br>

  [![chat on Discord](https://img.shields.io/discord/856971667393609759.svg?logo=discord)](https://clerk.com/discord)
  [![twitter](https://img.shields.io/twitter/follow/ClerkDev?style=social)](https://twitter.com/intent/follow?screen_name=ClerkDev)

  <!-- Start Summary [summary] -->


  Clerk Backend API: The Clerk REST Backend API, meant to be accessed by backend
  servers.



  When the API changes in a way that isn't compatible with older versions, a new version is released.
  Each version is identified by its release date, e.g. `2021-02-05`. For more information, please see [Clerk API Versions](https://clerk.com/docs/backend-requests/versioning/overview).


  Please see https://clerk.com/docs for more information.

  More information about the API can be found at https://clerk.com/docs
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->


  * [SDK Installation](https://github.com/clerk/clerk-sdk-python/blob/master/#sdk-installation)
  * [IDE Support](https://github.com/clerk/clerk-sdk-python/blob/master/#ide-support)
  * [SDK Example Usage](https://github.com/clerk/clerk-sdk-python/blob/master/#sdk-example-usage)
  * [Available Resources and Operations](https://github.com/clerk/clerk-sdk-python/blob/master/#available-resources-and-operations)
  * [File uploads](https://github.com/clerk/clerk-sdk-python/blob/master/#file-uploads)
  * [Retries](https://github.com/clerk/clerk-sdk-python/blob/master/#retries)
  * [Error Handling](https://github.com/clerk/clerk-sdk-python/blob/master/#error-handling)
  * [Server Selection](https://github.com/clerk/clerk-sdk-python/blob/master/#server-selection)
  * [Custom HTTP Client](https://github.com/clerk/clerk-sdk-python/blob/master/#custom-http-client)
  * [Authentication](https://github.com/clerk/clerk-sdk-python/blob/master/#authentication)
  * [Debugging](https://github.com/clerk/clerk-sdk-python/blob/master/#debugging)
  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install clerk-backend-api
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add clerk-backend-api
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from clerk_backend_api import Clerk

  s = Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )

  res = s.email_addresses.get(email_address_id="email_address_id_example")

  if res is not None:
      
      pass
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from clerk_backend_api import Clerk

  async def main():
      s = Clerk(
          bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
      )
      res = await s.email_addresses.get_async(email_address_id="email_address_id_example")
      if res is not None:
          
          pass

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/actortokens/README.md#create) - Create actor token
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/actortokens/README.md#revoke) - Revoke actor token



  * [list_allowlist_identifiers](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#list_allowlist_identifiers) - List all identifiers on the allow-list
  * [create_allowlist_identifier](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#create_allowlist_identifier) - Add identifier to the allow-list
  * [create_blocklist_identifier](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#create_blocklist_identifier) - Add identifier to the block-list
  * [delete_blocklist_identifier](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#delete_blocklist_identifier) - Delete identifier from block-list



  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistidentifiers/README.md#delete) - Delete identifier from allow-list



  * [update_instance_settings](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/betafeatures/README.md#update_instance_settings) - Update instance settings
  * [~~update_domain~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/betafeatures/README.md#update_domain) - Update production instance domain :warning: **Deprecated**
  * [change_production_instance_domain](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/betafeatures/README.md#change_production_instance_domain) - Update production instance domain



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/blocklistidentifierssdk/README.md#list) - List all identifiers on the block-list




  * [~~list~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clients/README.md#list) - List all clients :warning: **Deprecated**
  * [verify](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clients/README.md#verify) - Verify a client
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clients/README.md#get) - Get a client



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#list) - List all instance domains
  * [add](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#add) - Add a domain
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#delete) - Delete a satellite domain
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#update) - Update a domain



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#create) - Create an email address
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#get) - Retrieve an email address
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#delete) - Delete an email address
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#update) - Update an email address



  * [~~upsert~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailandsmstemplates/README.md#upsert) - Update a template for a given type and slug :warning: **Deprecated**



  * [~~list~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#list) - List all templates :warning: **Deprecated**
  * [~~revert~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#revert) - Revert a template :warning: **Deprecated**
  * [~~get~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#get) - Retrieve a template :warning: **Deprecated**
  * [~~toggle_template_delivery~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#toggle_template_delivery) - Toggle the delivery by Clerk for a template of a given type and slug :warning: **Deprecated**



  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/instancesettingssdk/README.md#update) - Update instance settings
  * [update_restrictions](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/instancesettingssdk/README.md#update_restrictions) - Update instance restrictions
  * [update_organization_settings](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/instancesettingssdk/README.md#update_organization_settings) - Update instance organization settings



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/invitations/README.md#create) - Create an invitation
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/invitations/README.md#list) - List all invitations
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/invitations/README.md#revoke) - Revokes an invitation



  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwks/README.md#get) - Retrieve the JSON Web Key Set of the instance



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#list) - List all templates
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#create) - Create a JWT template
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#get) - Retrieve a template
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#update) - Update a JWT template
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#delete) - Delete a Template



  * [get_interstitial](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/miscellaneous/README.md#get_interstitial) - Returns the markup for the interstitial page



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#list) - Get a list of OAuth applications for an instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#create) - Create an OAuth application
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#get) - Retrieve an OAuth application by ID
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#update) - Update an OAuth application
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#delete) - Delete an OAuth application
  * [rotate_secret](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#rotate_secret) - Rotate the client secret of the given OAuth application



  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainsdk/README.md#update) - Update an organization domain.



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainssdk/README.md#create) - Create a new organization domain.
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainssdk/README.md#list) - Get a list of all domains of an organization.
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainssdk/README.md#delete) - Remove a domain from an organization.



  * [get_all](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#get_all) - Get a list of organization invitations for the current instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#create) - Create and send an organization invitation
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#list) - Get a list of organization invitations
  * [bulk_create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#bulk_create) - Bulk create and send organization invitations
  * [~~list_pending~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#list_pending) - Get a list of pending organization invitations :warning: **Deprecated**
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#get) - Retrieve an organization invitation by ID
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#revoke) - Revoke a pending organization invitation



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#create) - Create a new organization membership
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#list) - Get a list of all members of an organization
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#update) - Update an organization membership
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#delete) - Remove a member from an organization
  * [update_metadata](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#update_metadata) - Merge and update organization membership metadata
  * [get_all](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#get_all) - Get a list of all organization memberships within an instance.



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#list) - Get a list of organizations for an instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#create) - Create an organization
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#get) - Retrieve an organization by ID or slug
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#update) - Update an organization
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#delete) - Delete an organization
  * [merge_metadata](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#merge_metadata) - Merge and update metadata for an organization
  * [upload_logo](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#upload_logo) - Upload a logo for the organization
  * [delete_logo](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#delete_logo) - Delete the organization's logo.



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#create) - Create a phone number
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#get) - Retrieve a phone number
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#delete) - Delete a phone number
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#update) - Update a phone number



  * [verify](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/proxychecks/README.md#verify) - Verify the proxy configuration for your domain



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/redirecturls/README.md#list) - List all redirect URLs



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clerkredirecturls/README.md#create) - Create a redirect URL
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clerkredirecturls/README.md#get) - Retrieve a redirect URL
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clerkredirecturls/README.md#delete) - Delete a redirect URL



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#list) - Get a list of SAML Connections for an instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#create) - Create a SAML Connection
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#get) - Retrieve a SAML Connection by ID
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#update) - Update a SAML Connection
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#delete) - Delete a SAML Connection



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#list) - List all sessions
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#get) - Retrieve a session
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#revoke) - Revoke a session
  * [~~verify~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#verify) - Verify a session :warning: **Deprecated**
  * [create_token_from_template](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#create_token_from_template) - Create a session token from a jwt template



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/signintokens/README.md#create) - Create sign-in token
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/signintokens/README.md#revoke) - Revoke the given sign-in token



  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/signups/README.md#update) - Update a sign-up



  * [~~preview~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/templates/README.md#preview) - Preview changes to a template :warning: **Deprecated**



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/testingtokens/README.md#create) - Retrieve a new testing token



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#list) - List all users
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#create) - Create a new user
  * [count](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#count) - Count users
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get) - Retrieve a user
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#update) - Update a user
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete) - Delete a user
  * [ban](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#ban) - Ban a user
  * [unban](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#unban) - Unban a user
  * [lock](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#lock) - Lock a user
  * [unlock](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#unlock) - Unlock a user
  * [set_profile_image](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#set_profile_image) - Set user profile image
  * [delete_profile_image](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_profile_image) - Delete user profile image
  * [update_metadata](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#update_metadata) - Merge and update a user's metadata
  * [get_o_auth_access_token](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get_o_auth_access_token) - Retrieve the OAuth access token of a user
  * [get_organization_memberships](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get_organization_memberships) - Retrieve all memberships for a user
  * [get_organization_invitations](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get_organization_invitations) - Retrieve all invitations for a user
  * [verify_password](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#verify_password) - Verify the password of a user
  * [verify_totp](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#verify_totp) - Verify a TOTP or backup code for a user
  * [disable_mfa](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#disable_mfa) - Disable a user's MFA methods
  * [delete_backup_codes](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_backup_codes) - Disable all user's Backup codes
  * [delete_passkey](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_passkey) - Delete a user passkey
  * [delete_web3_wallet](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_web3_wallet) - Delete a user web3 wallet
  * [create_totp](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#create_totp) - Create a TOTP for a user
  * [delete_totp](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_totp) - Delete all the user's TOTPs
  * [delete_external_account](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_external_account) - Delete External Account



  * [create_svix_app](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/webhooks/README.md#create_svix_app) - Create a Svix app
  * [delete_svix_app](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/webhooks/README.md#delete_svix_app) - Delete a Svix app
  * [generate_svix_auth_url](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/webhooks/README.md#generate_svix_auth_url) - Create a Svix Dashboard URL

  </details>
  <!-- End Available Resources and Operations [operations] -->

  <!-- Start File uploads [file-upload] -->


  Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.

  > [!TIP]
  >
  > For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.
  >

  ```python
  from clerk_backend_api import Clerk

  s = Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )

  res = s.users.set_profile_image(user_id="usr_test123", file={
      "file_name": "example.file",
      "content": open("example.file", "rb"),
      "content_type": "<value>",
  })

  if res is not None:
      
      pass

  ```
  <!-- End File uploads [file-upload] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from clerk.utils import BackoffStrategy, RetryConfig
  from clerk_backend_api import Clerk

  s = Clerk()

  s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d",
      RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))



  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from clerk.utils import BackoffStrategy, RetryConfig
  from clerk_backend_api import Clerk

  s = Clerk(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
  )

  s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d")



  ```
  <!-- End Retries [retries] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a models.SDKError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `verify_async` method may raise the following exceptions:

  | Error Type         | Status Code   | Content Type     |
  | ------------------ | ------------- | ---------------- |
  | models.ClerkErrors | 400, 401, 404 | application/json |
  | models.SDKError    | 4XX, 5XX      | \*/\*            |



  ```python
  from clerk_backend_api import Clerk, models

  s = Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )

  res = None
  try:
      res = s.clients.verify(request={
          "token": "jwt_token_example",
      })

      if res is not None:
          
          pass

  except models.ClerkErrors as e:
      
      raise(e)
  except models.SDKError as e:
      
      raise(e)
  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from clerk_backend_api import Clerk

  s = Clerk(
      server_url="https://api.clerk.com/v1",
  )

  s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d")



  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from clerk_backend_api import Clerk
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = Clerk(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from clerk_backend_api import Clerk
  from clerk_backend_api.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = Clerk(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name          | Type | Scheme      |
  | ------------- | ---- | ----------- |
  | `bearer_auth` | http | HTTP Bearer |

  To authenticate with the API the `bearer_auth` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from clerk_backend_api import Clerk

  s = Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  )

  s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d")



  ```
  <!-- End Authentication [security] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from clerk_backend_api import Clerk
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = Clerk(debug_logger=logging.getLogger("clerk_backend_api"))
  ```
  <!-- End Debugging [debug] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation.
  We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.


pkgId: 094be4c95cff6436d44ee8b58d33a2a0eeb704e0f330afa961f5a56f66658f85
name: python-clerk-backend-api
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: Python Client SDK for clerk.dev
url: https://github.com/clerk/clerk-sdk-python.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clerk-backend-api-1.4.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <a href="https://clerk.com?utm_source=github&utm_medium=clerk_javascript" target="_blank" rel="noopener noreferrer">
      <picture>
        <source media="(prefers-color-scheme: dark)" srcset="https://images.clerk.com/static/logo-dark-mode-400x400.png">
        <img src="https://images.clerk.com/static/logo-light-mode-400x400.png" height="100">
      </picture>
    </a>
     <p>The most comprehensive User Management Platform</p>
     <a href="https://clerk.com/docs/reference/backend-api"><img src="https://img.shields.io/static/v1?label=Docs&message=API Ref&color=000000&style=for-the-badge" /></a>
    <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" /></a>
  </div>
  <br></br>

  [![chat on Discord](https://img.shields.io/discord/856971667393609759.svg?logo=discord)](https://clerk.com/discord)
  [![twitter](https://img.shields.io/twitter/follow/ClerkDev?style=social)](https://twitter.com/intent/follow?screen_name=ClerkDev)

  <!-- Start Summary [summary] -->


  Clerk Backend API: The Clerk REST Backend API, meant to be accessed by backend
  servers.



  When the API changes in a way that isn't compatible with older versions, a new version is released.
  Each version is identified by its release date, e.g. `2021-02-05`. For more information, please see [Clerk API Versions](https://clerk.com/docs/backend-requests/versioning/overview).


  Please see https://clerk.com/docs for more information.

  More information about the API can be found at https://clerk.com/docs
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->


  * [SDK Installation](https://github.com/clerk/clerk-sdk-python/blob/master/#sdk-installation)
  * [IDE Support](https://github.com/clerk/clerk-sdk-python/blob/master/#ide-support)
  * [SDK Example Usage](https://github.com/clerk/clerk-sdk-python/blob/master/#sdk-example-usage)
  * [Available Resources and Operations](https://github.com/clerk/clerk-sdk-python/blob/master/#available-resources-and-operations)
  * [File uploads](https://github.com/clerk/clerk-sdk-python/blob/master/#file-uploads)
  * [Retries](https://github.com/clerk/clerk-sdk-python/blob/master/#retries)
  * [Error Handling](https://github.com/clerk/clerk-sdk-python/blob/master/#error-handling)
  * [Server Selection](https://github.com/clerk/clerk-sdk-python/blob/master/#server-selection)
  * [Custom HTTP Client](https://github.com/clerk/clerk-sdk-python/blob/master/#custom-http-client)
  * [Authentication](https://github.com/clerk/clerk-sdk-python/blob/master/#authentication)
  * [Debugging](https://github.com/clerk/clerk-sdk-python/blob/master/#debugging)
  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install clerk-backend-api
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add clerk-backend-api
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from clerk_backend_api import Clerk

  with Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as s:
      res = s.email_addresses.get(email_address_id="email_address_id_example")

      if res is not None:
          
          pass
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from clerk_backend_api import Clerk

  async def main():
      async with Clerk(
          bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
      ) as s:
          res = await s.email_addresses.get_async(email_address_id="email_address_id_example")

          if res is not None:
              
              pass

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/actortokens/README.md#create) - Create actor token
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/actortokens/README.md#revoke) - Revoke actor token



  * [list_allowlist_identifiers](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#list_allowlist_identifiers) - List all identifiers on the allow-list
  * [create_allowlist_identifier](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#create_allowlist_identifier) - Add identifier to the allow-list
  * [create_blocklist_identifier](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#create_blocklist_identifier) - Add identifier to the block-list
  * [delete_blocklist_identifier](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistblocklist/README.md#delete_blocklist_identifier) - Delete identifier from block-list



  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/allowlistidentifiers/README.md#delete) - Delete identifier from allow-list



  * [update_instance_settings](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/betafeatures/README.md#update_instance_settings) - Update instance settings
  * [~~update_domain~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/betafeatures/README.md#update_domain) - Update production instance domain :warning: **Deprecated**
  * [change_production_instance_domain](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/betafeatures/README.md#change_production_instance_domain) - Update production instance domain



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/blocklistidentifierssdk/README.md#list) - List all identifiers on the block-list




  * [~~list~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clients/README.md#list) - List all clients :warning: **Deprecated**
  * [verify](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clients/README.md#verify) - Verify a client
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clients/README.md#get) - Get a client



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#list) - List all instance domains
  * [add](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#add) - Add a domain
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#delete) - Delete a satellite domain
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/domainssdk/README.md#update) - Update a domain



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#create) - Create an email address
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#get) - Retrieve an email address
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#delete) - Delete an email address
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailaddresses/README.md#update) - Update an email address



  * [~~upsert~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailandsmstemplates/README.md#upsert) - Update a template for a given type and slug :warning: **Deprecated**



  * [~~list~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#list) - List all templates :warning: **Deprecated**
  * [~~revert~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#revert) - Revert a template :warning: **Deprecated**
  * [~~get~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#get) - Retrieve a template :warning: **Deprecated**
  * [~~toggle_template_delivery~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/emailsmstemplates/README.md#toggle_template_delivery) - Toggle the delivery by Clerk for a template of a given type and slug :warning: **Deprecated**



  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/instancesettingssdk/README.md#update) - Update instance settings
  * [update_restrictions](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/instancesettingssdk/README.md#update_restrictions) - Update instance restrictions
  * [update_organization_settings](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/instancesettingssdk/README.md#update_organization_settings) - Update instance organization settings



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/invitations/README.md#create) - Create an invitation
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/invitations/README.md#list) - List all invitations
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/invitations/README.md#revoke) - Revokes an invitation



  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwks/README.md#get) - Retrieve the JSON Web Key Set of the instance



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#list) - List all templates
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#create) - Create a JWT template
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#get) - Retrieve a template
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#update) - Update a JWT template
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/jwttemplates/README.md#delete) - Delete a Template



  * [get_interstitial](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/miscellaneous/README.md#get_interstitial) - Returns the markup for the interstitial page



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#list) - Get a list of OAuth applications for an instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#create) - Create an OAuth application
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#get) - Retrieve an OAuth application by ID
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#update) - Update an OAuth application
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#delete) - Delete an OAuth application
  * [rotate_secret](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/oauthapplicationssdk/README.md#rotate_secret) - Rotate the client secret of the given OAuth application



  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainsdk/README.md#update) - Update an organization domain.



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainssdk/README.md#create) - Create a new organization domain.
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainssdk/README.md#list) - Get a list of all domains of an organization.
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationdomainssdk/README.md#delete) - Remove a domain from an organization.



  * [get_all](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#get_all) - Get a list of organization invitations for the current instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#create) - Create and send an organization invitation
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#list) - Get a list of organization invitations
  * [bulk_create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#bulk_create) - Bulk create and send organization invitations
  * [~~list_pending~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#list_pending) - Get a list of pending organization invitations :warning: **Deprecated**
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#get) - Retrieve an organization invitation by ID
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationinvitationssdk/README.md#revoke) - Revoke a pending organization invitation



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#create) - Create a new organization membership
  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#list) - Get a list of all members of an organization
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#update) - Update an organization membership
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#delete) - Remove a member from an organization
  * [update_metadata](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#update_metadata) - Merge and update organization membership metadata
  * [get_all](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationmembershipssdk/README.md#get_all) - Get a list of all organization memberships within an instance.



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#list) - Get a list of organizations for an instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#create) - Create an organization
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#get) - Retrieve an organization by ID or slug
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#update) - Update an organization
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#delete) - Delete an organization
  * [merge_metadata](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#merge_metadata) - Merge and update metadata for an organization
  * [upload_logo](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#upload_logo) - Upload a logo for the organization
  * [delete_logo](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/organizationssdk/README.md#delete_logo) - Delete the organization's logo.



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#create) - Create a phone number
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#get) - Retrieve a phone number
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#delete) - Delete a phone number
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/phonenumbers/README.md#update) - Update a phone number



  * [verify](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/proxychecks/README.md#verify) - Verify the proxy configuration for your domain



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/redirecturls/README.md#list) - List all redirect URLs



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clerkredirecturls/README.md#create) - Create a redirect URL
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clerkredirecturls/README.md#get) - Retrieve a redirect URL
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/clerkredirecturls/README.md#delete) - Delete a redirect URL



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#list) - Get a list of SAML Connections for an instance
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#create) - Create a SAML Connection
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#get) - Retrieve a SAML Connection by ID
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#update) - Update a SAML Connection
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/samlconnectionssdk/README.md#delete) - Delete a SAML Connection



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#list) - List all sessions
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#get) - Retrieve a session
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#revoke) - Revoke a session
  * [~~verify~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#verify) - Verify a session :warning: **Deprecated**
  * [create_token_from_template](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/sessions/README.md#create_token_from_template) - Create a session token from a jwt template



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/signintokens/README.md#create) - Create sign-in token
  * [revoke](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/signintokens/README.md#revoke) - Revoke the given sign-in token



  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/signups/README.md#update) - Update a sign-up



  * [~~preview~~](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/templates/README.md#preview) - Preview changes to a template :warning: **Deprecated**



  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/testingtokens/README.md#create) - Retrieve a new testing token



  * [list](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#list) - List all users
  * [create](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#create) - Create a new user
  * [count](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#count) - Count users
  * [get](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get) - Retrieve a user
  * [update](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#update) - Update a user
  * [delete](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete) - Delete a user
  * [ban](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#ban) - Ban a user
  * [unban](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#unban) - Unban a user
  * [lock](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#lock) - Lock a user
  * [unlock](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#unlock) - Unlock a user
  * [set_profile_image](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#set_profile_image) - Set user profile image
  * [delete_profile_image](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_profile_image) - Delete user profile image
  * [update_metadata](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#update_metadata) - Merge and update a user's metadata
  * [get_o_auth_access_token](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get_o_auth_access_token) - Retrieve the OAuth access token of a user
  * [get_organization_memberships](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get_organization_memberships) - Retrieve all memberships for a user
  * [get_organization_invitations](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#get_organization_invitations) - Retrieve all invitations for a user
  * [verify_password](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#verify_password) - Verify the password of a user
  * [verify_totp](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#verify_totp) - Verify a TOTP or backup code for a user
  * [disable_mfa](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#disable_mfa) - Disable a user's MFA methods
  * [delete_backup_codes](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_backup_codes) - Disable all user's Backup codes
  * [delete_passkey](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_passkey) - Delete a user passkey
  * [delete_web3_wallet](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_web3_wallet) - Delete a user web3 wallet
  * [create_totp](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#create_totp) - Create a TOTP for a user
  * [delete_totp](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_totp) - Delete all the user's TOTPs
  * [delete_external_account](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/users/README.md#delete_external_account) - Delete External Account



  * [create_svix_app](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/webhooks/README.md#create_svix_app) - Create a Svix app
  * [delete_svix_app](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/webhooks/README.md#delete_svix_app) - Delete a Svix app
  * [generate_svix_auth_url](https://github.com/clerk/clerk-sdk-python/blob/master/docs/sdks/webhooks/README.md#generate_svix_auth_url) - Create a Svix Dashboard URL

  </details>
  <!-- End Available Resources and Operations [operations] -->

  <!-- Start File uploads [file-upload] -->


  Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.

  > [!TIP]
  >
  > For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.
  >

  ```python
  from clerk_backend_api import Clerk

  with Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as s:
      res = s.users.set_profile_image(user_id="usr_test123", file={
          "file_name": "example.file",
          "content": open("example.file", "rb"),
          "content_type": "<value>",
      })

      if res is not None:
          
          pass

  ```
  <!-- End File uploads [file-upload] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from clerk.utils import BackoffStrategy, RetryConfig
  from clerk_backend_api import Clerk

  with Clerk() as s:
      s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d",
          RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

      

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from clerk.utils import BackoffStrategy, RetryConfig
  from clerk_backend_api import Clerk

  with Clerk(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
  ) as s:
      s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d")

      

  ```
  <!-- End Retries [retries] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a models.SDKError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `verify_async` method may raise the following exceptions:

  | Error Type         | Status Code   | Content Type     |
  | ------------------ | ------------- | ---------------- |
  | models.ClerkErrors | 400, 401, 404 | application/json |
  | models.SDKError    | 4XX, 5XX      | \*/\*            |



  ```python
  from clerk_backend_api import Clerk, models

  with Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as s:
      res = None
      try:
          res = s.clients.verify(request={
              "token": "jwt_token_example",
          })

          if res is not None:
              
              pass

      except models.ClerkErrors as e:
          
          raise(e)
      except models.SDKError as e:
          
          raise(e)
  ```
  <!-- End Error Handling [errors] -->

  <!-- Start Server Selection [server] -->




  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from clerk_backend_api import Clerk

  with Clerk(
      server_url="https://api.clerk.com/v1",
  ) as s:
      s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d")

      

  ```
  <!-- End Server Selection [server] -->

  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from clerk_backend_api import Clerk
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = Clerk(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from clerk_backend_api import Clerk
  from clerk_backend_api.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = Clerk(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->

  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name          | Type | Scheme      |
  | ------------- | ---- | ----------- |
  | `bearer_auth` | http | HTTP Bearer |

  To authenticate with the API the `bearer_auth` parameter must be set when initializing the SDK client instance. For example:
  ```python
  from clerk_backend_api import Clerk

  with Clerk(
      bearer_auth="<YOUR_BEARER_TOKEN_HERE>",
  ) as s:
      s.miscellaneous.get_interstitial(frontend_api="frontend-api_1a2b3c4d", publishable_key="pub_1a2b3c4d")

      

  ```
  <!-- End Authentication [security] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from clerk_backend_api import Clerk
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = Clerk(debug_logger=logging.getLogger("clerk_backend_api"))
  ```
  <!-- End Debugging [debug] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->





  This SDK is in beta, and there may be breaking changes between versions without a major version update. Therefore, we recommend pinning usage
  to a specific package version. This way, you can install the same version each time without breaking changes unless you are intentionally
  looking for the latest version.



  While we value open-source contributions to this SDK, this library is generated programmatically. Any manual changes added to internal files will be overwritten on the next generation.
  We look forward to hearing your feedback. Feel free to open a PR or an issue with a proof of concept and we'll do our best to include it in a future release.


pkgId: 4b16fd32cc6fbf5d6bc2df10a4c9dec213cf041a74c98efd45b2f28988f942b0
name: python-clerk_backend_sdk
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Clerk Backend API
url: https://github.com/GIT_USER_ID/GIT_REPO_ID
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clerk_backend_sdk-1.1.1-1.src.rpm
checksum_type: sha256
description:
  *ActorTokensApi* | [**create_actor_token**](docs/ActorTokensApi.md#create_actor_token) | **POST** /actor_tokens | Create actor token
  *ActorTokensApi* | [**revoke_actor_token**](docs/ActorTokensApi.md#revoke_actor_token) | **POST** /actor_tokens/{actor_token_id}/revoke | Revoke actor token
  *AllowListBlockListApi* | [**create_allowlist_identifier**](docs/AllowListBlockListApi.md#create_allowlist_identifier) | **POST** /allowlist_identifiers | Add identifier to the allow-list
  *AllowListBlockListApi* | [**create_blocklist_identifier**](docs/AllowListBlockListApi.md#create_blocklist_identifier) | **POST** /blocklist_identifiers | Add identifier to the block-list
  *AllowListBlockListApi* | [**delete_allowlist_identifier**](docs/AllowListBlockListApi.md#delete_allowlist_identifier) | **DELETE** /allowlist_identifiers/{identifier_id} | Delete identifier from allow-list
  *AllowListBlockListApi* | [**delete_blocklist_identifier**](docs/AllowListBlockListApi.md#delete_blocklist_identifier) | **DELETE** /blocklist_identifiers/{identifier_id} | Delete identifier from block-list
  *AllowListBlockListApi* | [**list_allowlist_identifiers**](docs/AllowListBlockListApi.md#list_allowlist_identifiers) | **GET** /allowlist_identifiers | List all identifiers on the allow-list
  *AllowListBlockListApi* | [**list_blocklist_identifiers**](docs/AllowListBlockListApi.md#list_blocklist_identifiers) | **GET** /blocklist_identifiers | List all identifiers on the block-list
  *BetaFeaturesApi* | [**change_production_instance_domain**](docs/BetaFeaturesApi.md#change_production_instance_domain) | **POST** /instance/change_domain | Update production instance domain
  *BetaFeaturesApi* | [**update_instance_auth_config**](docs/BetaFeaturesApi.md#update_instance_auth_config) | **PATCH** /beta_features/instance_settings | Update instance settings
  *BetaFeaturesApi* | [**update_production_instance_domain**](docs/BetaFeaturesApi.md#update_production_instance_domain) | **PUT** /beta_features/domain | Update production instance domain
  *ClientsApi* | [**get_client**](docs/ClientsApi.md#get_client) | **GET** /clients/{client_id} | Get a client
  *ClientsApi* | [**get_client_list**](docs/ClientsApi.md#get_client_list) | **GET** /clients | List all clients
  *ClientsApi* | [**verify_client**](docs/ClientsApi.md#verify_client) | **POST** /clients/verify | Verify a client
  *DomainsApi* | [**add_domain**](docs/DomainsApi.md#add_domain) | **POST** /domains | Add a domain
  *DomainsApi* | [**delete_domain**](docs/DomainsApi.md#delete_domain) | **DELETE** /domains/{domain_id} | Delete a satellite domain
  *DomainsApi* | [**list_domains**](docs/DomainsApi.md#list_domains) | **GET** /domains | List all instance domains
  *DomainsApi* | [**update_domain**](docs/DomainsApi.md#update_domain) | **PATCH** /domains/{domain_id} | Update a domain
  *EmailAddressesApi* | [**create_email_address**](docs/EmailAddressesApi.md#create_email_address) | **POST** /email_addresses | Create an email address
  *EmailAddressesApi* | [**delete_email_address**](docs/EmailAddressesApi.md#delete_email_address) | **DELETE** /email_addresses/{email_address_id} | Delete an email address
  *EmailAddressesApi* | [**get_email_address**](docs/EmailAddressesApi.md#get_email_address) | **GET** /email_addresses/{email_address_id} | Retrieve an email address
  *EmailAddressesApi* | [**update_email_address**](docs/EmailAddressesApi.md#update_email_address) | **PATCH** /email_addresses/{email_address_id} | Update an email address
  *EmailSMSTemplatesApi* | [**get_template**](docs/EmailSMSTemplatesApi.md#get_template) | **GET** /templates/{template_type}/{slug} | Retrieve a template
  *EmailSMSTemplatesApi* | [**get_template_list**](docs/EmailSMSTemplatesApi.md#get_template_list) | **GET** /templates/{template_type} | List all templates
  *EmailSMSTemplatesApi* | [**preview_template**](docs/EmailSMSTemplatesApi.md#preview_template) | **POST** /templates/{template_type}/{slug}/preview | Preview changes to a template
  *EmailSMSTemplatesApi* | [**revert_template**](docs/EmailSMSTemplatesApi.md#revert_template) | **POST** /templates/{template_type}/{slug}/revert | Revert a template
  *EmailSMSTemplatesApi* | [**toggle_template_delivery**](docs/EmailSMSTemplatesApi.md#toggle_template_delivery) | **POST** /templates/{template_type}/{slug}/toggle_delivery | Toggle the delivery by Clerk for a template of a given type and slug
  *EmailSMSTemplatesApi* | [**upsert_template**](docs/EmailSMSTemplatesApi.md#upsert_template) | **PUT** /templates/{template_type}/{slug} | Update a template for a given type and slug
  *InstanceSettingsApi* | [**update_instance**](docs/InstanceSettingsApi.md#update_instance) | **PATCH** /instance | Update instance settings
  *InstanceSettingsApi* | [**update_instance_organization_settings**](docs/InstanceSettingsApi.md#update_instance_organization_settings) | **PATCH** /instance/organization_settings | Update instance organization settings
  *InstanceSettingsApi* | [**update_instance_restrictions**](docs/InstanceSettingsApi.md#update_instance_restrictions) | **PATCH** /instance/restrictions | Update instance restrictions
  *InvitationsApi* | [**create_invitation**](docs/InvitationsApi.md#create_invitation) | **POST** /invitations | Create an invitation
  *InvitationsApi* | [**list_invitations**](docs/InvitationsApi.md#list_invitations) | **GET** /invitations | List all invitations
  *InvitationsApi* | [**revoke_invitation**](docs/InvitationsApi.md#revoke_invitation) | **POST** /invitations/{invitation_id}/revoke | Revokes an invitation
  *JWKSApi* | [**get_jwks**](docs/JWKSApi.md#get_jwks) | **GET** /jwks | Retrieve the JSON Web Key Set of the instance
  *JWTTemplatesApi* | [**create_jwt_template**](docs/JWTTemplatesApi.md#create_jwt_template) | **POST** /jwt_templates | Create a JWT template
  *JWTTemplatesApi* | [**delete_jwt_template**](docs/JWTTemplatesApi.md#delete_jwt_template) | **DELETE** /jwt_templates/{template_id} | Delete a Template
  *JWTTemplatesApi* | [**get_jwt_template**](docs/JWTTemplatesApi.md#get_jwt_template) | **GET** /jwt_templates/{template_id} | Retrieve a template
  *JWTTemplatesApi* | [**list_jwt_templates**](docs/JWTTemplatesApi.md#list_jwt_templates) | **GET** /jwt_templates | List all templates
  *JWTTemplatesApi* | [**update_jwt_template**](docs/JWTTemplatesApi.md#update_jwt_template) | **PATCH** /jwt_templates/{template_id} | Update a JWT template
  *MiscellaneousApi* | [**get_public_interstitial**](docs/MiscellaneousApi.md#get_public_interstitial) | **GET** /public/interstitial | Returns the markup for the interstitial page
  *OAuthApplicationsApi* | [**create_o_auth_application**](docs/OAuthApplicationsApi.md#create_o_auth_application) | **POST** /oauth_applications | Create an OAuth application
  *OAuthApplicationsApi* | [**delete_o_auth_application**](docs/OAuthApplicationsApi.md#delete_o_auth_application) | **DELETE** /oauth_applications/{oauth_application_id} | Delete an OAuth application
  *OAuthApplicationsApi* | [**get_o_auth_application**](docs/OAuthApplicationsApi.md#get_o_auth_application) | **GET** /oauth_applications/{oauth_application_id} | Retrieve an OAuth application by ID
  *OAuthApplicationsApi* | [**list_o_auth_applications**](docs/OAuthApplicationsApi.md#list_o_auth_applications) | **GET** /oauth_applications | Get a list of OAuth applications for an instance
  *OAuthApplicationsApi* | [**rotate_o_auth_application_secret**](docs/OAuthApplicationsApi.md#rotate_o_auth_application_secret) | **POST** /oauth_applications/{oauth_application_id}/rotate_secret | Rotate the client secret of the given OAuth application
  *OAuthApplicationsApi* | [**update_o_auth_application**](docs/OAuthApplicationsApi.md#update_o_auth_application) | **PATCH** /oauth_applications/{oauth_application_id} | Update an OAuth application
  *OrganizationInvitationsApi* | [**create_organization_invitation**](docs/OrganizationInvitationsApi.md#create_organization_invitation) | **POST** /organizations/{organization_id}/invitations | Create and send an organization invitation
  *OrganizationInvitationsApi* | [**create_organization_invitation_bulk**](docs/OrganizationInvitationsApi.md#create_organization_invitation_bulk) | **POST** /organizations/{organization_id}/invitations/bulk | Bulk create and send organization invitations
  *OrganizationInvitationsApi* | [**get_organization_invitation**](docs/OrganizationInvitationsApi.md#get_organization_invitation) | **GET** /organizations/{organization_id}/invitations/{invitation_id} | Retrieve an organization invitation by ID
  *OrganizationInvitationsApi* | [**list_organization_invitations**](docs/OrganizationInvitationsApi.md#list_organization_invitations) | **GET** /organizations/{organization_id}/invitations | Get a list of organization invitations
  *OrganizationInvitationsApi* | [**list_pending_organization_invitations**](docs/OrganizationInvitationsApi.md#list_pending_organization_invitations) | **GET** /organizations/{organization_id}/invitations/pending | Get a list of pending organization invitations
  *OrganizationInvitationsApi* | [**revoke_organization_invitation**](docs/OrganizationInvitationsApi.md#revoke_organization_invitation) | **POST** /organizations/{organization_id}/invitations/{invitation_id}/revoke | Revoke a pending organization invitation
  *OrganizationMembershipsApi* | [**create_organization_membership**](docs/OrganizationMembershipsApi.md#create_organization_membership) | **POST** /organizations/{organization_id}/memberships | Create a new organization membership
  *OrganizationMembershipsApi* | [**delete_organization_membership**](docs/OrganizationMembershipsApi.md#delete_organization_membership) | **DELETE** /organizations/{organization_id}/memberships/{user_id} | Remove a member from an organization
  *OrganizationMembershipsApi* | [**list_organization_memberships**](docs/OrganizationMembershipsApi.md#list_organization_memberships) | **GET** /organizations/{organization_id}/memberships | Get a list of all members of an organization
  *OrganizationMembershipsApi* | [**update_organization_membership**](docs/OrganizationMembershipsApi.md#update_organization_membership) | **PATCH** /organizations/{organization_id}/memberships/{user_id} | Update an organization membership
  *OrganizationMembershipsApi* | [**update_organization_membership_metadata**](docs/OrganizationMembershipsApi.md#update_organization_membership_metadata) | **PATCH** /organizations/{organization_id}/memberships/{user_id}/metadata | Merge and update organization membership metadata
  *OrganizationsApi* | [**create_organization**](docs/OrganizationsApi.md#create_organization) | **POST** /organizations | Create an organization
  *OrganizationsApi* | [**delete_organization**](docs/OrganizationsApi.md#delete_organization) | **DELETE** /organizations/{organization_id} | Delete an organization
  *OrganizationsApi* | [**delete_organization_logo**](docs/OrganizationsApi.md#delete_organization_logo) | **DELETE** /organizations/{organization_id}/logo |
  *OrganizationsApi* | [**get_organization**](docs/OrganizationsApi.md#get_organization) | **GET** /organizations/{organization_id} | Retrieve an organization by ID or slug
  *OrganizationsApi* | [**list_organizations**](docs/OrganizationsApi.md#list_organizations) | **GET** /organizations | Get a list of organizations for an instance
  *OrganizationsApi* | [**merge_organization_metadata**](docs/OrganizationsApi.md#merge_organization_metadata) | **PATCH** /organizations/{organization_id}/metadata | Merge and update metadata for an organization
  *OrganizationsApi* | [**update_organization**](docs/OrganizationsApi.md#update_organization) | **PATCH** /organizations/{organization_id} | Update an organization
  *OrganizationsApi* | [**upload_organization_logo**](docs/OrganizationsApi.md#upload_organization_logo) | **PUT** /organizations/{organization_id}/logo | Upload a logo for the organization
  *PhoneNumbersApi* | [**create_phone_number**](docs/PhoneNumbersApi.md#create_phone_number) | **POST** /phone_numbers | Create a phone number
  *PhoneNumbersApi* | [**delete_phone_number**](docs/PhoneNumbersApi.md#delete_phone_number) | **DELETE** /phone_numbers/{phone_number_id} | Delete a phone number
  *PhoneNumbersApi* | [**get_phone_number**](docs/PhoneNumbersApi.md#get_phone_number) | **GET** /phone_numbers/{phone_number_id} | Retrieve a phone number
  *PhoneNumbersApi* | [**update_phone_number**](docs/PhoneNumbersApi.md#update_phone_number) | **PATCH** /phone_numbers/{phone_number_id} | Update a phone number
  *ProxyChecksApi* | [**verify_domain_proxy**](docs/ProxyChecksApi.md#verify_domain_proxy) | **POST** /proxy_checks | Verify the proxy configuration for your domain
  *RedirectURLsApi* | [**create_redirect_url**](docs/RedirectURLsApi.md#create_redirect_url) | **POST** /redirect_urls | Create a redirect URL
  *RedirectURLsApi* | [**delete_redirect_url**](docs/RedirectURLsApi.md#delete_redirect_url) | **DELETE** /redirect_urls/{id} | Delete a redirect URL
  *RedirectURLsApi* | [**get_redirect_url**](docs/RedirectURLsApi.md#get_redirect_url) | **GET** /redirect_urls/{id} | Retrieve a redirect URL
  *RedirectURLsApi* | [**list_redirect_urls**](docs/RedirectURLsApi.md#list_redirect_urls) | **GET** /redirect_urls | List all redirect URLs
  *SAMLConnectionsApi* | [**create_saml_connection**](docs/SAMLConnectionsApi.md#create_saml_connection) | **POST** /saml_connections | Create a SAML Connection
  *SAMLConnectionsApi* | [**delete_saml_connection**](docs/SAMLConnectionsApi.md#delete_saml_connection) | **DELETE** /saml_connections/{saml_connection_id} | Delete a SAML Connection
  *SAMLConnectionsApi* | [**get_saml_connection**](docs/SAMLConnectionsApi.md#get_saml_connection) | **GET** /saml_connections/{saml_connection_id} | Retrieve a SAML Connection by ID
  *SAMLConnectionsApi* | [**list_saml_connections**](docs/SAMLConnectionsApi.md#list_saml_connections) | **GET** /saml_connections | Get a list of SAML Connections for an instance
  *SAMLConnectionsApi* | [**update_saml_connection**](docs/SAMLConnectionsApi.md#update_saml_connection) | **PATCH** /saml_connections/{saml_connection_id} | Update a SAML Connection
  *SessionsApi* | [**create_session_token_from_template**](docs/SessionsApi.md#create_session_token_from_template) | **POST** /sessions/{session_id}/tokens/{template_name} | Create a session token from a jwt template
  *SessionsApi* | [**get_session**](docs/SessionsApi.md#get_session) | **GET** /sessions/{session_id} | Retrieve a session
  *SessionsApi* | [**get_session_list**](docs/SessionsApi.md#get_session_list) | **GET** /sessions | List all sessions
  *SessionsApi* | [**revoke_session**](docs/SessionsApi.md#revoke_session) | **POST** /sessions/{session_id}/revoke | Revoke a session
  *SessionsApi* | [**verify_session**](docs/SessionsApi.md#verify_session) | **POST** /sessions/{session_id}/verify | Verify a session
  *SignInTokensApi* | [**create_sign_in_token**](docs/SignInTokensApi.md#create_sign_in_token) | **POST** /sign_in_tokens | Create sign-in token
  *SignInTokensApi* | [**revoke_sign_in_token**](docs/SignInTokensApi.md#revoke_sign_in_token) | **POST** /sign_in_tokens/{sign_in_token_id}/revoke | Revoke the given sign-in token
  *SignUpsApi* | [**update_sign_up**](docs/SignUpsApi.md#update_sign_up) | **PATCH** /sign_ups/{id} | Update a sign-up
  *TestingTokensApi* | [**create_testing_token**](docs/TestingTokensApi.md#create_testing_token) | **POST** /testing_tokens | Retrieve a new testing token
  *UsersApi* | [**ban_user**](docs/UsersApi.md#ban_user) | **POST** /users/{user_id}/ban | Ban a user
  *UsersApi* | [**create_user**](docs/UsersApi.md#create_user) | **POST** /users | Create a new user
  *UsersApi* | [**delete_user**](docs/UsersApi.md#delete_user) | **DELETE** /users/{user_id} | Delete a user
  *UsersApi* | [**delete_user_profile_image**](docs/UsersApi.md#delete_user_profile_image) | **DELETE** /users/{user_id}/profile_image | Delete user profile image
  *UsersApi* | [**disable_mfa**](docs/UsersApi.md#disable_mfa) | **DELETE** /users/{user_id}/mfa | Disable a user&#39;s MFA methods
  *UsersApi* | [**get_o_auth_access_token**](docs/UsersApi.md#get_o_auth_access_token) | **GET** /users/{user_id}/oauth_access_tokens/{provider} | Retrieve the OAuth access token of a user
  *UsersApi* | [**get_user**](docs/UsersApi.md#get_user) | **GET** /users/{user_id} | Retrieve a user
  *UsersApi* | [**get_user_list**](docs/UsersApi.md#get_user_list) | **GET** /users | List all users
  *UsersApi* | [**get_users_count**](docs/UsersApi.md#get_users_count) | **GET** /users/count | Count users
  *UsersApi* | [**lock_user**](docs/UsersApi.md#lock_user) | **POST** /users/{user_id}/lock | Lock a user
  *UsersApi* | [**set_user_profile_image**](docs/UsersApi.md#set_user_profile_image) | **POST** /users/{user_id}/profile_image | Set user profile image
  *UsersApi* | [**unban_user**](docs/UsersApi.md#unban_user) | **POST** /users/{user_id}/unban | Unban a user
  *UsersApi* | [**unlock_user**](docs/UsersApi.md#unlock_user) | **POST** /users/{user_id}/unlock | Unlock a user
  *UsersApi* | [**update_user**](docs/UsersApi.md#update_user) | **PATCH** /users/{user_id} | Update a user
  *UsersApi* | [**update_user_metadata**](docs/UsersApi.md#update_user_metadata) | **PATCH** /users/{user_id}/metadata | Merge and update a user&#39;s metadata
  *UsersApi* | [**users_get_organization_memberships**](docs/UsersApi.md#users_get_organization_memberships) | **GET** /users/{user_id}/organization_memberships | Retrieve all memberships for a user
  *UsersApi* | [**verify_password**](docs/UsersApi.md#verify_password) | **POST** /users/{user_id}/verify_password | Verify the password of a user
  *UsersApi* | [**verify_totp**](docs/UsersApi.md#verify_totp) | **POST** /users/{user_id}/verify_totp | Verify a TOTP or backup code for a user
  *WebhooksApi* | [**create_svix_app**](docs/WebhooksApi.md#create_svix_app) | **POST** /webhooks/svix | Create a Svix app
  *WebhooksApi* | [**delete_svix_app**](docs/WebhooksApi.md#delete_svix_app) | **DELETE** /webhooks/svix | Delete a Svix app
  *WebhooksApi* | [**generate_svix_auth_url**](docs/WebhooksApi.md#generate_svix_auth_url) | **POST** /webhooks/svix_url | Create a Svix Dashboard URL

   - [ActorToken](docs/ActorToken.md)
   - [AddDomainRequest](docs/AddDomainRequest.md)
   - [Admin](docs/Admin.md)
   - [AllowlistIdentifier](docs/AllowlistIdentifier.md)
   - [BlocklistIdentifier](docs/BlocklistIdentifier.md)
   - [BlocklistIdentifiers](docs/BlocklistIdentifiers.md)
   - [CNameTarget](docs/CNameTarget.md)
   - [ChangeProductionInstanceDomainRequest](docs/ChangeProductionInstanceDomainRequest.md)
   - [ClerkError](docs/ClerkError.md)
   - [ClerkErrors](docs/ClerkErrors.md)
   - [Client](docs/Client.md)
   - [CreateActorTokenRequest](docs/CreateActorTokenRequest.md)
   - [CreateAllowlistIdentifierRequest](docs/CreateAllowlistIdentifierRequest.md)
   - [CreateBlocklistIdentifierRequest](docs/CreateBlocklistIdentifierRequest.md)
   - [CreateEmailAddressRequest](docs/CreateEmailAddressRequest.md)
   - [CreateInvitationRequest](docs/CreateInvitationRequest.md)
   - [CreateJWTTemplateRequest](docs/CreateJWTTemplateRequest.md)
   - [CreateOAuthApplicationRequest](docs/CreateOAuthApplicationRequest.md)
   - [CreateOrganizationInvitationBulkRequestInner](docs/CreateOrganizationInvitationBulkRequestInner.md)
   - [CreateOrganizationInvitationRequest](docs/CreateOrganizationInvitationRequest.md)
   - [CreateOrganizationMembershipRequest](docs/CreateOrganizationMembershipRequest.md)
   - [CreateOrganizationRequest](docs/CreateOrganizationRequest.md)
   - [CreatePhoneNumberRequest](docs/CreatePhoneNumberRequest.md)
   - [CreateRedirectURLRequest](docs/CreateRedirectURLRequest.md)
   - [CreateSAMLConnectionRequest](docs/CreateSAMLConnectionRequest.md)
   - [CreateSAMLConnectionRequestAttributeMapping](docs/CreateSAMLConnectionRequestAttributeMapping.md)
   - [CreateSessionTokenFromTemplate200Response](docs/CreateSessionTokenFromTemplate200Response.md)
   - [CreateSignInTokenRequest](docs/CreateSignInTokenRequest.md)
   - [CreateUserRequest](docs/CreateUserRequest.md)
   - [DeletedObject](docs/DeletedObject.md)
   - [DisableMFA200Response](docs/DisableMFA200Response.md)
   - [Domain](docs/Domain.md)
   - [Domains](docs/Domains.md)
   - [EmailAddress](docs/EmailAddress.md)
   - [EmailAddressVerification](docs/EmailAddressVerification.md)
   - [GetOAuthAccessToken200ResponseInner](docs/GetOAuthAccessToken200ResponseInner.md)
   - [IdentificationLink](docs/IdentificationLink.md)
   - [InstanceRestrictions](docs/InstanceRestrictions.md)
   - [Invitation](docs/Invitation.md)
   - [JWTTemplate](docs/JWTTemplate.md)
   - [MergeOrganizationMetadataRequest](docs/MergeOrganizationMetadataRequest.md)
   - [OAuthApplication](docs/OAuthApplication.md)
   - [OAuthApplicationWithSecret](docs/OAuthApplicationWithSecret.md)
   - [OAuthApplications](docs/OAuthApplications.md)
   - [OTP](docs/OTP.md)
   - [Oauth](docs/Oauth.md)
   - [OauthError](docs/OauthError.md)
   - [Organization](docs/Organization.md)
   - [OrganizationInvitation](docs/OrganizationInvitation.md)
   - [OrganizationInvitations](docs/OrganizationInvitations.md)
   - [OrganizationMembership](docs/OrganizationMembership.md)
   - [OrganizationMembershipPublicUserData](docs/OrganizationMembershipPublicUserData.md)
   - [OrganizationMemberships](docs/OrganizationMemberships.md)
   - [OrganizationSettings](docs/OrganizationSettings.md)
   - [OrganizationWithLogo](docs/OrganizationWithLogo.md)
   - [Organizations](docs/Organizations.md)
   - [Passkey](docs/Passkey.md)
   - [PasswordHasher](docs/PasswordHasher.md)
   - [PhoneNumber](docs/PhoneNumber.md)
   - [PhoneNumberVerification](docs/PhoneNumberVerification.md)
   - [PreviewTemplateRequest](docs/PreviewTemplateRequest.md)
   - [ProxyCheck](docs/ProxyCheck.md)
   - [RedirectURL](docs/RedirectURL.md)
   - [RevokeInvitation200Response](docs/RevokeInvitation200Response.md)
   - [RevokeOrganizationInvitationRequest](docs/RevokeOrganizationInvitationRequest.md)
   - [SAML](docs/SAML.md)
   - [SAMLAccount](docs/SAMLAccount.md)
   - [SAMLAccountVerification](docs/SAMLAccountVerification.md)
   - [SAMLConnection](docs/SAMLConnection.md)
   - [SAMLConnectionAttributeMapping](docs/SAMLConnectionAttributeMapping.md)
   - [SAMLConnections](docs/SAMLConnections.md)
   - [SchemasPasskey](docs/SchemasPasskey.md)
   - [SchemasPasskeyVerification](docs/SchemasPasskeyVerification.md)
   - [Session](docs/Session.md)
   - [SignInToken](docs/SignInToken.md)
   - [SignUp](docs/SignUp.md)
   - [SvixURL](docs/SvixURL.md)
   - [Template](docs/Template.md)
   - [TestingToken](docs/TestingToken.md)
   - [Ticket](docs/Ticket.md)
   - [ToggleTemplateDeliveryRequest](docs/ToggleTemplateDeliveryRequest.md)
   - [TotalCount](docs/TotalCount.md)
   - [UpdateDomainRequest](docs/UpdateDomainRequest.md)
   - [UpdateEmailAddressRequest](docs/UpdateEmailAddressRequest.md)
   - [UpdateInstanceAuthConfig200Response](docs/UpdateInstanceAuthConfig200Response.md)
   - [UpdateInstanceAuthConfigRequest](docs/UpdateInstanceAuthConfigRequest.md)
   - [UpdateInstanceOrganizationSettingsRequest](docs/UpdateInstanceOrganizationSettingsRequest.md)
   - [UpdateInstanceRequest](docs/UpdateInstanceRequest.md)
   - [UpdateInstanceRestrictionsRequest](docs/UpdateInstanceRestrictionsRequest.md)
   - [UpdateOAuthApplicationRequest](docs/UpdateOAuthApplicationRequest.md)
   - [UpdateOrganizationMembershipMetadataRequest](docs/UpdateOrganizationMembershipMetadataRequest.md)
   - [UpdateOrganizationMembershipRequest](docs/UpdateOrganizationMembershipRequest.md)
   - [UpdateOrganizationRequest](docs/UpdateOrganizationRequest.md)
   - [UpdatePhoneNumberRequest](docs/UpdatePhoneNumberRequest.md)
   - [UpdateProductionInstanceDomainRequest](docs/UpdateProductionInstanceDomainRequest.md)
   - [UpdateSAMLConnectionRequest](docs/UpdateSAMLConnectionRequest.md)
   - [UpdateSAMLConnectionRequestAttributeMapping](docs/UpdateSAMLConnectionRequestAttributeMapping.md)
   - [UpdateSignUpRequest](docs/UpdateSignUpRequest.md)
   - [UpdateUserMetadataRequest](docs/UpdateUserMetadataRequest.md)
   - [UpdateUserRequest](docs/UpdateUserRequest.md)
   - [UpsertTemplateRequest](docs/UpsertTemplateRequest.md)
   - [User](docs/User.md)
   - [VerifyClientRequest](docs/VerifyClientRequest.md)
   - [VerifyDomainProxyRequest](docs/VerifyDomainProxyRequest.md)
   - [VerifyPassword200Response](docs/VerifyPassword200Response.md)
   - [VerifyPasswordRequest](docs/VerifyPasswordRequest.md)
   - [VerifySessionRequest](docs/VerifySessionRequest.md)
   - [VerifyTOTP200Response](docs/VerifyTOTP200Response.md)
   - [VerifyTOTPRequest](docs/VerifyTOTPRequest.md)
   - [Web3Signature](docs/Web3Signature.md)
   - [Web3Wallet](docs/Web3Wallet.md)
   - [Web3WalletVerification](docs/Web3WalletVerification.md)
  <a id="documentation-for-authorization"></a>

  Authentication schemes defined for the API:
  <a id="bearerAuth"></a>

  - **Type**: Bearer authentication (sk_<environment>_<secret value>)

  support@clerk.com


pkgId: 72785ea52e6fba267d460aad188ac8474281efec3544ed909491ea5fe3f40b2c
name: python-cleverbotfree
arch: src
version: 2.3.6
epoch: 0
release: 1
summary: Free Alternative For The Cleverbot API
url: https://github.com/plasticuproject/cleverbotfree
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleverbotfree-2.3.6-1.src.rpm
checksum_type: sha256
description:
  [![build](https://github.com/plasticuproject/cleverbotfree/actions/workflows/tests.yml/badge.svg)](https://github.com/plasticuproject/cleverbotfree/actions/workflows/tests.yml)
  [![Python 3.8](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/release/python-380/)
  [![GPLv3 license](https://img.shields.io/badge/License-GPLv3-blue.svg)](http://perso.crans.org/besson/LICENSE.html)
  [![PyPI version](https://badge.fury.io/py/cleverbotfree.svg)](https://badge.fury.io/py/cleverbotfree)
  [![Downloads](https://pepy.tech/badge/cleverbotfree)](https://pepy.tech/project/cleverbotfree)
  [![CodeQL](https://github.com/plasticuproject/cleverbotfree/actions/workflows/codeql.yml/badge.svg)](https://github.com/plasticuproject/cleverbotfree/actions/workflows/codeql.yml)
  [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=plasticuproject_cleverbotfree&metric=alert_status)](https://sonarcloud.io/dashboard?id=plasticuproject_cleverbotfree)
  [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=plasticuproject_cleverbotfree&metric=security_rating)](https://sonarcloud.io/dashboard?id=plasticuproject_cleverbotfree)

  Cleverbot.com used to have a free API for their chatbot application. They have <br />
  removed their free API in place of a tiered subscription API service. <br />
  cleverbotfree is a free alternative to that API that uses a headless Firefox <br />
  browser to communicate with their chatbot application. You can use this module <br />
  to create applications/bots that send and receive messages to the Cleverbot <br />
  chatbot application. <br />




  - node >= 14.16.1
  - Python >= 3.8.0
  - python3-pip >= 21.1.1

  Once requirments are met, you can install this library through pip. <br />
  ```
  pip install cleverbotfree
  ```


  This library uses the Playwright library to interface the Cleverbot website <br />
  with a headless Firefox browser. <br />
  To download the Playwright Firefox browser binary simply run this command after <br />
  installing cleverbotfree: <br />
  ```
  playwright install firefox
  ```


  <b>Examples</b>

  Example of a simple CLI script that creates a persistent chat session until closed. <br />
  ```python
  import asyncio
  import cleverbotfree

  def chat():
      """Example code using cleverbotfree sync api."""
      with cleverbotfree.sync_playwright() as p_w:
          c_b = cleverbotfree.Cleverbot(p_w)
          while True:
              user_input = input("User: ")
              if user_input == 'quit':
                  break
              bot = c_b.single_exchange(user_input)
              print('Cleverbot:', bot)
          c_b.close()

  chat()


  async def async_chat():
      """Example code using cleverbotfree async api."""
      async with cleverbotfree.async_playwright() as p_w:
          c_b = await cleverbotfree.CleverbotAsync(p_w)
          while True:
              user_input = input("User: ")
              if user_input == 'quit':
                  break
              bot = await c_b.single_exchange(user_input)
              print('Cleverbot:', bot)
          await c_b.close()

  asyncio.run(async_chat())
  ```

  Example of a simple CLI script using the class decorator. <br />
  ```python
  import asyncio
  from cleverbotfree import CleverbotAsync
  from cleverbotfree import Cleverbot

  @Cleverbot.connect
  def chat(bot, user_prompt, bot_prompt):
      """Example code using cleverbotfree sync api with decorator."""
      while True:
          user_input = input(user_prompt)
          if user_input == "quit":
              break
          reply = bot.single_exchange(user_input)
          print(bot_prompt, reply)
      bot.close()

  chat("User: ", "Cleverbot:")


  @CleverbotAsync.connect
  async def async_chat(bot, user_prompt, bot_prompt):
      """Example code using cleverbotfree async api with decorator."""
      while True:
          user_input = input(user_prompt)
          if user_input == "quit":
              break
          reply = await bot.single_exchange(user_input)
          print(bot_prompt, reply)
      await bot.close()

  asyncio.run(async_chat("User: ", "Cleverbot:"))
  ```


pkgId: 97ecfa6cce8d0f1c36e9227e851f8a4a59d00ebf379c6cae83ca261371f32cf0
name: python-cleverdict
arch: src
version: 1.9.2
epoch: 0
release: 1
url: https://github.com/Pfython/cleverdict
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleverdict-1.9.2-1.src.rpm
checksum_type: sha256
summary:
  A JSON-friendly data structure which allows both object attributes and dictionary keys and values to be used simultaneously and interchangeably.

description:
  **AUTOSAVE OPTION #1: DICTIONARY DATA ONLY**
      >>> x = CleverDict({"Patient Name": "Wobbly Joe", "Test Result": "Positive"})
      >>> x.autosave()
      âš  Autosaving to:
      C:\Users\Peter\AppData\Roaming\CleverDict\2021-01-20-15-03-54-30.json
      >>> x.Prognosis = "Not good"


pkgId: aa7e7a6742f5e59a702b917f835f83728d0eeabb8bab66bf7f71aa3faee291fb
name: python-cleverminer
arch: src
version: 1.1.0
epoch: 0
release: 1
url: https://cleverminer.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleverminer-1.1.0-1.src.rpm
checksum_type: sha256
summary:
  Beyond apriori. Cleverminer is the package for enhanced association rule mining (eARM). Comparing to standard association rules, it is very enhanced, because the package implements the GUHA procedures that generalises apriori and association rules in many ways. Rules are based on categorical data that can be easily visualized and interpreted. Their if-then with probability allows easy deployment by human realized processes. Trully explainable knowledge mining.

description:
  <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/cleverminer">
  <img alt="PyPI - Wheel" src="https://img.shields.io/pypi/wheel/cleverminer">
  <img alt="PyPI - Status" src="https://img.shields.io/pypi/status/cleverminer">
  <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/cleverminer">



  Beyond apriori. Cleverminer is the package for enhanced association rule mining (eARM), that are INTERPRETABLE, so by definition   one of few intristic methods of explainable AI (XAI). Comparing to standard association rules, it is very enhanced, because the package implements the GUHA procedures that generalises apriori and association rules in many ways. Rules are based on categorical data that can be easily visualized and interpreted. Their if-then with probability allows easy deployment by human realized processes. Trully explainable knowledge mining.



  In general, apriori is looking for rules {ItemSet} -> {Item} (Base, prob). GUHA goes further and instead of items (boolean attributes), list of categorial attributes and combination of values (nominal and several strategies for ordinal -- joining categories) is searched on left and right hand side. Moreover, GUHA has much more possibilites and several other procedures, like mining interesting histograms, finding couples of rules etc.

  To run cleverminer procedures, use dataframe with categorical variables only. Cleverminer prepares all variables and values for future reuse.



  CleverMiner has optimized space search in several ways.

  - first, it encodes dataframe into internal format that is optimized for frequent querying for similar pattern, then it queries the dataframe many (typically several thousand or tens/hunderds thousand) times.
  - the algorithm has also optimizations by the derived properties of individual procedures (e.g. when procedure A finds that expanding rule will in every case lead into rules that does not meet requirements, it skips entire branch). This optimization typically reduces the mining time significantly.




  Documentation for CleverMiner can be found at [cleverminer.org](https://cleverminer.org)



  1.1.0 (cumulative feature update)
   - support for displaying charts for rules (.draw_rule() method)
   - procedures fully documented (docstrings available)
   - UIC Miner supports relevant base lift and relevant cat base quantifiers
   - support for lambda quantifiers
   - support for list literal type
   - improved detection of ordered categories


  1.0.12
   - fixed problem with .mine method ("row_count" issue)

  1.0.11
   - fixed wording in UIC miner output
   - fixed bug in dataset description

  1.0.10
   - get_ruletext method
   - result contains rowcont of original dataframe to increase possibilities of post-processing

  1.0.9
   - fixed bugs - error message when displaying of results that has not been calculated
   - Python 3.12 regression tests passed ok

  1.0.8
   - data preparation enhanced in many ways
   - able to work with series like 1,2,3, 4-20, 21 and more, 0.0,1.0, ..., Temp 17-25oC,...


  1.0.7
   - CF miner supports step size and range between relmax & relmin
   - categories printed in CF output
   - bugfix: checking number of categories fixed
   - can return also adjusted df (ordered categories, ...) - functionality not guaranteed to future

  1.0.6
   - progressbar

  1.0.5

   - supports missing pandas functionalities and implements several automated data preprocessing
   - listing of variables, ordering and labels
   - automatically process conversion to numeric, integers and order float & integer variables
   - fixed verbosity level prints

  1.0.4
   - sorting output rules

  1.0.3
   - UIC Miner introduced

  1.0.2
   - merge changes from 0.91 (data structure checks; as 1.0.0 was build from 0.0.90 so remaining features are merged now)

  1.0.1
   - new procedures get4fold, gethist, getquantifiers, getrulecount

  1.0.0 - Major release, major rebuild from all views:
   - data import reworked and fastened significantly
   - much faster calculation (rule mining) in Py3.10 + next optimizations for rule mining are in place
   - output structure is enhanced, fully structured output is available for post-processing (trace_cedent, cedent_struct in output)
   - data can be read once and multiple tasks can be performed (.mine method)
   - optimizations for sd4ft miner
   - verbosity options available (run progress output has been changed)
   - additional options available (able to override maximum number of categories)
   - better formatting outputs (bugfix)
   - data structure in output has changed

  0.0.91 - detect error in datatypes in input data and correctly report it

  0.0.90 - fix in displaying rules for 4ft-Miner, in CF-Miner: allowing relmax to be bounded from both sides (leq introduced), in SD4ft-Miner: allowing ratioconf to be bounded from both sides (leq introduced)

  0.0.89 - quantifiers and output dictionary names change in favor of rules terminology (output: hypotheses->rules; hypo_id -> rule_id, quantifiers kept
  for compatibility old and new names, including variability (like frstbase -> also base1 is possible)

  0.0.88 - print of task summary, hypo listing and individual hypothesis

  0.0.87 - support for 'one category' added

  0.0.86 - bugfixes (space search for optimized branch, able to switch off optimization, minimal cedent length bug for optimized search)

  0.0.85 - bugfixes (row_count), checking input structure

  0.0.84 - optimizations for conjunctions


pkgId: 954c5ecfd421dace1f96f39b7f918a1d1ff1180c089cdd78fad6383b90db3880
name: python-cleverminer
arch: src
version: 1.1.1
epoch: 0
release: 1
url: https://cleverminer.org
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cleverminer-1.1.1-1.src.rpm
checksum_type: sha256
summary:
  Beyond apriori. Cleverminer is the package for enhanced association rule mining (eARM). Comparing to standard association rules, it is very enhanced, because the package implements the GUHA procedures that generalises apriori and association rules in many ways. Rules are based on categorical data that can be easily visualized and interpreted. Their if-then with probability allows easy deployment by human realized processes. Trully interpretable & explainable knowledge mining.

description:
  <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/cleverminer">
  <img alt="PyPI - Wheel" src="https://img.shields.io/pypi/wheel/cleverminer">
  <img alt="PyPI - Status" src="https://img.shields.io/pypi/status/cleverminer">
  <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/cleverminer">



  Beyond apriori. Cleverminer is the package for enhanced association rule mining (eARM), that are INTERPRETABLE, so by definition   one of few intristic methods of explainable AI (XAI). Comparing to standard association rules, it is very enhanced, because the package implements the GUHA procedures that generalises apriori and association rules in many ways. Rules are based on categorical data that can be easily visualized and interpreted. Their if-then with probability allows easy deployment by human realized processes. Trully interpretable & explainable knowledge mining.



  In general, apriori is looking for rules {ItemSet} -> {Item} (Base, prob). GUHA goes further and instead of items (boolean attributes), list of categorial attributes and combination of values (nominal and several strategies for ordinal -- joining categories) is searched on left and right hand side. Moreover, GUHA has much more possibilites and several other procedures, like mining interesting histograms, finding couples of rules etc.

  To run cleverminer procedures, use dataframe with categorical variables only. Cleverminer prepares all variables and values for future reuse.



  CleverMiner has optimized space search in several ways.

  - first, it encodes dataframe into internal format that is optimized for frequent querying for similar pattern, then it queries the dataframe many (typically several thousand or tens/hunderds thousand) times.
  - the algorithm has also optimizations by the derived properties of individual procedures (e.g. when procedure A finds that expanding rule will in every case lead into rules that does not meet requirements, it skips entire branch). This optimization typically reduces the mining time significantly.




  Documentation for CleverMiner can be found at [cleverminer.org](https://cleverminer.org)



  1.1.1
   - rich API available
   - new detailed documentation available at [cleverminer.org](https://cleverminer.org)
   - minor bugfixes


  1.1.0 (cumulative feature update)
   - support for displaying charts for rules (.draw_rule() method)
   - procedures fully documented (docstrings available)
   - UIC Miner supports relevant base lift and relevant cat base quantifiers
   - support for lambda quantifiers
   - support for list literal type
   - improved detection of ordered categories


  1.0.12
   - fixed problem with .mine method ("row_count" issue)

  1.0.11
   - fixed wording in UIC miner output
   - fixed bug in dataset description

  1.0.10
   - get_ruletext method
   - result contains rowcont of original dataframe to increase possibilities of post-processing

  1.0.9
   - fixed bugs - error message when displaying of results that has not been calculated
   - Python 3.12 regression tests passed ok

  1.0.8
   - data preparation enhanced in many ways
   - able to work with series like 1,2,3, 4-20, 21 and more, 0.0,1.0, ..., Temp 17-25oC,...


  1.0.7
   - CF miner supports step size and range between relmax & relmin
   - categories printed in CF output
   - bugfix: checking number of categories fixed
   - can return also adjusted df (ordered categories, ...) - functionality not guaranteed to future

  1.0.6
   - progressbar

  1.0.5

   - supports missing pandas functionalities and implements several automated data preprocessing
   - listing of variables, ordering and labels
   - automatically process conversion to numeric, integers and order float & integer variables
   - fixed verbosity level prints

  1.0.4
   - sorting output rules

  1.0.3
   - UIC Miner introduced

  1.0.2
   - merge changes from 0.91 (data structure checks; as 1.0.0 was build from 0.0.90 so remaining features are merged now)

  1.0.1
   - new procedures get4fold, gethist, getquantifiers, getrulecount

  1.0.0 - Major release, major rebuild from all views:
   - data import reworked and fastened significantly
   - much faster calculation (rule mining) in Py3.10 + next optimizations for rule mining are in place
   - output structure is enhanced, fully structured output is available for post-processing (trace_cedent, cedent_struct in output)
   - data can be read once and multiple tasks can be performed (.mine method)
   - optimizations for sd4ft miner
   - verbosity options available (run progress output has been changed)
   - additional options available (able to override maximum number of categories)
   - better formatting outputs (bugfix)
   - data structure in output has changed

  0.0.91 - detect error in datatypes in input data and correctly report it

  0.0.90 - fix in displaying rules for 4ft-Miner, in CF-Miner: allowing relmax to be bounded from both sides (leq introduced), in SD4ft-Miner: allowing ratioconf to be bounded from both sides (leq introduced)

  0.0.89 - quantifiers and output dictionary names change in favor of rules terminology (output: hypotheses->rules; hypo_id -> rule_id, quantifiers kept
  for compatibility old and new names, including variability (like frstbase -> also base1 is possible)

  0.0.88 - print of task summary, hypo listing and individual hypothesis

  0.0.87 - support for 'one category' added

  0.0.86 - bugfixes (space search for optimized branch, able to switch off optimization, minimal cedent length bug for optimized search)

  0.0.85 - bugfixes (row_count), checking input structure

  0.0.84 - optimizations for conjunctions


pkgId: 16481b67b9aadc0a9bdb0456ef4f469905e20a6dad4a4bcaa6eb027b7ec8d328
name: python-clg
arch: src
version: 3.3.0
epoch: 0
release: 1
summary: Command-line generator from a dictionary.
url: https://clg.readthedocs.org/en/latest/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-clg-3.3.0-1.src.rpm
checksum_type: sha256
description:
  This module, which wrap `argparse
  <https://docs.python.org/3/library/argparse.html>`__, aims to simplify the
  creation and the maintainabilty of command-line by defining its configuration
  in a predefined struture (ie. a dictionnary). As python dictionnaries are easily
  exportable to configuration files like *YAML* or *JSON*, the idea is to
  outsource the command-line definition to a file instead of writing dozens or
  hundreds lines of code.
  * Code is available on `Github <http://github.com/fmenabe/python-clg>`__.
  * Documentation is available on `Readthedocs <https://clg.readthedocs.org/en/latest/>`__.
  * Changlog is available `here <http://github.com/fmenabe/python-clg/blob/master/CHANGELOG.rst>`__


pkgId: 48197472f2f6b1ac3775feaeddc30581941e3053721481ec9968253bfaed624f
name: python-cli-base-utilities
arch: src
version: 0.13.1
epoch: 0
release: 1
summary: Helpers to bild a CLI program
url: https://pypi.org/project/cli-base-utilities/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-base-utilities-0.13.1-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/jedie/cli-base-utilities/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/jedie/cli-base-utilities/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/github/jedie/cli-base-utilities/branch/main/graph/badge.svg)](https://app.codecov.io/github/jedie/cli-base-utilities)
  [![cli-base-utilities @ PyPi](https://img.shields.io/pypi/v/cli-base-utilities?label=cli-base-utilities%20%40%20PyPi)](https://pypi.org/project/cli-base-utilities/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/cli-base-utilities)](https://github.com/jedie/cli-base-utilities/blob/main/pyproject.toml)
  [![License GPL-3.0-or-later](https://img.shields.io/pypi/l/cli-base-utilities)](https://github.com/jedie/cli-base-utilities/blob/main/LICENSE)

  Helpers to build a CLI program and some useful tools for CLI programs.

  ```
  pip install cli-base-utilities
  ```




  Some of the features are:

  * [`run_pip_audit()` to run `pip-audit` with configuration from `pyproject.toml`](https://github.com/jedie/cli-base-utilities/blob/main/docs/pip_audit.md)

  TODO: Document all features here ;)




  ```bash
  ~$ git clone https://github.com/jedie/cli-base-utilities.git
  ~$ cd cli-base-utilities
  ~/cli-base-utilities$ ./dev-cli.py --help
  ```




  [comment]: <> (✂✂✂ auto generated dev help start ✂✂✂)
  ```
  usage: ./dev-cli.py [-h]
                      {check-code-style,coverage,fix-code-style,install,mypy,pip-audit,publish,test,
  tox,update,update-test-snapshot-files,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help        show this help message and exit                                              │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {check-code-style,coverage,fix-code-style,install,mypy,pip-audit,publish,test,tox,update,upda… │
  │     check-code-style                                                                           │
  │                   Check code style by calling darker + flake8                                  │
  │     coverage      Run tests and show coverage report.                                          │
  │     fix-code-style                                                                             │
  │                   Fix code style of all cli_base source code files via darker                  │
  │     install       Run pip-sync and install 'cli_base' via pip as editable.                     │
  │     mypy          Run Mypy (configured in pyproject.toml)                                      │
  │     pip-audit     Run pip-audit check against current requirements files                       │
  │     publish       Build and upload this project to PyPi                                        │
  │     test          Run unittests                                                                │
  │     tox           Run tox                                                                      │
  │     update        Update "requirements*.txt" dependencies files                                │
  │     update-test-snapshot-files                                                                 │
  │                   Update all test snapshot files (by remove and recreate all snapshot files)   │
  │     version       Print version and exit                                                       │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated dev help end ✂✂✂)




  [comment]: <> (✂✂✂ auto generated app help start ✂✂✂)
  ```
  usage: ./cli.py [-h] {update-readme-history,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help        show this help message and exit                                              │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {update-readme-history,version}                                                                │
  │     update-readme-history                                                                      │
  │                   Update project history base on git commits/tags in README.md Will be exited  │
  │                   with 1 if the README.md was updated otherwise with 0.                        │
  │                                                                                                │
  │                   Also, callable via e.g.:                                                     │
  │                       python -m cli_base update-readme-history -v                              │
  │     version       Print version and exit                                                       │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated app help end ✂✂✂)




  [comment]: <> (✂✂✂ auto generated demo help start ✂✂✂)
  ```
  usage: ./cli.py [-h]
                  {demo-endless-loop,demo-verbose-check-output-error,edit-settings,print-settings,sy
  stemd-debug,systemd-remove,systemd-setup,systemd-status,systemd-stop,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help                                                                                     │
  │     show this help message and exit                                                            │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {demo-endless-loop,demo-verbose-check-output-error,edit-settings,print-settings,systemd-debug… │
  │     demo-endless-loop                                                                          │
  │     Just a useless example command, used in systemd DEMO: It just print some information in a  │
  │     endless loop.                                                                              │
  │     demo-verbose-check-output-error                                                            │
  │     DEMO for a error calling cli_base.cli_tools.subprocess_utils.verbose_check_output()        │
  │     edit-settings                                                                              │
  │     Edit the settings file. On first call: Create the default one.                             │
  │     print-settings                                                                             │
  │     Display (anonymized) MQTT server username and password                                     │
  │     systemd-debug                                                                              │
  │     Print Systemd service template + context + rendered file content.                          │
  │     systemd-remove                                                                             │
  │     Write Systemd service file, enable it and (re-)start the service. (May need sudo)          │
  │     systemd-setup                                                                              │
  │     Write Systemd service file, enable it and (re-)start the service. (May need sudo)          │
  │     systemd-status                                                                             │
  │     Display status of systemd service. (May need sudo)                                         │
  │     systemd-stop                                                                               │
  │     Stops the systemd service. (May need sudo)                                                 │
  │     version                                                                                    │
  │     Print version and exit                                                                     │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated demo help end ✂✂✂)




  Add a test case similar to [cli_base/tests/test_readme_history.py](https://github.com/jedie/cli-base-utilities/blob/main/cli_base/tests/test_readme_history.py) into your project.
  Add the needed `start`/`end` comments into your README.

  To make a new release, do this:

  * Increase your project version number
  * Run tests to update the README
  * commit the changes
  * Create release

  It's recommended to use git hookd (via [pre-commit](https://pre-commit.com/)) to update the README.
  For this, add in your `pyproject.toml`:

  ```toml
  [tool.cli_base]
  version_module_name = "<your_package>" # Must provide the `__version__` attribute
  ```

  Copy&paste [.pre-commit-config.yaml](https://github.com/jedie/cli-base-utilities/blob/main/.pre-commit-config.yaml) into your project.

  Add `pre-commit` to your requirements and install the git hooks by:

  ```bash
  .venv/bin/pre-commit install
  .venv/bin/pre-commit autoupdate
  ```



  Update version in `.pre-commit-config.yaml` and make a release.

  The Problem: The hooks are broken, if the "new" version is not tagged yet.
  To create a release, it's possible to use all git commands (commit, push, etc) with `--no-verify` to skip the hooks.

  It's easier to temporarily uninstall the hooks, create the release and install the hooks again, e.g.:

  ```bash
  .../cli-base-utilities$ .venv/bin/pre-commit uninstall

  .../cli-base-utilities$ .venv/bin/pre-commit install
  ```




  [comment]: <> (✂✂✂ auto generated history start ✂✂✂)

  * [v0.13.1](https://github.com/jedie/cli-base-utilities/compare/v0.13.0...v0.13.1)
    * 2024-09-26 - Bugfix missing click. Add it for Backward compatibility
  * [v0.13.0](https://github.com/jedie/cli-base-utilities/compare/v0.12.0...v0.13.0)
    * 2024-09-26 - Add Helper for tyro and replace click with tyro in own CLIs
  * [v0.12.0](https://github.com/jedie/cli-base-utilities/compare/v0.11.0...v0.12.0)
    * 2024-09-25 - Add debug log to update_readme_history call
    * 2024-09-25 - Simplify AssertCliHelpInReadme to a flat function
    * 2024-09-25 - Apply manage projects updates
    * 2024-09-25 - Update requirements
  * [v0.11.0](https://github.com/jedie/cli-base-utilities/compare/v0.10.3...v0.11.0)
    * 2024-08-30 - Apply manageprojects updates, e.g.: Set min. Python to 3.11+
    * 2024-08-30 - NEW: EncloseRuleContext

  <details><summary>Expand older history entries ...</summary>

  * [v0.10.3](https://github.com/jedie/cli-base-utilities/compare/v0.10.2...v0.10.3)
    * 2024-08-05 - Bugfix unchanable boolean flags in toml settings
  * [v0.10.2](https://github.com/jedie/cli-base-utilities/compare/v0.10.1...v0.10.2)
    * 2024-08-04 - Auto activate pre commit hooks
    * 2024-08-04 - Update demo CLI: Always update pip and pip-tools
    * 2024-08-04 - Handle KeyboardInterrupt in cli scripts.
    * 2024-08-04 - Bugfix #50 toml2dataclass(): AttributeError: 'bool' object has no attribute 'unwrap'.
    * 2024-08-02 - Fix doc link in README.md
  * [v0.10.1](https://github.com/jedie/cli-base-utilities/compare/v0.10.0...v0.10.1)
    * 2024-08-02 - Increase default timout from 5 to 15 minutes
    * 2024-08-02 - Update pre-commit hook version to cli-base-utilities v0.10.0
  * [v0.10.0](https://github.com/jedie/cli-base-utilities/compare/v0.9.0...v0.10.0)
    * 2024-08-02 - Use dateutil in get_commit_date()
    * 2024-08-02 - Replace "safety" by "pip-audit" and add tooling for it.
    * 2024-08-01 - Update manageprojects updates
  * [v0.9.0](https://github.com/jedie/cli-base-utilities/compare/v0.8.0...v0.9.0)
    * 2024-07-16 - Update project
  * [v0.8.0](https://github.com/jedie/cli-base-utilities/compare/v0.7.0...v0.8.0)
    * 2024-03-12 - Bugfix publish
    * 2024-03-12 - fix tests
    * 2024-03-12 - Split app/dev CLI into a package with autodiscovery
    * 2024-03-12 - Move click defaults
    * 2024-03-12 - Apply cookiecutter template updates
    * 2024-03-12 - Update requirements
    * 2024-01-16 - Use typeguard in tests
    * 2024-01-16 - manageprojects updates
    * 2024-01-16 - Update requirements + datetimes ;)
    * 2023-12-17 - Bugfix .pre-commit-config.yaml
  * [v0.7.0](https://github.com/jedie/cli-base-utilities/compare/v0.6.0...v0.7.0)
    * 2023-12-16 - Add "Update pre-commit hooks" to README
    * 2023-12-16 - Bugfix update_readme_history(): Use `__version__` from module
    * 2023-12-16 - NEW: "update-readme-history" git hook using "pre-commit"
    * 2023-12-16 - fix tests
    * 2023-12-16 - Bugfix type hints
    * 2023-12-16 - Add update-readme-history to app CLI
    * 2023-12-16 - Move DEMO into `./cli_base/demo/`
    * 2023-12-16 - Simplify App CLI
    * 2023-12-16 - Remove PACKAGE_ROOT from app CLI
    * 2023-12-16 - Update requirements
    * 2023-12-16 - Skip test_readme_history() on CI
  * [v0.6.0](https://github.com/jedie/cli-base-utilities/compare/v0.5.0...v0.6.0)
    * 2023-12-02 - NEW: Code style tools
  * [v0.5.0](https://github.com/jedie/cli-base-utilities/compare/v0.4.5...v0.5.0)
    * 2023-12-01 - fix flake8
    * 2023-12-01 - NEW: test utils: AssertLogs() context manager
    * 2023-12-01 - Bugfix expand_user() if SUDO_USER is the same as current user
    * 2023-12-01 - Add "run_coverage()" to "dev_tools" and polish tox, unittest, too.
    * 2023-12-01 - add tests for EraseCoverageData()
    * 2023-12-01 - Apply manageprojects updates
  * [v0.4.5](https://github.com/jedie/cli-base-utilities/compare/v0.4.4...v0.4.5)
    * 2023-11-30 - Configure unittests via "load_tests Protocol" hook
    * 2023-11-30 - Update requirements and add "flake8-bugbear"
    * 2023-11-30 - Remove function calls in function agruments
  * [v0.4.4](https://github.com/jedie/cli-base-utilities/compare/v0.4.3...v0.4.4)
    * 2023-11-01 - Bugfix "AssertionError: Expected only one line" in Git.first_commit_info()
  * [v0.4.3](https://github.com/jedie/cli-base-utilities/compare/v0.4.2...v0.4.3)
    * 2023-11-01 - Git history renderer: Collapse older entries
  * [v0.4.2](https://github.com/jedie/cli-base-utilities/compare/v0.4.1...v0.4.2)
    * 2023-11-01 - Remove duplicate git commits and keep only test last one, e.g.: "update requirements"
    * 2023-11-01 - Bugfix git history: Add commits before the first tag
  * [v0.4.1](https://github.com/jedie/cli-base-utilities/compare/v0.4.0...v0.4.1)
    * 2023-10-08 - Remove commit URLs from history and handle release a new version
    * 2023-10-08 - NEW: Generate a project history base on git commits/tags.
    * 2023-10-08 - Update requirements
    * 2023-09-26 - Update README.md
  * [v0.4.0](https://github.com/jedie/cli-base-utilities/compare/v0.3.0...v0.4.0)
    * 2023-09-24 - fix tests
    * 2023-09-24 - Add UpdateTestSnapshotFiles() Context Manager
    * 2023-09-24 - coverage: Refactor setup and add helpers
    * 2023-09-24 - Update requirements
  * [v0.3.0](https://github.com/jedie/cli-base-utilities/compare/v0.2.0...v0.3.0)
    * 2023-08-17 - Bugfix tests run in terminal
    * 2023-08-17 - update requirements
    * 2023-08-17 - NEW: cli_base.cli_tools.git and cli_base.cli_tools.version_info
  * [v0.2.0](https://github.com/jedie/cli-base-utilities/compare/d89f23b...v0.2.0)
    * 2023-08-09 - Project setup updates
    * 2023-05-22 - Update README.md
    * 2023-05-22 - Rename project "cli-base" to "cli-base-utilities"
    * 2023-05-22 - Add github CI config
    * 2023-05-22 - Add subprocess_utils from manageprojects
    * 2023-05-21 - init

  </details>


  [comment]: <> (✂✂✂ auto generated history end ✂✂✂)


pkgId: cb94779d0d869c40bcc9726728828690df8a69188a75f1dca8461b1cc7dd4d50
name: python-cli-base-utilities
arch: src
version: 0.14.0
epoch: 0
release: 1
summary: Helpers to bild a CLI program
url: https://pypi.org/project/cli-base-utilities/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-base-utilities-0.14.0-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/jedie/cli-base-utilities/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/jedie/cli-base-utilities/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/github/jedie/cli-base-utilities/branch/main/graph/badge.svg)](https://app.codecov.io/github/jedie/cli-base-utilities)
  [![cli-base-utilities @ PyPi](https://img.shields.io/pypi/v/cli-base-utilities?label=cli-base-utilities%20%40%20PyPi)](https://pypi.org/project/cli-base-utilities/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/cli-base-utilities)](https://github.com/jedie/cli-base-utilities/blob/main/pyproject.toml)
  [![License GPL-3.0-or-later](https://img.shields.io/pypi/l/cli-base-utilities)](https://github.com/jedie/cli-base-utilities/blob/main/LICENSE)

  Helpers to build a CLI program and some useful tools for CLI programs.

  ```
  pip install cli-base-utilities
  ```




  Some of the features are:

  * [`run_pip_audit()` to run `pip-audit` with configuration from `pyproject.toml`](https://github.com/jedie/cli-base-utilities/blob/main/docs/pip_audit.md)

  TODO: Document all features here ;)




  ```bash
  ~$ git clone https://github.com/jedie/cli-base-utilities.git
  ~$ cd cli-base-utilities
  ~/cli-base-utilities$ ./dev-cli.py --help
  ```




  [comment]: <> (✂✂✂ auto generated dev help start ✂✂✂)
  ```
  usage: ./dev-cli.py [-h]
                      {check-code-style,coverage,fix-code-style,install,mypy,pip-audit,publish,test,
  tox,update,update-test-snapshot-files,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help        show this help message and exit                                              │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {check-code-style,coverage,fix-code-style,install,mypy,pip-audit,publish,test,tox,update,upda… │
  │     check-code-style                                                                           │
  │                   Check code style by calling darker + flake8                                  │
  │     coverage      Run tests and show coverage report.                                          │
  │     fix-code-style                                                                             │
  │                   Fix code style of all cli_base source code files via darker                  │
  │     install       Run pip-sync and install 'cli_base' via pip as editable.                     │
  │     mypy          Run Mypy (configured in pyproject.toml)                                      │
  │     pip-audit     Run pip-audit check against current requirements files                       │
  │     publish       Build and upload this project to PyPi                                        │
  │     test          Run unittests                                                                │
  │     tox           Run tox                                                                      │
  │     update        Update "requirements*.txt" dependencies files                                │
  │     update-test-snapshot-files                                                                 │
  │                   Update all test snapshot files (by remove and recreate all snapshot files)   │
  │     version       Print version and exit                                                       │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated dev help end ✂✂✂)




  [comment]: <> (✂✂✂ auto generated app help start ✂✂✂)
  ```
  usage: ./cli.py [-h] {update-readme-history,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help        show this help message and exit                                              │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {update-readme-history,version}                                                                │
  │     update-readme-history                                                                      │
  │                   Update project history base on git commits/tags in README.md Will be exited  │
  │                   with 1 if the README.md was updated otherwise with 0.                        │
  │                                                                                                │
  │                   Also, callable via e.g.:                                                     │
  │                       python -m cli_base update-readme-history -v                              │
  │     version       Print version and exit                                                       │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated app help end ✂✂✂)




  [comment]: <> (✂✂✂ auto generated demo help start ✂✂✂)
  ```
  usage: ./demo-cli.py [-h]
                       {demo-endless-loop,demo-verbose-check-output-error,edit-settings,print-settin
  gs,systemd-debug,systemd-remove,systemd-setup,systemd-status,systemd-stop,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help                                                                                     │
  │     show this help message and exit                                                            │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {demo-endless-loop,demo-verbose-check-output-error,edit-settings,print-settings,systemd-debug… │
  │     demo-endless-loop                                                                          │
  │     Just a useless example command, used in systemd DEMO: It just print some information in a  │
  │     endless loop.                                                                              │
  │     demo-verbose-check-output-error                                                            │
  │     DEMO for a error calling cli_base.cli_tools.subprocess_utils.verbose_check_output()        │
  │     edit-settings                                                                              │
  │     Edit the settings file. On first call: Create the default one.                             │
  │     print-settings                                                                             │
  │     Display (anonymized) MQTT server username and password                                     │
  │     systemd-debug                                                                              │
  │     Print Systemd service template + context + rendered file content.                          │
  │     systemd-remove                                                                             │
  │     Write Systemd service file, enable it and (re-)start the service. (May need sudo)          │
  │     systemd-setup                                                                              │
  │     Write Systemd service file, enable it and (re-)start the service. (May need sudo)          │
  │     systemd-status                                                                             │
  │     Display status of systemd service. (May need sudo)                                         │
  │     systemd-stop                                                                               │
  │     Stops the systemd service. (May need sudo)                                                 │
  │     version                                                                                    │
  │     Print version and exit                                                                     │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated demo help end ✂✂✂)




  Add a test case similar to [cli_base/tests/test_readme_history.py](https://github.com/jedie/cli-base-utilities/blob/main/cli_base/tests/test_readme_history.py) into your project.
  Add the needed `start`/`end` comments into your README.

  To make a new release, do this:

  * Increase your project version number
  * Run tests to update the README
  * commit the changes
  * Create release

  It's recommended to use git hookd (via [pre-commit](https://pre-commit.com/)) to update the README.
  For this, add in your `pyproject.toml`:

  ```toml
  [tool.cli_base]
  version_module_name = "<your_package>" # Must provide the `__version__` attribute
  ```

  Copy&paste [.pre-commit-config.yaml](https://github.com/jedie/cli-base-utilities/blob/main/.pre-commit-config.yaml) into your project.

  Add `pre-commit` to your requirements and install the git hooks by:

  ```bash
  .venv/bin/pre-commit install
  .venv/bin/pre-commit autoupdate
  ```



  Update version in `.pre-commit-config.yaml` and make a release.

  The Problem: The hooks are broken, if the "new" version is not tagged yet.
  To create a release, it's possible to use all git commands (commit, push, etc) with `--no-verify` to skip the hooks.

  It's easier to temporarily uninstall the hooks, create the release and install the hooks again, e.g.:

  ```bash
  .../cli-base-utilities$ .venv/bin/pre-commit uninstall

  .../cli-base-utilities$ .venv/bin/pre-commit install
  ```





  `cli_base.run_pip_audit.run_pip_audit()` works now with `uv` base projects instead of `pip-tools`.




  [comment]: <> (✂✂✂ auto generated history start ✂✂✂)

  * [v0.14.0](https://github.com/jedie/cli-base-utilities/compare/v0.13.1...v0.14.0)
    * 2024-11-21 - Use tyro.extras.SubcommandApp()
    * 2024-11-21 - Update "install" command and use uv
    * 2024-11-21 - Switch from pip-tools to uv
  * [v0.13.1](https://github.com/jedie/cli-base-utilities/compare/v0.13.0...v0.13.1)
    * 2024-09-26 - Bugfix missing click. Add it for Backward compatibility
  * [v0.13.0](https://github.com/jedie/cli-base-utilities/compare/v0.12.0...v0.13.0)
    * 2024-09-26 - Add Helper for tyro and replace click with tyro in own CLIs
  * [v0.12.0](https://github.com/jedie/cli-base-utilities/compare/v0.11.0...v0.12.0)
    * 2024-09-25 - Add debug log to update_readme_history call
    * 2024-09-25 - Simplify AssertCliHelpInReadme to a flat function
    * 2024-09-25 - Apply manage projects updates
    * 2024-09-25 - Update requirements

  <details><summary>Expand older history entries ...</summary>

  * [v0.11.0](https://github.com/jedie/cli-base-utilities/compare/v0.10.3...v0.11.0)
    * 2024-08-30 - Apply manageprojects updates, e.g.: Set min. Python to 3.11+
    * 2024-08-30 - NEW: EncloseRuleContext
  * [v0.10.3](https://github.com/jedie/cli-base-utilities/compare/v0.10.2...v0.10.3)
    * 2024-08-05 - Bugfix unchanable boolean flags in toml settings
  * [v0.10.2](https://github.com/jedie/cli-base-utilities/compare/v0.10.1...v0.10.2)
    * 2024-08-04 - Auto activate pre commit hooks
    * 2024-08-04 - Update demo CLI: Always update pip and pip-tools
    * 2024-08-04 - Handle KeyboardInterrupt in cli scripts.
    * 2024-08-04 - Bugfix #50 toml2dataclass(): AttributeError: 'bool' object has no attribute 'unwrap'.
    * 2024-08-02 - Fix doc link in README.md
  * [v0.10.1](https://github.com/jedie/cli-base-utilities/compare/v0.10.0...v0.10.1)
    * 2024-08-02 - Increase default timout from 5 to 15 minutes
    * 2024-08-02 - Update pre-commit hook version to cli-base-utilities v0.10.0
  * [v0.10.0](https://github.com/jedie/cli-base-utilities/compare/v0.9.0...v0.10.0)
    * 2024-08-02 - Use dateutil in get_commit_date()
    * 2024-08-02 - Replace "safety" by "pip-audit" and add tooling for it.
    * 2024-08-01 - Update manageprojects updates
  * [v0.9.0](https://github.com/jedie/cli-base-utilities/compare/v0.8.0...v0.9.0)
    * 2024-07-16 - Update project
  * [v0.8.0](https://github.com/jedie/cli-base-utilities/compare/v0.7.0...v0.8.0)
    * 2024-03-12 - Bugfix publish
    * 2024-03-12 - fix tests
    * 2024-03-12 - Split app/dev CLI into a package with autodiscovery
    * 2024-03-12 - Move click defaults
    * 2024-03-12 - Apply cookiecutter template updates
    * 2024-03-12 - Update requirements
    * 2024-01-16 - Use typeguard in tests
    * 2024-01-16 - manageprojects updates
    * 2024-01-16 - Update requirements + datetimes ;)
    * 2023-12-17 - Bugfix .pre-commit-config.yaml
  * [v0.7.0](https://github.com/jedie/cli-base-utilities/compare/v0.6.0...v0.7.0)
    * 2023-12-16 - Add "Update pre-commit hooks" to README
    * 2023-12-16 - Bugfix update_readme_history(): Use `__version__` from module
    * 2023-12-16 - NEW: "update-readme-history" git hook using "pre-commit"
    * 2023-12-16 - fix tests
    * 2023-12-16 - Bugfix type hints
    * 2023-12-16 - Add update-readme-history to app CLI
    * 2023-12-16 - Move DEMO into `./cli_base/demo/`
    * 2023-12-16 - Simplify App CLI
    * 2023-12-16 - Remove PACKAGE_ROOT from app CLI
    * 2023-12-16 - Update requirements
    * 2023-12-16 - Skip test_readme_history() on CI
  * [v0.6.0](https://github.com/jedie/cli-base-utilities/compare/v0.5.0...v0.6.0)
    * 2023-12-02 - NEW: Code style tools
  * [v0.5.0](https://github.com/jedie/cli-base-utilities/compare/v0.4.5...v0.5.0)
    * 2023-12-01 - fix flake8
    * 2023-12-01 - NEW: test utils: AssertLogs() context manager
    * 2023-12-01 - Bugfix expand_user() if SUDO_USER is the same as current user
    * 2023-12-01 - Add "run_coverage()" to "dev_tools" and polish tox, unittest, too.
    * 2023-12-01 - add tests for EraseCoverageData()
    * 2023-12-01 - Apply manageprojects updates
  * [v0.4.5](https://github.com/jedie/cli-base-utilities/compare/v0.4.4...v0.4.5)
    * 2023-11-30 - Configure unittests via "load_tests Protocol" hook
    * 2023-11-30 - Update requirements and add "flake8-bugbear"
    * 2023-11-30 - Remove function calls in function agruments
  * [v0.4.4](https://github.com/jedie/cli-base-utilities/compare/v0.4.3...v0.4.4)
    * 2023-11-01 - Bugfix "AssertionError: Expected only one line" in Git.first_commit_info()
  * [v0.4.3](https://github.com/jedie/cli-base-utilities/compare/v0.4.2...v0.4.3)
    * 2023-11-01 - Git history renderer: Collapse older entries
  * [v0.4.2](https://github.com/jedie/cli-base-utilities/compare/v0.4.1...v0.4.2)
    * 2023-11-01 - Remove duplicate git commits and keep only test last one, e.g.: "update requirements"
    * 2023-11-01 - Bugfix git history: Add commits before the first tag
  * [v0.4.1](https://github.com/jedie/cli-base-utilities/compare/v0.4.0...v0.4.1)
    * 2023-10-08 - Remove commit URLs from history and handle release a new version
    * 2023-10-08 - NEW: Generate a project history base on git commits/tags.
    * 2023-10-08 - Update requirements
    * 2023-09-26 - Update README.md
  * [v0.4.0](https://github.com/jedie/cli-base-utilities/compare/v0.3.0...v0.4.0)
    * 2023-09-24 - fix tests
    * 2023-09-24 - Add UpdateTestSnapshotFiles() Context Manager
    * 2023-09-24 - coverage: Refactor setup and add helpers
    * 2023-09-24 - Update requirements
  * [v0.3.0](https://github.com/jedie/cli-base-utilities/compare/v0.2.0...v0.3.0)
    * 2023-08-17 - Bugfix tests run in terminal
    * 2023-08-17 - update requirements
    * 2023-08-17 - NEW: cli_base.cli_tools.git and cli_base.cli_tools.version_info
  * [v0.2.0](https://github.com/jedie/cli-base-utilities/compare/d89f23b...v0.2.0)
    * 2023-08-09 - Project setup updates
    * 2023-05-22 - Update README.md
    * 2023-05-22 - Rename project "cli-base" to "cli-base-utilities"
    * 2023-05-22 - Add github CI config
    * 2023-05-22 - Add subprocess_utils from manageprojects
    * 2023-05-21 - init

  </details>


  [comment]: <> (✂✂✂ auto generated history end ✂✂✂)


pkgId: 67f9f6b7b90b9477533c8e3023728da534883750543492b32d4cace55bf635b3
name: python-cli-base-utilities
arch: src
version: 0.15.0
epoch: 0
release: 1
summary: Helpers to bild a CLI program
url: https://pypi.org/project/cli-base-utilities/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-base-utilities-0.15.0-1.src.rpm
checksum_type: sha256
description:
  [![tests](https://github.com/jedie/cli-base-utilities/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/jedie/cli-base-utilities/actions/workflows/tests.yml)
  [![codecov](https://codecov.io/github/jedie/cli-base-utilities/branch/main/graph/badge.svg)](https://app.codecov.io/github/jedie/cli-base-utilities)
  [![cli-base-utilities @ PyPi](https://img.shields.io/pypi/v/cli-base-utilities?label=cli-base-utilities%20%40%20PyPi)](https://pypi.org/project/cli-base-utilities/)
  [![Python Versions](https://img.shields.io/pypi/pyversions/cli-base-utilities)](https://github.com/jedie/cli-base-utilities/blob/main/pyproject.toml)
  [![License GPL-3.0-or-later](https://img.shields.io/pypi/l/cli-base-utilities)](https://github.com/jedie/cli-base-utilities/blob/main/LICENSE)

  Helpers to build a CLI program and some useful tools for CLI programs.

  ```
  pip install cli-base-utilities
  ```




  Some of the features are:

  * [`run_pip_audit()` to run `pip-audit` with configuration from `pyproject.toml`](https://github.com/jedie/cli-base-utilities/blob/main/docs/pip_audit.md)

  TODO: Document all features here ;)




  ```bash
  ~$ git clone https://github.com/jedie/cli-base-utilities.git
  ~$ cd cli-base-utilities
  ~/cli-base-utilities$ ./dev-cli.py --help
  ```




  [comment]: <> (✂✂✂ auto generated dev help start ✂✂✂)
  ```
  usage: ./dev-cli.py [-h]
                      {check-code-style,coverage,fix-code-style,install,mypy,pip-audit,publish,test,
  tox,update,update-test-snapshot-files,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help        show this help message and exit                                              │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {check-code-style,coverage,fix-code-style,install,mypy,pip-audit,publish,test,tox,update,upda… │
  │     check-code-style                                                                           │
  │                   Check code style by calling darker + flake8                                  │
  │     coverage      Run tests and show coverage report.                                          │
  │     fix-code-style                                                                             │
  │                   Fix code style of all cli_base source code files via darker                  │
  │     install       Run pip-sync and install 'cli_base' via pip as editable.                     │
  │     mypy          Run Mypy (configured in pyproject.toml)                                      │
  │     pip-audit     Run pip-audit check against current requirements files                       │
  │     publish       Build and upload this project to PyPi                                        │
  │     test          Run unittests                                                                │
  │     tox           Run tox                                                                      │
  │     update        Update "requirements*.txt" dependencies files                                │
  │     update-test-snapshot-files                                                                 │
  │                   Update all test snapshot files (by remove and recreate all snapshot files)   │
  │     version       Print version and exit                                                       │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated dev help end ✂✂✂)




  [comment]: <> (✂✂✂ auto generated app help start ✂✂✂)
  ```
  usage: ./cli.py [-h] {update-readme-history,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help        show this help message and exit                                              │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {update-readme-history,version}                                                                │
  │     update-readme-history                                                                      │
  │                   Update project history base on git commits/tags in README.md Will be exited  │
  │                   with 1 if the README.md was updated otherwise with 0.                        │
  │                                                                                                │
  │                   Also, callable via e.g.:                                                     │
  │                       python -m cli_base update-readme-history -v                              │
  │     version       Print version and exit                                                       │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated app help end ✂✂✂)




  [comment]: <> (✂✂✂ auto generated demo help start ✂✂✂)
  ```
  usage: ./demo-cli.py [-h]
                       {demo-endless-loop,demo-verbose-check-output-error,edit-settings,print-settin
  gs,systemd-debug,systemd-remove,systemd-setup,systemd-status,systemd-stop,version}



  ╭─ options ──────────────────────────────────────────────────────────────────────────────────────╮
  │ -h, --help                                                                                     │
  │     show this help message and exit                                                            │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ╭─ subcommands ──────────────────────────────────────────────────────────────────────────────────╮
  │ {demo-endless-loop,demo-verbose-check-output-error,edit-settings,print-settings,systemd-debug… │
  │     demo-endless-loop                                                                          │
  │     Just a useless example command, used in systemd DEMO: It just print some information in a  │
  │     endless loop.                                                                              │
  │     demo-verbose-check-output-error                                                            │
  │     DEMO for a error calling cli_base.cli_tools.subprocess_utils.verbose_check_output()        │
  │     edit-settings                                                                              │
  │     Edit the settings file. On first call: Create the default one.                             │
  │     print-settings                                                                             │
  │     Display (anonymized) MQTT server username and password                                     │
  │     systemd-debug                                                                              │
  │     Print Systemd service template + context + rendered file content.                          │
  │     systemd-remove                                                                             │
  │     Write Systemd service file, enable it and (re-)start the service. (May need sudo)          │
  │     systemd-setup                                                                              │
  │     Write Systemd service file, enable it and (re-)start the service. (May need sudo)          │
  │     systemd-status                                                                             │
  │     Display status of systemd service. (May need sudo)                                         │
  │     systemd-stop                                                                               │
  │     Stops the systemd service. (May need sudo)                                                 │
  │     version                                                                                    │
  │     Print version and exit                                                                     │
  ╰────────────────────────────────────────────────────────────────────────────────────────────────╯
  ```
  [comment]: <> (✂✂✂ auto generated demo help end ✂✂✂)




  Add a test case similar to [cli_base/tests/test_readme_history.py](https://github.com/jedie/cli-base-utilities/blob/main/cli_base/tests/test_readme_history.py) into your project.
  Add the needed `start`/`end` comments into your README.

  To make a new release, do this:

  * Increase your project version number
  * Run tests to update the README
  * commit the changes
  * Create release

  It's recommended to use git hookd (via [pre-commit](https://pre-commit.com/)) to update the README.
  For this, add in your `pyproject.toml`:

  ```toml
  [tool.cli_base]
  version_module_name = "<your_package>" # Must provide the `__version__` attribute
  ```

  Copy&paste [.pre-commit-config.yaml](https://github.com/jedie/cli-base-utilities/blob/main/.pre-commit-config.yaml) into your project.

  Add `pre-commit` to your requirements and install the git hooks by:

  ```bash
  .venv/bin/pre-commit install
  .venv/bin/pre-commit autoupdate
  ```



  Update version in `.pre-commit-config.yaml` and make a release.

  The Problem: The hooks are broken, if the "new" version is not tagged yet.
  To create a release, it's possible to use all git commands (commit, push, etc) with `--no-verify` to skip the hooks.

  It's easier to temporarily uninstall the hooks, create the release and install the hooks again, e.g.:

  ```bash
  .../cli-base-utilities$ .venv/bin/pre-commit uninstall

  .../cli-base-utilities$ .venv/bin/pre-commit install
  ```





  `cli_base.run_pip_audit.run_pip_audit()` works now with `uv` base projects instead of `pip-tools`.




  [comment]: <> (✂✂✂ auto generated history start ✂✂✂)

  * [v0.15.0](https://github.com/jedie/cli-base-utilities/compare/v0.14.0...v0.15.0)
    * 2024-12-03 - Restructure cli test utils
    * 2024-12-03 - Remove tyro work-a-round
  * [v0.14.0](https://github.com/jedie/cli-base-utilities/compare/v0.13.1...v0.14.0)
    * 2024-11-21 - Use tyro.extras.SubcommandApp()
    * 2024-11-21 - Update "install" command and use uv
    * 2024-11-21 - Switch from pip-tools to uv
  * [v0.13.1](https://github.com/jedie/cli-base-utilities/compare/v0.13.0...v0.13.1)
    * 2024-09-26 - Bugfix missing click. Add it for Backward compatibility
  * [v0.13.0](https://github.com/jedie/cli-base-utilities/compare/v0.12.0...v0.13.0)
    * 2024-09-26 - Add Helper for tyro and replace click with tyro in own CLIs

  <details><summary>Expand older history entries ...</summary>

  * [v0.12.0](https://github.com/jedie/cli-base-utilities/compare/v0.11.0...v0.12.0)
    * 2024-09-25 - Add debug log to update_readme_history call
    * 2024-09-25 - Simplify AssertCliHelpInReadme to a flat function
    * 2024-09-25 - Apply manage projects updates
    * 2024-09-25 - Update requirements
  * [v0.11.0](https://github.com/jedie/cli-base-utilities/compare/v0.10.3...v0.11.0)
    * 2024-08-30 - Apply manageprojects updates, e.g.: Set min. Python to 3.11+
    * 2024-08-30 - NEW: EncloseRuleContext
  * [v0.10.3](https://github.com/jedie/cli-base-utilities/compare/v0.10.2...v0.10.3)
    * 2024-08-05 - Bugfix unchanable boolean flags in toml settings
  * [v0.10.2](https://github.com/jedie/cli-base-utilities/compare/v0.10.1...v0.10.2)
    * 2024-08-04 - Auto activate pre commit hooks
    * 2024-08-04 - Update demo CLI: Always update pip and pip-tools
    * 2024-08-04 - Handle KeyboardInterrupt in cli scripts.
    * 2024-08-04 - Bugfix #50 toml2dataclass(): AttributeError: 'bool' object has no attribute 'unwrap'.
    * 2024-08-02 - Fix doc link in README.md
  * [v0.10.1](https://github.com/jedie/cli-base-utilities/compare/v0.10.0...v0.10.1)
    * 2024-08-02 - Increase default timout from 5 to 15 minutes
    * 2024-08-02 - Update pre-commit hook version to cli-base-utilities v0.10.0
  * [v0.10.0](https://github.com/jedie/cli-base-utilities/compare/v0.9.0...v0.10.0)
    * 2024-08-02 - Use dateutil in get_commit_date()
    * 2024-08-02 - Replace "safety" by "pip-audit" and add tooling for it.
    * 2024-08-01 - Update manageprojects updates
  * [v0.9.0](https://github.com/jedie/cli-base-utilities/compare/v0.8.0...v0.9.0)
    * 2024-07-16 - Update project
  * [v0.8.0](https://github.com/jedie/cli-base-utilities/compare/v0.7.0...v0.8.0)
    * 2024-03-12 - Bugfix publish
    * 2024-03-12 - fix tests
    * 2024-03-12 - Split app/dev CLI into a package with autodiscovery
    * 2024-03-12 - Move click defaults
    * 2024-03-12 - Apply cookiecutter template updates
    * 2024-03-12 - Update requirements
    * 2024-01-16 - Use typeguard in tests
    * 2024-01-16 - manageprojects updates
    * 2024-01-16 - Update requirements + datetimes ;)
    * 2023-12-17 - Bugfix .pre-commit-config.yaml
  * [v0.7.0](https://github.com/jedie/cli-base-utilities/compare/v0.6.0...v0.7.0)
    * 2023-12-16 - Add "Update pre-commit hooks" to README
    * 2023-12-16 - Bugfix update_readme_history(): Use `__version__` from module
    * 2023-12-16 - NEW: "update-readme-history" git hook using "pre-commit"
    * 2023-12-16 - fix tests
    * 2023-12-16 - Bugfix type hints
    * 2023-12-16 - Add update-readme-history to app CLI
    * 2023-12-16 - Move DEMO into `./cli_base/demo/`
    * 2023-12-16 - Simplify App CLI
    * 2023-12-16 - Remove PACKAGE_ROOT from app CLI
    * 2023-12-16 - Update requirements
    * 2023-12-16 - Skip test_readme_history() on CI
  * [v0.6.0](https://github.com/jedie/cli-base-utilities/compare/v0.5.0...v0.6.0)
    * 2023-12-02 - NEW: Code style tools
  * [v0.5.0](https://github.com/jedie/cli-base-utilities/compare/v0.4.5...v0.5.0)
    * 2023-12-01 - fix flake8
    * 2023-12-01 - NEW: test utils: AssertLogs() context manager
    * 2023-12-01 - Bugfix expand_user() if SUDO_USER is the same as current user
    * 2023-12-01 - Add "run_coverage()" to "dev_tools" and polish tox, unittest, too.
    * 2023-12-01 - add tests for EraseCoverageData()
    * 2023-12-01 - Apply manageprojects updates
  * [v0.4.5](https://github.com/jedie/cli-base-utilities/compare/v0.4.4...v0.4.5)
    * 2023-11-30 - Configure unittests via "load_tests Protocol" hook
    * 2023-11-30 - Update requirements and add "flake8-bugbear"
    * 2023-11-30 - Remove function calls in function agruments
  * [v0.4.4](https://github.com/jedie/cli-base-utilities/compare/v0.4.3...v0.4.4)
    * 2023-11-01 - Bugfix "AssertionError: Expected only one line" in Git.first_commit_info()
  * [v0.4.3](https://github.com/jedie/cli-base-utilities/compare/v0.4.2...v0.4.3)
    * 2023-11-01 - Git history renderer: Collapse older entries
  * [v0.4.2](https://github.com/jedie/cli-base-utilities/compare/v0.4.1...v0.4.2)
    * 2023-11-01 - Remove duplicate git commits and keep only test last one, e.g.: "update requirements"
    * 2023-11-01 - Bugfix git history: Add commits before the first tag
  * [v0.4.1](https://github.com/jedie/cli-base-utilities/compare/v0.4.0...v0.4.1)
    * 2023-10-08 - Remove commit URLs from history and handle release a new version
    * 2023-10-08 - NEW: Generate a project history base on git commits/tags.
    * 2023-10-08 - Update requirements
    * 2023-09-26 - Update README.md
  * [v0.4.0](https://github.com/jedie/cli-base-utilities/compare/v0.3.0...v0.4.0)
    * 2023-09-24 - fix tests
    * 2023-09-24 - Add UpdateTestSnapshotFiles() Context Manager
    * 2023-09-24 - coverage: Refactor setup and add helpers
    * 2023-09-24 - Update requirements
  * [v0.3.0](https://github.com/jedie/cli-base-utilities/compare/v0.2.0...v0.3.0)
    * 2023-08-17 - Bugfix tests run in terminal
    * 2023-08-17 - update requirements
    * 2023-08-17 - NEW: cli_base.cli_tools.git and cli_base.cli_tools.version_info
  * [v0.2.0](https://github.com/jedie/cli-base-utilities/compare/d89f23b...v0.2.0)
    * 2023-08-09 - Project setup updates
    * 2023-05-22 - Update README.md
    * 2023-05-22 - Rename project "cli-base" to "cli-base-utilities"
    * 2023-05-22 - Add github CI config
    * 2023-05-22 - Add subprocess_utils from manageprojects
    * 2023-05-21 - init

  </details>


  [comment]: <> (✂✂✂ auto generated history end ✂✂✂)


pkgId: 661e81641244808b21d70d9a50cbf53da5f7c58d67bfbe7a825b97553bb774c6
name: python-cli-command-parser
arch: src
version: 2024.11.2
epoch: 0
release: 1
summary: CLI Command Parser
url: https://github.com/dskrypa/cli_command_parser
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-command-parser-2024.11.2-1.src.rpm
checksum_type: sha256
description:
  Python versions 3.9 and above are currently supported.  The last release of CLI Command Parser that supported 3.8 was
  2024-09-07.  Support for Python 3.8 `officially ended on 2024-10-07 <https://devguide.python.org/versions/>`__.
  Links
  *****
  - Documentation: https://dskrypa.github.io/cli_command_parser/
  - Example Scripts: https://github.com/dskrypa/cli_command_parser/tree/main/examples
  - PyPI Releases: https://pypi.org/project/cli-command-parser/
  - Source Code: https://github.com/dskrypa/cli_command_parser
  - Issue Tracker: https://github.com/dskrypa/cli_command_parser/issues


pkgId: 1d82aeebcac6719acdb02078ef588b4a36ff298bb89fe8cf47ea240e505ab256
name: python-cli-command-parser
arch: src
version: 2024.9.7
epoch: 0
release: 1
summary: CLI Command Parser
url: https://github.com/dskrypa/cli_command_parser
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-command-parser-2024.9.7-1.src.rpm
checksum_type: sha256
description:
  Python versions 3.8 and above are currently supported.  The last release of CLI Command Parser that supported 3.7 was
  2023-04-30.  Support for Python 3.7 `officially ended on 2023-06-27 <https://devguide.python.org/versions/>`__.
  When using Python 3.8, some additional packages that backport functionality that was added in later Python versions
  are required for compatibility.
  To use the argparse to cli-command-parser conversion script with Python 3.8, there is a dependency on
  `astunparse <https://astunparse.readthedocs.io>`__.  If you are using Python 3.9 or above, then ``astunparse`` is not
  necessary because the relevant code was added to the stdlib ``ast`` module.  If you're unsure, you can install
  cli-command-parser with the following command to automatically handle whether that extra dependency is needed or not::
      $ pip install -U cli-command-parser[conversion]
  Links
  *****
  - Documentation: https://dskrypa.github.io/cli_command_parser/
  - Example Scripts: https://github.com/dskrypa/cli_command_parser/tree/main/examples
  - PyPI Releases: https://pypi.org/project/cli-command-parser/
  - Source Code: https://github.com/dskrypa/cli_command_parser
  - Issue Tracker: https://github.com/dskrypa/cli_command_parser/issues


pkgId: 8f8adb8325eff64993020091c11a8a83ca37cc6d7514c0b13168934990e5dc3e
name: python-cli-exit-tools
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: functions to exit an cli application properly
url: https://github.com/bitranox/cli_exit_tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-exit-tools-1.2.6-1.src.rpm
checksum_type: sha256
description:
  Version v1.2.6 as of 2023-07-14 see `Changelog`_
  |build_badge| |codeql| |license| |jupyter| |pypi|
  |pypi-downloads| |black| |codecov| |cc_maintain| |cc_issues| |cc_coverage| |snyk|
  small toolset to properly exit a cli application:
  - print the traceback information (can be set with commandline option)
  - get a proper exit code from the Exception
  - flush the streams, to make sure output is written in proper order


pkgId: eaaa8c6a36f04c76055943e39ae0314b169de7f1edc746c60afaa5b21d058fea
name: python-cli-exit-tools
arch: src
version: 1.2.7
epoch: 0
release: 1
summary: functions to exit an cli application properly
url: https://github.com/bitranox/cli_exit_tools
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-exit-tools-1.2.7-1.src.rpm
checksum_type: sha256
description:
  Version v1.2.7 as of 2024-10-02 see `Changelog`_
  |build_badge| |codeql| |license| |jupyter| |pypi|
  |pypi-downloads| |black| |codecov| |cc_maintain| |cc_issues| |cc_coverage| |snyk|
  small toolset to properly exit a cli application:
  - print the traceback information (can be set with commandline option)
  - get a proper exit code from the Exception
  - flush the streams, to make sure output is written in proper order


pkgId: 6cb56951957a9b3bd2fb65151bf47fc40a48dfd7363c30782d2ba2c640c9dd1f
name: python-cli-lite
arch: src
version: 0.10.2
epoch: 0
release: 1
summary: A simple framework to build a cli tool, base on Alconna
url: https://github.com/RF-Tar-Railt/cli-lite
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-lite-0.10.2-1.src.rpm
checksum_type: sha256
description:
  A simple framework to build a cli tool. Base on [`Alconna`](https://github.com/ArcletProject/Alconna)



  ```shell
  pip install cli-lite
  ```



  write as sample:

  ```python

  from clilte import BasePlugin, CommandLine, PluginMetadata
  from arclet.alconna import Alconna, Arparma, Args, CommandMeta, Option


  class MyPlugin(BasePlugin):

      def init(self) -> Alconna | str:
          return Alconna("hello", Args["name", str], meta=CommandMeta("test command"))

      def meta(self) -> PluginMetadata:
          return PluginMetadata("hello", "0.0.1", "my first plugin", ["dev"], ["john"])

      def dispatch(self, result: Arparma) -> bool | None:
          return print(f"Hello! {result.name}")

      @classmethod
      def supply_options(cls) -> list[Option] | None:
          return


  if __name__ == '__main__':
      cli = CommandLine(title="My first CLI", version="example 0.0.1")
      cli.add(MyPlugin)
      cli.main()
  ```

  and execute the line:

  ```shell
  python example.py hello world
  ```

  you will get the result:

  ```shell
  Hello! world
  ```


pkgId: adb21687b8f8d789f1964b771bb4159916844442cc04edb31afe42eeb1c3408f
name: python-cli-mcp-server
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Command line interface for MCP clients with secure execution and customizable security policies
url: https://github.com/MladenSU/cli-mcp-server
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-mcp-server-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A secure Model Context Protocol (MCP) server implementation for executing controlled command-line operations with
  comprehensive security
  features.
  ![License](https://img.shields.io/badge/license-MIT-blue.svg)
  ![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)


pkgId: f02320c357bb1cc90a5fa53638192b3138189f87dd1a8d66fe130a11c64895f9
name: python-cli-print
arch: src
version: 3.5.1
epoch: 0
release: 1
summary: Colored CLI Print
url: https://github.com/VisionNetworkProject/python-cli-print
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-print-3.5.1-1.src.rpm
checksum_type: sha256
description:
  [![PyPi Version](http://img.shields.io/pypi/v/cli-print.svg)](https://pypi.python.org/pypi/cli-print/)

  Colored CLI Print




  ``` console
  $ pip3 install cli-print
  ```




  ``` python
  import cli_print as cp
  ```


pkgId: 021073a209b95153940ad25e7c21b60dae6ae2540ab24aed2f66acd0f95a7c7f
name: python-cli-select
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A package that enables MCQ select in terminal
url: https://github.com/zlliu246/cli_select
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-select-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A package that allows MCQ select in terminal/CLI



  ```
  pip install cli_select
  ```



  use Up and Down arrow keys to select your option
  use Enter key to confirm your selection


  ```python
  from cli_select import select

  selected = select(
      "Which is your favourite fruit?",
      ["apple", "orange", "pear", "pineaple", "durian"],
      color="green",
  )

  print(f"you selected {selected}")








  ```


pkgId: c5a6624457280b397cda9fb61f909147e46789753eb14932ca7b1a824ee05a81
name: python-cli-snapsort
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A CLI tool to classify photos
url: https://github.com/Jiaaming/snapsort
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-snapsort-0.1.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="assets/snapsort-logo-main.jpg" alt="Logo" width="200">
  </p>





  **SnapSort** is a light weighted (relatively) command-line tool that helps you classify and organize your photos based on focus accuracy, exposure (overexposed/underexposed), and content (landscape/portrait). SnapSort leverages OpenCV for image processing and allows you to quickly sort your photos into categorized folders for easy management.


  - **Semantic search**: Search for images based on your prompt.
  - **Exposure Classification**: Identify overexposed and underexposed images.
  - **Find similar images**: Find similar images based on a reference image.



  You can install SnapSort using `pip`:

  ```bash
  pip install snapsort
  ```


  ```bash
  pip install --editable .
  ```


pkgId: 9f2d9c8c9fa7171ed234dadb2a9fd13e2ff3612996370c2960eaeb09a5170e52
name: python-cli-snapsort
arch: src
version: 0.1.4
epoch: 0
release: 1
summary: A CLI tool to classify photos
url: https://github.com/Jiaaming/snapsort
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-snapsort-0.1.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="assets/snapsort-logo-main.jpg" alt="Logo" width="200">
  </p>



  **SnapSort** is a light weighted (relatively) command-line tool that helps you classify and organize your photos based on focus accuracy, exposure (overexposed/underexposed), and content (landscape/portrait). SnapSort leverages OpenCV for image processing and allows you to quickly sort your photos into categorized folders for easy management.


  - **Semantic search**: Search for images based on your prompt.
  - **Find similar images**: Find similar images based on a reference image.
  - **Exposure Classification**: Identify overexposed and underexposed images.



  You can install SnapSort using `pip`:

  ```bash
  pip install cli-snapsort
  ```


  ```bash
  git clone ...
  pip install --editable .
  ```


pkgId: 5a719cc07f659a5eac964cbc66c210ab5fce2c65d1cf03ae2a407e34a6c88ea4
name: python-cli-tool-audit
arch: src
version: 3.1.0
epoch: 0
release: 1
summary: Audit for existence and version number of cli tools.
url: https://github.com/matthewdeanmartin/cli_tool_audit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-tool-audit-3.1.0-1.src.rpm
checksum_type: sha256
description:
  Verify that a list of cli tools are available. Like a requirements.txt for cli tools, but without an installer
  component. Intended to work with cli tools regardless to how they were installed, e.g. via pipx, npm, etc.

  If 100% of your tools are installed by the same package manager that can install tools from a list with desired
  versions, then you don't need this tool.

  Some useful scenarios:

  - Validating a developer's workstation instead of an "install everything" script.
  - - Validating a CI environment and failing the build when configuration has drifted
  - Validating an end user's environment before running an app where you can't install all the
    dependencies for them.



  You declare a list of cli commands and version ranges.

  The tool will run `tool --version` for each tool and make best efforts to parse the result and compare it to the
  desired version range.

  The tool then can either output a report with warnings or signal failure if something is missing, the wrong version
  or can't be determined.

  There is no universal method for getting a version number from a CLI tool, nor is there a universal orderable
  version number system, so the outcome of many check may be limited to an existence check or exact version number check.

  Here is an example run.

  ```text
  ❯ cli_tool_audit audit
  +--------+--------------------------+--------+----------+------------+----------+
  |  Tool  |          Found           | Parsed | Desired  |   Status   | Modified |
  +--------+--------------------------+--------+----------+------------+----------+
  |  java  | openjdk version "17.0.6" | 17.0.6 | >=17.0.6 | Compatible | 01/18/23 |
  |  make  |      GNU Make 3.81       | 3.81.0 |  >=3.81  | Compatible | 11/24/06 |
  |        |       Copyright (        |        |          |            |          |
  | python |      Python 3.11.1       | 3.11.1 | >=3.11.1 | Compatible | 01/13/24 |
  +--------+--------------------------+--------+----------+------------+----------+
  ```



  You will need to install it to your virtual environment if tools you are looking for are in your virtual environment.
  If all the tools are global then you can pipx install. It is on the roadmap to support a pipx install for all scenarios.

  ```shell
  pipx install cli-tool-audit
  ```



  Generate minimal config for a few tools.

  ```bash
  cli_tool_audit freeze python java make rustc
  ```

  Copy result of above into your pyproject.toml. Edit as needed, especially if you don't want snapshot versioning,
  which is probably too strict.

  Audit the environment with the current configuration.

  ```bash
  cli_tool_audit audit
  ```

  All commands

  ```text
  ❯ cli_tool_audit --help
  usage: cli_tool_audit [-h] [-V] [--verbose] [--demo {pipx,venv,npm}]
                        {interactive,freeze,audit,single,read,create,update,delete} ...

  Audit for existence and version number of cli tools.

  positional arguments:
    {interactive,freeze,audit,single,read,create,update,delete}
                          Subcommands.
      interactive         Interactively edit configuration
      freeze              Freeze the versions of specified tools
      audit               Audit environment with current configuration
      single              Audit one tool without configuration file
      read                Read and list all tool configurations
      create              Create a new tool configuration
      update              Update an existing tool configuration
      delete              Delete a tool configuration

  options:
    -h, --help            show this help message and exit
    -V, --version         Show program's version number and exit.
    --verbose             verbose output
    --demo {pipx,venv,npm}
                          Demo for values of npm, pipx or venv

      Examples:

          
          cli_tool_audit audit

          
          cli_tool_audit freeze python java make rustc
  ```

  Note. If you use the create/update commands and specify the `--version` switch, it must have an equal sign.

  Here is how to generate a freeze, a list of current versions by snapshot, for a lis tof tools. All tools will be
  check with `--version` unless they are well known.

  ```shell
  cli_tool_audit freeze python java make rustc
  ```

  This is for programmatic usage.

  ```python
  import cli_tool_audit

  print(cli_tool_audit.validate(file_path="pyproject.toml"))
  ```

  The configuration file lists the tools you expect how hints on how detect the version.

  ```toml
  [tool.cli-tools]

  pipx = { version = ">=1.0.0", version_switch = "--version" }

  brew = { version = ">=0.1.0", if_os="darwin" }

  poetry = {version = "Poetry (version 1.5.1)", schema="snapshot"}

  notepad = { schema = "existence" }

  vulture = { version = "*" }

  shellcheck = { version = "^0.8.0" }

  rustc = { version = "1.67.0" }
  ```

  See [semver3](https://python-semver.readthedocs.io/en/latest/usage/check-compatible-semver-version.html) for
  compatibility logic for versions without operators/symbols.

  See [poetry](https://python-poetry.org/docs/dependency-specification/) for version range specifiers.

  See [stackoverflow](https://stackoverflow.com/a/13874620/33264) for os names.



  Demos will discover a bunch of executables as installed in the local virtual environment, installed by pipx or
  installed by npm. It will then assume that we want the current or any version and run an audit. Since we know these
  files already exist, the failures are centered on failing to execute, failing to guess the version switch, failure
  to parse the switch or the
  tool's version switch returning a version incompatible to what the package manager reports.

  ```bash
  cli_tool_audit --demo=pipx --verbose
  cli_tool_audit --demo=venv --verbose
  cli_tool_audit --demo=npm --verbose
  ```



  Package managers do far more than check for the existence of a tool. They will install it, at the desired version
  and make sure that tools and their transitive dependencies are compatible.

  What they can't do is verify what other package managers have done.

  This captures your desired tools, versions and guarantees you have them by installing them.

  ```shell

  pip freeze>requirements.txt

  pip install -r requirements.txt
  ```

  This is the same thing, but for windows and .net centric apps.

  ```shell
  choco export requirements.txt
  choco install -y requirements.txt
  ```

  There are similar patterns, for apt, brew, npm, and so on.

  It would be foolish to try to create a package manager that supports other package managers, so features in that
  vein are out of scope.



  - [tool-audit](https://github.com/jstutters/toolaudit)
  - [dotnet-tool-list](https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-tool-list)


pkgId: 2d77f55492e215da921ea327d2f4d3e3fbc01145331ffe3ec526c61b683d9ed4
name: python-cli-toolkit
arch: src
version: 2.5.1
epoch: 0
release: 1
summary: Classes to implement CLI commands in python
url: https://github.com/hile/cli-toolkit
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli-toolkit-2.5.1-1.src.rpm
checksum_type: sha256
description:
  ![Unit Tests](https://github.com/hile/cli-toolkit/actions/workflows/unittest.yml/badge.svg)
  ![Style Checks](https://github.com/hile/cli-toolkit/actions/workflows/lint.yml/badge.svg)



  This module contains modules to implement CLI scripts by wrapping
  python argparse.ArgumentParser to user friendly utility classes.



  Main class to use is the Script class. It will get it's name from
  sys.argv[0].

  Example:

  ```python
  from cli_toolkit.script import Script

  if __name__ == '__main__':
      script = Script()
      script.add_argument('files', nargs='*', help='Files to process')
      args = script.parse_args()
      for filename in args.files:
          script.debug('PROCESSING', filename)
          script.message(filename)
  ```

  Running the example:

  ```
  > python test.py foo bar
  foo
  bar
  ```

  This is pretty straightforward ArgumentParser, except it

  * sets SIGINT handler
  * adds --debug and --quiet flags
  * adds `debug` and `message` functions which honor the debug and quiet flags



  More useful is using a script with subcommands. The subcommands require
  at least `name` class variable and should have `usage`, `description` and
  `epilog`.

  You also should implement `run` method and call script.run() to run correct
  subcommand. Arguments for subcommand parser are registered with method
  `register_parser_arguments`.

  ```python
  from cli_toolkit.script import Script
  from cli_toolkit.command import Command


  class ListCommand(Command):
      name = 'list'
      usage = 'List files'
      description = 'Lists files specified on command line'

      def register_parser_arguments(self, parser):
          parser.add_argument('files', nargs='*', help='Files to process')

      def run(self, args):
          for filename in args.files:
              self.debug('PROCESSING', filename)
              self.message(filename)


  if __name__ == '__main__':
      script = Script()
      script.add_subcommand(ListCommand(script))
      script.run()
  ```

  Running the example:

  ```bash
  > python test.py list foo bar
  foo
  bar
  ```



  The subcommands can be nested. You need to pass the parser in paren't
  register_parser_subcommand to add_subcommand.

  ```python
  from cli_toolkit.script import Script
  from cli_toolkit.command import Command


  class FilesCommand(Command):
      name = 'demo'
      usage = 'Run nested demo subcommands'

      def register_parser_arguments(self, parser):
          """
          Register 'list' command under demo subcommand
          """
          self.add_subcommand(ListCommand(self), parser)
          return parser


  class ListCommand(Command):
      name = 'list'
      usage = 'List files'
      description = 'Lists files specified on command line'

      def register_parser_arguments(self, parser):
          """
          Register 'list' command arguments
          """
          parser.add_argument('files', nargs='*', help='Files to process')
          return parser

      def run(self, args):
          if not args.files:
              self.exit(1, 'No files provided')
          for filename in args.files:
              self.debug('PROCESSING', filename)
              self.message(filename)


  if __name__ == '__main__':
      script = Script()
      script.add_subcommand(FilesCommand(script))
      script.run()
  ```

  Running the example:

  ```bash
  > python test.py demo list foo bar
  foo
  bar
  ```


pkgId: 84e6b48982796faf7e4bdf23b0eabd8ab462b7303f8248ac0be425a9d8162879
name: python-cli2
arch: src
version: 2.8.0
epoch: 0
release: 1
summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
url: https://yourlabs.io/oss/cli2
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli2-2.8.0-1.src.rpm
checksum_type: sha256
description:
  cli2 is a little library to build CLIs, which documentation is `available on
  RTFD <https://cli2.readthedocs.io/en/latest/>`_, but it comes with its own demo
  command that may as well be useful to explore Python libraries and call
  functions on the fly.
  Because, initially, cli2 was supposed to just bring Python callables on the CLI
  without even a single line of code::
      cli2 path.to.your.callable arg1 kwarg1=value
  This command was implemented again in this 10th rewrite of the CLI engine
  extracted from Playlabs, however this implementation features something pretty
  funny: cli2 is a Group subclass which overrides the default Group
  implementation based on the first argument passed on the command line.
  Basically, when you call ``cli2 path.to.module``, it will load a Group of name
  ``path.to.module`` which whill load one Command per callable in
  ``path.to.module``.
  When you call ``cli2 path.to.function`` it will execute the function.
  As a result, these three commands are strictly equivalent::
      cli2 cli2.test_node.example_function foo=bar
      cli2 cli2.test_node example_function foo=bar
  That is because cli2 generates a group with every member of the previous group!
  See for yourself with::
      cli2 help cli2.test_node
  Or just::
      cli2 cli2.test_node
  Because cli2.test_node is not a callable but a module, cli2's cli2 CLI created
  a command Group on the fly with the module and added every callable member as
  command.
  When you call a group on the command line, it displays help by default to drive
  the user.


pkgId: 2555418fa77a781f051b50b370353ad5b2e81b44edaac067ffa4b7305f245005
name: python-cli2gui
arch: src
version: 2024.3
epoch: 0
release: 1
summary: Use this module to convert a cli program to a gui
url: https://github.com/FHPythonUtils/Cli2Gui
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli2gui-2024.3-1.src.rpm
checksum_type: sha256
description:
  [![GitHub top language](https://img.shields.io/github/languages/top/FHPythonUtils/Cli2Gui.svg?style=for-the-badge&cacheSeconds=28800)](../../)
  [![Issues](https://img.shields.io/github/issues/FHPythonUtils/Cli2Gui.svg?style=for-the-badge&cacheSeconds=28800)](../../issues)
  [![License](https://img.shields.io/github/license/FHPythonUtils/Cli2Gui.svg?style=for-the-badge&cacheSeconds=28800)](/LICENSE.md)
  [![Commit activity](https://img.shields.io/github/commit-activity/m/FHPythonUtils/Cli2Gui.svg?style=for-the-badge&cacheSeconds=28800)](../../commits/master)
  [![Last commit](https://img.shields.io/github/last-commit/FHPythonUtils/Cli2Gui.svg?style=for-the-badge&cacheSeconds=28800)](../../commits/master)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/cli2gui.svg?style=for-the-badge&cacheSeconds=28800)](https://pypistats.org/packages/cli2gui)
  [![PyPI Total Downloads](https://img.shields.io/badge/dynamic/json?style=for-the-badge&label=total%20downloads&query=%24.total_downloads&url=https%3A%2F%2Fapi%2Epepy%2Etech%2Fapi%2Fv2%2Fprojects%2Fcli2gui)](https://pepy.tech/project/cli2gui)
  [![PyPI Version](https://img.shields.io/pypi/v/cli2gui.svg?style=for-the-badge&cacheSeconds=28800)](https://pypi.org/project/cli2gui)

  <!-- omit in toc -->


  <img src="readme-assets/icons/name.png" alt="Project Icon" width="750">

  **Project Description:**

  `Cli2Gui` enables you to convert command-line interface (CLI) applications into graphical user
  interfaces (GUIs) with minimal effort. Designed to accommodate a wide variety of use cases,
  this library allows developers to maintain a CLI while seamlessly enabling a GUI option for
  popular Python parsers like `argparse`, `docopt` with GUI frameworks such as `freesimplegui`,
  `dearpygui`, and more. By using `Cli2Gui`, developers can extend the accessibility of their
  applications, catering to both command-line users and those who prefer interactive graphical tools.

  With a decorator-based approach, `Cli2Gui` allows you to keep your CLI logic intact while adding
  GUI support as needed. Customization options such as theming, custom icons, and program descriptions
  make it easy to enhance the user experience. Whether you are working on small scripts or complex
  tools, `Cli2Gui` provides a flexible and user-friendly way to bridge the gap between command-line
  and graphical interfaces, offering convenience for both developers and end-users.

  - [Screenshots](#screenshots)
  - [Documentation](#documentation)
  - [Install With PIP](#install-with-pip)
  - [Language information](#language-information)
  	- [Built for](#built-for)
  - [Building](#building)
  - [Download Project](#download-project)
  	- [Clone](#clone)
  		- [Using The Command Line](#using-the-command-line)
  		- [Using GitHub Desktop](#using-github-desktop)
  	- [Download Zip File](#download-zip-file)
  - [Community Files](#community-files)
  	- [Licence](#licence)
  	- [Changelog](#changelog)
  	- [Code of Conduct](#code-of-conduct)
  	- [Contributing](#contributing)
  	- [Security](#security)
  	- [Support](#support)



  <div>
  <img src="readme-assets/screenshots/dearpygui.png" alt="dearpygui" width="600">
  <img src="readme-assets/screenshots/freesimplegui.png" alt="freesimplegui" width="600">
  </div>




  A high-level overview of how the documentation is organized organized will help you know
  where to look for certain things:

  - [Tutorials](/documentation/tutorials) take you by the hand through a series of steps to get
    started using the software. Start here if you’re new.
  - The [Technical Reference](/documentation/reference) documents APIs and other aspects of the
    machinery. This documentation describes how to use the classes and functions at a lower level
    and assume that you have a good high-level understanding of the software.
  <!--
  - The [Help](/documentation/help) guide provides a starting point and outlines common issues that you
    may have.
  -->



  ```python
  pip install cli2gui
  ```

  Head to https://pypi.org/project/cli2gui/ for more info





  This program has been written for Python versions 3.8 - 3.11 and has been tested with both 3.8 and
  3.11



  This project uses https://github.com/FHPythonUtils/FHMake to automate most of the building. This
  command generates the documentation, updates the requirements.txt and builds the library artefacts

  Note the functionality provided by fhmake can be approximated by the following

  ```sh
  handsdown  --cleanup -o documentation/reference
  poetry export -f requirements.txt --output requirements.txt
  poetry export -f requirements.txt --with dev --output requirements_optional.txt
  poetry build
  ```

  `fhmake audit` can be run to perform additional checks







  1. Press the Clone or download button in the top right
  2. Copy the URL (link)
  3. Open the command line and change directory to where you wish to
  clone to
  4. Type 'git clone' followed by URL in step 2

  	```bash
  	git clone https://github.com/FHPythonUtils/Cli2Gui
  	```

  More information can be found at
  https://help.github.com/en/articles/cloning-a-repository



  1. Press the Clone or download button in the top right
  2. Click open in desktop
  3. Choose the path for where you want and click Clone

  More information can be found at
  https://help.github.com/en/desktop/contributing-to-projects/cloning-a-repository-from-github-to-github-desktop



  1. Download this GitHub repository
  2. Extract the zip archive
  3. Copy/ move to the desired location





  MIT License
  Copyright (c) FredHappyface
  (See the [LICENSE](/LICENSE.md) for more information.)



  See the [Changelog](/CHANGELOG.md) for more information.



  Online communities include people from many backgrounds. The *Project*
  contributors are committed to providing a friendly, safe and welcoming
  environment for all. Please see the
  [Code of Conduct](https://github.com/FHPythonUtils/.github/blob/master/CODE_OF_CONDUCT.md)
   for more information.



  Contributions are welcome, please see the
  [Contributing Guidelines](https://github.com/FHPythonUtils/.github/blob/master/CONTRIBUTING.md)
  for more information.



  Thank you for improving the security of the project, please see the
  [Security Policy](https://github.com/FHPythonUtils/.github/blob/master/SECURITY.md)
  for more information.



  Thank you for using this project, I hope it is of use to you. Please be aware that
  those involved with the project often do so for fun along with other commitments
  (such as work, family, etc). Please see the
  [Support Policy](https://github.com/FHPythonUtils/.github/blob/master/SUPPORT.md)
  for more information.


pkgId: 0ec4b5ee4187653fd03d8a7008cb08f19525a2325781c60939dd0c6797b86acf
name: python-cli2webui
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: 将命令行工具转换为 Web 界面的工具
url: https://github.com/skyfireitdiy/cli2web
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli2webui-0.1.0-1.src.rpm
checksum_type: sha256
description:
  CLI2Web 是一个将命令行工具转换为 Web 界面的工具。它能自动解析命令行程序的帮助信息，生成对应的 Web 表单界面，让用户可以通过浏览器来使用命令行工具。



  - 自动解析命令行程序的帮助信息
    - 优先使用 man 手册进行解析
    - 支持短选项和长选项组合（如 -a, --all）
    - 智能识别选项参数类型（文本、数字、选择列表等）
    - 自动提取选项的有效值列表
    - 正确处理多行选项描述
    - 支持中英文帮助文档
  - 生成友好的 Web 界面
    - 根据选项类型生成对应的表单控件
    - 实时预览完整命令行
    - 提供选项的详细说明
  - 实时显示命令执行输出
  - 支持标准输入
  - 响应式设计，支持移动设备



  1. **命令解析**
     - 优先使用 man 手册获取命令帮助信息
     - 如果 man 手册不可用，回退到使用 --help
     - 通过正则表达式解析帮助信息，提取命令选项
     - 自动识别选项类型：
       - 标志选项（不需要参数）
       - 文本输入选项
       - 数字输入选项
       - 选择列表选项（带有预定义的有效值）

  2. **选项处理**
     - 智能参数识别：
       - 识别必需参数和可选参数（如 --option=VALUE 和 --option[=VALUE]）
       - 从描述中提取有效值列表
       - 根据参数名和描述判断参数类型
       - 处理可选参数标记

  3. **Web 界面**
     - 使用 Flask 作为 Web 框架
     - 使用 Socket.IO 实现实时输出
     - 采用响应式设计，提供良好的移动端体验





  ```bash
  pip install cli2webui
  ```

  安装完成后可以直接使用 `cli2webui` 命令：
  ```bash
  cli2webui <command_name>
  ```



  1. 克隆仓库：
  ```bash
  git clone https://github.com/yourusername/cli2web.git
  cd cli2web
  ```

  2. 安装包及其依赖：
  ```bash
  pip install -e .
  ```



  1. 克隆仓库：
  ```bash
  git clone https://github.com/yourusername/cli2web.git
  cd cli2web
  ```

  2. 创建并激活虚拟环境：
  ```bash
  python -m venv venv
  source venv/bin/activate  # Linux/Mac

  venv\Scripts\activate  # Windows
  ```

  3. 安装开发依赖：
  ```bash
  pip install -r requirements.txt
  ```





  基本用法：
  ```bash
  cli2webui <command_name>
  ```

  完整选项：
  ```bash
  cli2webui [-h] [--host HOST] [--port PORT] command

  位置参数:
    command            要转换的命令行工具名称

  可选参数:
    -h, --help        显示帮助信息
    --host HOST       监听的主机地址 (默认: localhost)
    --port PORT       监听的端口号 (默认: 5000)
  ```

  示例：
  ```bash

  cli2webui ls


  cli2webui --port 8080 ls


  cli2webui --host 0.0.0.0 --port 8080 ls
  ```



  基本用法：
  ```bash
  python -m cli2webui <command_name>
  ```

  完整选项：
  ```bash
  python -m cli2webui [-h] [--host HOST] [--port PORT] command
  ```

  示例：
  ```bash

  python -m cli2webui ls


  python -m cli2webui --port 8080 ls


  python -m cli2webui --host 0.0.0.0 --port 8080 ls
  ```



  启动服务后，打开浏览器访问显示的地址，例如：
  ```
  http://localhost:5000  # 默认配置
  http://localhost:8080  # 自定义端口
  ```



  1. **自动解析命令选项**
     - 支持短选项和长选项
     - 自动识别必选和可选参数
     - 智能解析选项描述

  2. **实时命令执行**
     - WebSocket 实时输出
     - 区分标准输出和错误输出
     - 显示命令执行状态和返回值

  3. **用户友好界面**
     - 响应式布局
     - 实时命令行预览
     - 参数可视化配置
     - 支持标准输入



  - **后端**
    - Python 3.8+
    - Flask
    - Flask-SocketIO
    - Eventlet

  - **前端**
    - HTML5
    - CSS3
    - JavaScript
    - Socket.IO Client



  1. **安全性**
     - 该工具目前主要用于开发环境
     - 不建议在生产环境中直接使用
     - 注意命令注入风险
     - 建议在受信任的网络环境中使用

  2. **兼容性**
     - 支持大多数标准的命令行工具
     - 某些特殊格式的帮助信息可能无法正确解析
     - 建议先测试目标命令的兼容性
     - 确保命令行工具支持 --help 选项

  3. **性能**
     - 适合短时间运行的命令
     - 对于长时间运行的命令，建议使用适当的超时设置
     - 注意内存和 CPU 使用情况
     - 避免同时执行过多命令

  4. **网络**
     - 默认监听 localhost:5000
     - 可以通过 --host 和 --port 参数配置监听地址和端口
     - 如果需要从其他设备访问，可以设置 --host 0.0.0.0
     - 注意 WebSocket 连接的稳定性
     - 建议在受信任的网络环境中使用



  1. **近期计划**
     - 添加命令历史记录
     - 支持保存常用参数配置
     - 改进命令解析准确性
     - 添加更多的错误处理

  2. **长期计划**
     - 支持更多命令行工具
     - 添加用户认证
     - 提供 API 接口
     - 支持命令管道



  1. Fork 项目
  2. 创建特性分支
  3. 提交更改
  4. 推送到分支
  5. 创建 Pull Request



  如果您在使用过程中遇到任何问题，或有任何建议，请通过以下方式反馈：

  1. 提交 Issue
  2. 发送邮件
  3. 参与讨论



  MIT License

  Copyright (c) 2024 skyfire

  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.





  ```bash

  cli2webui ls


  cli2webui --port 8080 ls


  cli2webui --host 0.0.0.0 --port 8080 ls
  ```



  以 ls 命令为例，CLI2Web 会正确解析并处理以下类型的选项：

  1. 标志选项：
  ```bash
  -a, --all                  不隐藏任何以 . 开始的项目
  ```

  2. 带必需参数选项：
  ```bash
  --block-size=SIZE         指定块大小
  --time=WORD              指定时间类型（可选值：atime, access, use, ctime, status）
  ```

  3. 带可选参数选项：
  ```bash
  --color[=WHEN]           控制是否使用颜色（可选值：always, auto, never）
  ```


pkgId: f6630ed7e903e13f5f2bf3befe3e4e38e0d3912ccdcd415e07e051ea1602bd53
name: python-cli50
arch: src
version: 8.0.1
epoch: 0
release: 1
summary: This is CS50 CLI, with which you can mount a directory inside of an Ubuntu container.
url: https://github.com/cs50/cli50
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli50-8.0.1-1.src.rpm
checksum_type: sha256
description:
  This is `cli50`, a command-line script that facilitates using [CS50 CLI](https://github.com/cs50/cli).


pkgId: 630b1586c7597034c1b019bf03200c803a282d492ed5925f406d0ebcd89b5a78
name: python-cli_tracker
arch: src
version: 0.3.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://gefyra.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cli_tracker-0.3.5-1.src.rpm
checksum_type: sha256
description:
  Allows to collect cli usage data to a Sentry instance.

  Built by: Blueshoe - the team behind Gefyra


pkgId: 2fc31390f14be89edba4936f3f561472d64a85e73d69d415204054873d6befa4
name: python-cliar
arch: src
version: 1.3.5
epoch: 0
release: 1
summary: Create CLIs with classes and type hints.
url: https://moigagoo.github.io/cliar/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cliar-1.3.5-1.src.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/cliar.svg)](https://pypi.org/project/cliar)
  [![Build Status](https://travis-ci.com/moigagoo/cliar.svg?branch=develop)](https://travis-ci.com/moigagoo/cliar)
  [![image](https://codecov.io/gh/moigagoo/cliar/branch/develop/graph/badge.svg)](https://codecov.io/gh/moigagoo/cliar)



  **Cliar** is a Python package to help you create commandline interfaces. It focuses on simplicity and extensibility:

  -   Creating a CLI is as simple as subclassing from `cliar.Cliar`.
  -   Extending a CLI is as simple as subclassing from a `cliar.Cliar` subclass.

  Cliar's mission is to let you focus on the business logic instead of building an interface for it. At the same time, Cliar doesn't want to stand in your way, so it provides the means to customize the generated CLI.




  ```shell
  $ pip install cliar
  ```

  Cliar requires Python 3.6+ and is tested on Windows, Linux, and macOS. There are no dependencies outside Python's standard library.




  Let's create a commandline calculator that adds two floats:

  ```python
  from cliar import Cliar


  class Calculator(Cliar):
      '''Calculator app.'''

      def add(self, x: float, y: float):
          '''Add two numbers.'''

          print(f'The sum of {x} and {y} is {x+y}.')


  if __name__ == '__main__':
      Calculator().parse()
  ```

  Save this code to `calc.py` and run it. Try different inputs:

  -   Valid input:

          $ python calc.py add 12 34
          The sum of 12.0 and 34.0 is 46.0.

  -   Invalid input:

          $ python calc.py add foo bar
          usage: calc.py add [-h] x y
          calc.py add: error: argument x: invalid float value: 'foo'

  -   Help:

          $ python calc.py -h
          usage: calc.py [-h] {add} ...

          Calculator app.

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

          commands:
          {add}       Available commands:
              add       Add two numbers.

  -   Help for `add` command:

          $ python calc.py add -h
          usage: calc.py add [-h] x y

          Add two numbers.

          positional arguments:
          x
          y

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

  A few things to note:

  -   It's a regular Python class with a regular Python method. You don't need to learn any new syntax to use Cliar.

  -   `add` method is converted to `add` command, its positional params are converted to positional commandline args.

  -   There is no explicit conversion to float for `x` or `y` or error handling in the `add` method body. Instead, `x` and `y` are just treated as floats. Cliar converts the types using `add`'s type hints. Invalid input doesn't even reach your code.

  -   `--help` and `-h` flags are added automatically and the help messages are generated from the docstrings.




  To invoke your CLI via an entrypoint, wrap `parse` call in a function and point to it in your `setup.py` or `pyproject.toml`.

  `calc.py`:

      ...
      def entry_point():
          Calculator().parse()

  `setup.py`:

      setup(
          ...
          entry_points = {
              'console_scripts': ['calc=calc:entry_point'],
          }
          ...
      )

  `pyproject.toml`:

      ...
      [tool.poetry.scripts]
      calc = 'calc:entry_point'




  -   [Tutorial →](https://moigagoo.github.io/cliar/tutorial/)
  -   [Cliar vs. Click vs. docopt →](https://moigagoo.github.io/cliar/comparison/)


pkgId: 083386dc5ce6df82380ff046e0387914b6f8691e1c475fa490d4e65a5c749732
name: python-cliboa
arch: src
version: 2.4.1b0
epoch: 0
release: 1
summary: application framework for ETL(ELT) processing
url: https://github.com/BrainPad/cliboa
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cliboa-2.4.1b0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/cliboa?style=flat-square)](https://pypi.org/project/cliboa)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/cliboa?style=flat-square)](https://pypi.org/project/cliboa)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/cliboa?style=flat-square)](https://pypi.org/project/cliboa)
  [![GitHub Actions](https://github.com/BrainPad/cliboa/workflows/cliboa/badge.svg)](https://github.com/BrainPad/cliboa/actions)
  [![Code Style:
  black](https://img.shields.io/badge/code%20style-black-000000.svg?style=flat-square)](https://github.com/psf/black)
  [![Contributions Welcome](https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square)](https://github.com/BrainPad/cliboa/blob/master/CONTRIBUTING.md)
  [![Repo Size](https://img.shields.io/github/repo-size/BrainPad/cliboa)](https://github.com/BrainPad/cliboa)
  [![Gitter](https://badges.gitter.im/cliboa/users.svg)](https://gitter.im/cliboa/users?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)



  * [Introction](#introduction)
    * [What is cliboa](#what-is-cliboa)
    * [Features](#features)
  * [Manual](#manual)
  * [How to Contribute](#how-to-contribute)
  * [Quick Start](#quick-start)
    * [Install cliboa](#install-cliboa)
    * [Configuration of a Simple ETL Processing](#configuration-of-a-simple-etl-processing)
    * [Directory Tree](#directory-tree)
    * [Install PyPI packages](#install-pypi-packages)
    * [Write a Scenario of ETL Processing](#write-a-scenario-of-etl-processing)
    * [Set an environment](#set-an-environment)
    * [Execute a scenario of ETL Processing](#execute-a-scenario-of-etl-processing)
  * [YAML Configuration](#yaml-configuration)
  * [Default ETL Modules](#default-etl-modules)
  * [How to Implement Additional ETL Modules](#how-to-implement-additional-etl-modules)



  cliboa is an application framework which can implement ETL(ELT) pipeline. It eases the implementation of ETL(ELT) pipeline. In this case, ETL(ELT) pipeline means the processings like fetch, transform and transfer of data between various databases, storages, and other services.
  ![](/img/cliboa_brief.png)


  - Python based framework.
  - ETL(ELT) processing is executable by YAML based configuration.
  - Additional modules for ETL(ELT) pipeline can be implemented by only a few steps if default modules not enough.


  See [MANUAL.md](/MANUAL.md)


  See [CONTRIBUTING.md](/CONTRIBUTING.md)




  Available on macOS and any Linux distributions, like Debian, Ubuntu, CentOS, REL, or etc.


  python version 3.7 or later and poetry are required. In the environemnt which pip can be used, execute as below.

  ```
  sudo pip3 install poetry
  sudo pip3 install cliboa
  ```


  After installed cliboa, 'cliboadmin' can be used as an administrator command.

  Create an executable environment of cliboa by using cliboadmin.

  ```
  $ cd /usr/local
  $ sudo cliboadmin init sample
  $ cd sample
  $ sudo cliboadmin create simple-etl
  ```


  Directory tree which was created aforementioned commands is as below.

  ```
  sample
  ├── pyproject.toml
  ├── bin
  │   └── clibomanager.py
  ├── cliboa
  │   └── conf
  ├── common
  │   ├── __init__.py
  │   ├── environment.py
  │   └── scenario
  ├── conf
  │   ├── cliboa.ini
  │   └── logging.conf
  ├── logs
  ├── project
  │   └── simple-etl
  │       ├── scenario
  │       └── scenario.yml
  ```


  ```
  $ cd sample
  $ poetry install
  ```


  As a simple etl processing, write scenario.yml in simple-etl as below.

  The following example is just download a gzip file from the local sftp server, decompress it, and upload it to the local sftp server.

  See [Examples](docs/yaml_configuration.md#examples)


  To make the above scenario available, set a local machine as a sftp server according to respective environments. Also, put "test.csv.gz" under /usr/local.


  After wrote scenario.yml and set the environment, execute a scenario by as below command.
  ```
  cd sample
  poetry run python3 bin/clibomanager.py simple-etl
  ```


  see [yaml_configuration.md](/docs/yaml_configuration.md)


  see [default_etl_modules.md](/docs/default_etl_modules.md)


  see [additional_etl_modules.md](/docs/additional_etl_modules.md)


pkgId: bf93e215ae73179531e7e417eb2a204628e7863aa547a8cfcd6b7255460bef4b
name: python-click-aliases
arch: src
version: 1.0.5
epoch: 0
release: 1
summary: Add (mutiple) aliases to a click group or command
url: https://pypi.org/project/click-aliases/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-aliases-1.0.5-1.src.rpm
checksum_type: sha256
description:
  [![build](https://travis-ci.org/click-contrib/click-aliases.svg?branch=master)](https://travis-ci.org/click-contrib/click-aliases)
  [![license](https://img.shields.io/badge/license-MIT-blue.svg?style=flat)](https://raw.githubusercontent.com/click-contrib/click-aliases/master/LICENSE)
  [![coverage](https://coveralls.io/repos/github/click-contrib/click-aliases/badge.svg?branch=master)](https://coveralls.io/github/click-contrib/click-aliases?branch=master)

  Add (multiple) aliases to a click_ group or command.

  In your [click](http://click.pocoo.org/) app:

  ```python
  import click
  from click_aliases import ClickAliasedGroup

  @click.group(cls=ClickAliasedGroup)
  def cli():
      pass

  @cli.command(aliases=['bar', 'baz', 'qux'])
  def foo():
      """Run a command."""
      click.echo('foo')
  ```

  Will result in:
  ```
  Usage: cli [OPTIONS] COMMAND [ARGS]...

  Options:
    --help  Show this message and exit.

  Commands:
    foo (bar,baz,qux)  Run a command.
  ```


pkgId: 1041a24b5c99d13f2def1316510bee0eb69c69299c2f29ba934c10c9468e35e4
name: python-click-commands-folder
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: A Click extension to read commands from a folder
description: A Click extension to load commands from Python files stored in a folder
url: https://github.com/rotoclap/click-commands-folder
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-commands-folder-1.0.1-1.src.rpm
checksum_type: sha256
rpm_license:
  MIT License  Copyright (c) 2024 Lionel ROTA  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: ac405abddffbac17d026e4c07eebb3942d54d6b202fe0abaa4602a9e356a839d
name: python-click-config-file
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Configuration file support for click applications.
url: http://github.com/phha/click_config_file
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-config-file-0.6.0-1.src.rpm
checksum_type: sha256
description:
  Easily add configuration file support to your
  `Click <http://click.pocoo.org/5/>`_ applications by adding a single
  no-arguments decorator.


pkgId: a0e2810ea489036ff69bce1e016bbe088bfcecc06ef638df199f1a802ea81412
name: python-click-configfile
arch: src
version: 0.2.3
epoch: 0
release: 1
summary: This package supports click commands that use configuration files.
url: https://github.com/click-contrib/click-configfile
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-configfile-0.2.3-1.src.rpm
checksum_type: sha256
description:
  click_ is a framework to simplify writing composable commands for
  command-line tools. This package extends the click_ functionality
  by adding support for commands that use configuration files.

  .. _click: https://click.pocoo.org/

  EXAMPLE:

  A configuration file, like:

  .. code-block:: INI

      
      [foo]
      flag = yes
      name = Alice and Bob
      numbers = 1 4 9 16 25
      filenames = foo/xxx.txt
          bar/baz/zzz.txt

      [person.alice]
      name = Alice
      birthyear = 1995

      [person.bob]
      name = Bob
      birthyear = 2001

  can be processed with:

  .. code-block:: python

      
      
      from click_configfile import ConfigFileReader, Param, SectionSchema
      from click_configfile import matches_section
      import click

      class ConfigSectionSchema(object):
          """Describes all config sections of this configuration file."""

          @matches_section("foo")
          class Foo(SectionSchema):
              name    = Param(type=str)
              flag    = Param(type=bool, default=True)
              numbers = Param(type=int, multiple=True)
              filenames = Param(type=click.Path(), multiple=True)

          @matches_section("person.*")   # Matches multiple sections
          class Person(SectionSchema):
              name      = Param(type=str)
              birthyear = Param(type=click.IntRange(1990, 2100))


      class ConfigFileProcessor(ConfigFileReader):
          config_files = ["foo.ini", "foo.cfg"]
          config_section_schemas = [
              ConfigSectionSchema.Foo,     # PRIMARY SCHEMA
              ConfigSectionSchema.Person,
          ]

          
          
          
          

          
          
          
          


      
      CONTEXT_SETTINGS = dict(default_map=ConfigFileProcessor.read_config())

      @click.command(context_settings=CONTEXT_SETTINGS)
      @click.option("-n", "--number", "numbers", type=int, multiple=True)
      @click.pass_context
      def command_with_config(ctx, numbers):
          
          for person_data_key in ctx.default_map.keys():
              if not person_data_key.startswith("person."):
                  continue
              person_data = ctx.default_map[person_data_key]
              process_person_data(person_data)    # as dict.


pkgId: 68174e1e183820ed5abbee5b13aa5895d295f6b8405cd5489279591e07b63ba6
name: python-click-creds
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Pluggable credentials storage and management for click CLI apps.
url: https://github.com/eshaan7/click-creds
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-creds-0.0.3-1.src.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/click-creds)](https://pypi.org/project/click-creds/)
  [![Build Status](https://github.com/Eshaan7/click-creds/workflows/Linter%20&%20Tests/badge.svg?branch=main)](https://github.com/Eshaan7/click-creds/actions?query=workflow%3A%22Linter+%26+Tests%22)
  [![codecov](https://codecov.io/gh/Eshaan7/click-creds/branch/main/graph/badge.svg?token=AeUhwwnaRW)](https://codecov.io/gh/Eshaan7/click-creds)
  [![CodeFactor](https://www.codefactor.io/repository/github/eshaan7/click-creds/badge)](https://www.codefactor.io/repository/github/eshaan7/click-creds)
  <a href="https://lgtm.com/projects/g/Eshaan7/click-creds/context:python">
    <img alt="Language grade: Python" src="https://img.shields.io/lgtm/grade/python/g/Eshaan7/click-creds.svg?logo=lgtm&logoWidth=18"/>
  </a>


  Pluggable credentials storage and management for [click](https://github.com/pallets/click/) CLI applications.

  Uses [`~/.netrc` file method](https://www.mkssoftware.com/docs/man4/netrc.4.asp) which is used by popular CLI applications like [Heroku CLI](https://devcenter.heroku.com/articles/authentication#netrc-file-format), AWS CLIs, etc.



  Requires python version `>=3.6`.

  ```bash
  $ pip install click-creds
  ```



  Here's an example `cli.py` file.

  ```python

  import click
  import click_creds

  @click.group(context_settings=dict(help_option_names=["-h", "--help"]))
  @click_creds.use_netrcstore(
      name="myawesomeapp",
      mapping={"login": "username", "password": "api_key", "account": "url"},
  )
  def cli():
      pass


  cli.add_command(click_creds.config_group)


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

  Now, if we execute `./cli.py config`,

  ```bash
  $ ./cli.py config
  Usage: cli.py config [OPTIONS] COMMAND [ARGS]...

    Set or view config variables

  Options:
    -h, --help  Show this message and exit.

  Commands:
    get  Echo config variables
    set  Update config variables
  ```



  Please see the [`example_project`](https://github.com/Eshaan7/click-creds/tree/main/example_project).




  All releases should be listed in the [releases tab on GitHub](https://github.com/Eshaan7/click-creds/releases).

  See [CHANGELOG](https://github.com/Eshaan7/click-creds/blob/main/.github/CHANGELOG.md) for a more detailed listing.



  This project is published with the [BSD License](LICENSE). See [https://choosealicense.com/licenses/bsd/](https://choosealicense.com/licenses/BSD/) for more information about what this means.



  - [tinynetrc](https://github.com/sloria/tinynetrc)


pkgId: 261a111332a3d50b45a1556d9a601541e634d75ca08ed71fb03215bdf02b5690
name: python-click-default-group
arch: src
version: 1.2.4
epoch: 0
release: 1
summary: click_default_group
url: https://pypi.org/project/click-default-group/
rpm_license: Public Domain
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-default-group-1.2.4-1.src.rpm
checksum_type: sha256
description:
  `DefaultGroup` is a sub class of [`click.Group`](https://click.pocoo.org/6/api/#click.Group).  But it invokes a default
  subcommand instead of showing a help message when a subcommand is not passed.
  [![Build Status](https://img.shields.io/travis/click-contrib/click-default-group.svg)](https://travis-ci.org/click-contrib/click-default-group)
  [![Coverage Status](https://img.shields.io/coveralls/click-contrib/click-default-group.svg)](https://coveralls.io/r/click-contrib/click-default-group)


pkgId: 20d43b37dafe529ebccd557a11ca49f5a26a57bba3bf63ed510a9eb213680d47
name: python-click-default-group-wheel
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: click-default-group-wheel is now click-default-group
url: https://pypi.org/project/click-default-group-wheel/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-default-group-wheel-1.2.3-1.src.rpm
checksum_type: sha256
description:
  This package has been renamed. Use `pip install click-default-group` instead.

  New package: https://pypi.org/project/click-default-group/


pkgId: 2bae2295934f8e5ce90a92a282f3633aacd8635e24c176b0e09c9e8605865637
name: python-click-didyoumean
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Enables git-like *did-you-mean* feature in click
url: https://github.com/click-contrib/click-didyoumean
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-didyoumean-0.3.1-1.src.rpm
checksum_type: sha256
description:
  |pypi| |build| |license|
  Enable git-like *did-you-mean* feature in click.
  It's as simple as this:
      import click
      from click_didyoumean import DYMGroup
      @click.group(cls=DYMGroup)
      def cli():
  |demo|


pkgId: 3ebe86ac02700a7029a8b15a0da93296d9de0a5ccca4813f492e192722132e14
name: python-click-extra
arch: src
version: 4.11.4
epoch: 0
release: 1
summary: 🌈 Drop-in replacement for Click to make user-friendly and colorful CLI
url: https://github.com/kdeldycke/click-extra
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-extra-4.11.4-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/kdeldycke/click-extra/">
      <img src="https://raw.githubusercontent.com/kdeldycke/click-extra/main/docs/assets/logo-banner.svg" alt="Click Extra">
    </a>
  </p>

  [![Last release](https://img.shields.io/pypi/v/click-extra.svg)](https://pypi.python.org/pypi/click-extra)
  [![Python versions](https://img.shields.io/pypi/pyversions/click-extra.svg)](https://pypi.python.org/pypi/click-extra)
  [![Downloads](https://static.pepy.tech/badge/click_extra/month)](https://pepy.tech/project/click_extra)
  [![Unittests status](https://github.com/kdeldycke/click-extra/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/kdeldycke/click-extra/actions/workflows/tests.yaml?query=branch%3Amain)
  [![Coverage status](https://codecov.io/gh/kdeldycke/click-extra/branch/main/graph/badge.svg)](https://app.codecov.io/gh/kdeldycke/click-extra)
  [![Documentation status](https://github.com/kdeldycke/click-extra/actions/workflows/docs.yaml/badge.svg?branch=main)](https://github.com/kdeldycke/click-extra/actions/workflows/docs.yaml?query=branch%3Amain)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7116050.svg)](https://doi.org/10.5281/zenodo.7116050)



  It should be easy to write a good CLI in Python. [Click](https://click.palletsprojects.com) makes it so. But there is still hundrends of tweaks to implement by yourself to have a user-friendly CLI.

  Click Extra is a **ready-to-use wrapper around Click** to make your CLI look good and behave well. It is a drop-in replacement with good defaults that saves lots of boilerplate code and frustration by making all parts working together.

  It also comes with [workarounds and patches](https://kdeldycke.github.io/click-extra/issues.html) that have not reached upstream yet (or are unlikely to).



  It transforms this vanilla `click` CLI:

  ![click CLI help screen](https://raw.githubusercontent.com/kdeldycke/click-extra/main/docs/assets/click-help-screen.png)

  Into this:

  ![click-extra CLI help screen](https://raw.githubusercontent.com/kdeldycke/click-extra/main/docs/assets/click-extra-screen.png)

  To undestrand how we ended up with the result above, [go read the tutorial](https://kdeldycke.github.io/click-extra/tutorial.html).



  - [Configuration file](https://kdeldycke.github.io/click-extra/config.html) loader for:
    - `TOML`
    - `YAML`
    - `JSON`, with inline and block comments (Python-style `#` and Javascript-style `//`)
    - `INI`, with extended interpolation, multi-level sections and non-native types (`list`, `set`, …)
    - `XML`
  - Automatic inference of the configuration file structure from your CLI's options
  - Remote loading of [configuration files from URLs](https://kdeldycke.github.io/click-extra/config.html#remote-url)
  - Optional [strict validation](https://kdeldycke.github.io/click-extra/config.html#strictness) of configuration
  - Respect the [default application path](https://kdeldycke.github.io/click-extra/config.html#default-folder) on each platform (XDG spec on Linux)
  - [Glob search patterns](https://kdeldycke.github.io/click-extra/config.html#pattern-matching) for configuration files
  - Respect of `CLI` > `Configuration` > `Environment` > `Defaults` [precedence](https://kdeldycke.github.io/click-extra/config.html#precedence)
  - Normalization and discoverability of environment variables
  - [`--show-params` option](https://kdeldycke.github.io/click-extra/parameters.html#show-params-option) to debug parameters defaults, values, environment variables and provenance
  - [Click parameters introspection](https://kdeldycke.github.io/click-extra/parameters.html#introspecting-parameters)
  - [Colorization of help screens](https://kdeldycke.github.io/click-extra/colorize.html) at the semantic-level of options, parameters, subheadings, choices, metavars and defaults
  - Global `show_envvar` option to display all environment variables in help screens
  - `-h`/`--help` option names (see [rant on other inconsistencies](https://blog.craftyguy.net/cmdline-help/))
  - `--color`/`--no-color` option flag
  - `--telemetry`/`--no-telemetry` flag to opt-in/out of tracking code
  - Recognize traditional environment variable conventions:
    - `NO_COLOR` from [`no-color.org`](https://no-color.org)
    - `DO_NOT_TRACK` from [`consoledonottrack.com`](https://consoledonottrack.com)
  - Colored `--version` option
  - [Colored `--verbosity` option and logs](https://kdeldycke.github.io/click-extra/logging.html)
  - `--time`/`--no-time` flag to measure duration of command execution
  - Global `show_choices` to activate selection of choices on user input prompts
  - [`.. click:example::` and `.. click:run::` Sphinx directives](https://kdeldycke.github.io/click-extra/sphinx.html) to document CLI source code and their execution
  - [Inline testing of CLI examples](https://kdeldycke.github.io/click-extra/sphinx.html#inline-tests) in documentation
  - [ANSI-capable Pygments lexers](https://kdeldycke.github.io/click-extra/pygments.html#lexers) for shell session and console output
  - [Fixes 40+ bugs](https://kdeldycke.github.io/click-extra/issues.html) from other Click-related projects
  - Rely on [Cloup](https://github.com/janluke/cloup) to add:
    - option groups
    - constraints
    - subcommands sections
    - aliases
    - command suggestion (`Did you mean <subcommand>?`)



  Check these projects to get real-life examples of `click-extra` usage:

  - ![GitHub stars](https://img.shields.io/github/stars/kdeldycke/meta-package-manager?label=%E2%AD%90&style=flat-square) [Meta Package Manager](https://github.com/kdeldycke/meta-package-manager#readme)
    \- A unifying CLI for multiple package managers.
  - ![GitHub stars](https://img.shields.io/github/stars/kdeldycke/mail-deduplicate?label=%E2%AD%90&style=flat-square) [Mail Deduplicate](https://github.com/kdeldycke/mail-deduplicate#readme) - A
    CLI to deduplicate similar emails.
  - ![GitHub stars](https://img.shields.io/github/stars/Sprocket-Security/fireproxng?label=%E2%AD%90&style=flat-square) [fireproxng](https://github.com/Sprocket-Security/fireproxng#readme) - A rewrite of the fireprox tool.
  - ![GitHub stars](https://img.shields.io/github/stars/hugolundin/badger?label=%E2%AD%90&style=flat-square) [badger-proxy](https://github.com/hugolundin/badger#readme) - An mDNS-based reverse
    proxy for naming services on a local network.

  Feel free to send a PR to add your project in this list if you are relying on Click Extra in any way.



  [Development guidelines](https://kdeldycke.github.io/meta-package-manager/development.html)
  are the same as
  [parent project `mpm`](https://github.com/kdeldycke/meta-package-manager), from
  which `click-extra` originated.


pkgId: a84877cae4e5c5d7ae8200ca79e63740f310df8fc483e599f3f9d91b3bd044bc
name: python-click-extra
arch: src
version: 4.11.7
epoch: 0
release: 1
summary: 🌈 Drop-in replacement for Click to make user-friendly and colorful CLI
url: https://github.com/kdeldycke/click-extra
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-extra-4.11.7-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/kdeldycke/click-extra/">
      <img src="https://raw.githubusercontent.com/kdeldycke/click-extra/main/docs/assets/logo-banner.svg" alt="Click Extra">
    </a>
  </p>

  [![Last release](https://img.shields.io/pypi/v/click-extra.svg)](https://pypi.python.org/pypi/click-extra)
  [![Python versions](https://img.shields.io/pypi/pyversions/click-extra.svg)](https://pypi.python.org/pypi/click-extra)
  [![Downloads](https://static.pepy.tech/badge/click_extra/month)](https://pepy.tech/project/click_extra)
  [![Unittests status](https://github.com/kdeldycke/click-extra/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/kdeldycke/click-extra/actions/workflows/tests.yaml?query=branch%3Amain)
  [![Coverage status](https://codecov.io/gh/kdeldycke/click-extra/branch/main/graph/badge.svg)](https://app.codecov.io/gh/kdeldycke/click-extra)
  [![Documentation status](https://github.com/kdeldycke/click-extra/actions/workflows/docs.yaml/badge.svg?branch=main)](https://github.com/kdeldycke/click-extra/actions/workflows/docs.yaml?query=branch%3Amain)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.7116050.svg)](https://doi.org/10.5281/zenodo.7116050)



  It should be easy to write a good CLI in Python. [Click](https://click.palletsprojects.com) makes it so. But there is still hundrends of tweaks to implement by yourself to have a user-friendly CLI.

  Click Extra is a **ready-to-use wrapper around Click** to make your CLI look good and behave well. It is a drop-in replacement with good defaults that saves lots of boilerplate code and frustration by making all parts working together.

  It also comes with [workarounds and patches](https://kdeldycke.github.io/click-extra/issues.html) that have not reached upstream yet (or are unlikely to).



  It transforms this vanilla `click` CLI:

  ![click CLI help screen](https://raw.githubusercontent.com/kdeldycke/click-extra/main/docs/assets/click-help-screen.png)

  Into this:

  ![click-extra CLI help screen](https://raw.githubusercontent.com/kdeldycke/click-extra/main/docs/assets/click-extra-screen.png)

  To undestrand how we ended up with the result above, [go read the tutorial](https://kdeldycke.github.io/click-extra/tutorial.html).



  - [Configuration file](https://kdeldycke.github.io/click-extra/config.html) loader for:
    - `TOML`
    - `YAML`
    - `JSON`
    - `INI`, with extended interpolation, multi-level sections and non-native types (`list`, `set`, …)
    - `XML`
  - Automatic inference of the configuration file structure from your CLI's options
  - Remote loading of [configuration files from URLs](https://kdeldycke.github.io/click-extra/config.html#remote-url)
  - Optional [strict validation](https://kdeldycke.github.io/click-extra/config.html#strictness) of configuration
  - Respect the [default application path](https://kdeldycke.github.io/click-extra/config.html#default-folder) on each platform (XDG spec on Linux)
  - [Glob search patterns](https://kdeldycke.github.io/click-extra/config.html#pattern-matching) for configuration files
  - Respect of `CLI` > `Configuration` > `Environment` > `Defaults` [precedence](https://kdeldycke.github.io/click-extra/config.html#precedence)
  - Normalization and discoverability of environment variables
  - [`--show-params` option](https://kdeldycke.github.io/click-extra/parameters.html#show-params-option) to debug parameters defaults, values, environment variables and provenance
  - [Click parameters introspection](https://kdeldycke.github.io/click-extra/parameters.html#introspecting-parameters)
  - [Colorization of help screens](https://kdeldycke.github.io/click-extra/colorize.html) at the semantic-level of options, parameters, subheadings, choices, metavars and defaults
  - Global `show_envvar` option to display all environment variables in help screens
  - `-h`/`--help` option names (see [rant on other inconsistencies](https://blog.craftyguy.net/cmdline-help/))
  - `--color`/`--no-color` option flag
  - `--telemetry`/`--no-telemetry` flag to opt-in/out of tracking code
  - Recognize traditional environment variable conventions:
    - `NO_COLOR` from [`no-color.org`](https://no-color.org)
    - `DO_NOT_TRACK` from [`consoledonottrack.com`](https://consoledonottrack.com)
  - Colored `--version` option
  - [Colored `--verbosity` option and logs](https://kdeldycke.github.io/click-extra/logging.html)
  - `--time`/`--no-time` flag to measure duration of command execution
  - Global `show_choices` to activate selection of choices on user input prompts
  - [`.. click:example::` and `.. click:run::` Sphinx directives](https://kdeldycke.github.io/click-extra/sphinx.html) to document CLI source code and their execution
  - [Inline testing of CLI examples](https://kdeldycke.github.io/click-extra/sphinx.html#inline-tests) in documentation
  - [ANSI-capable Pygments lexers](https://kdeldycke.github.io/click-extra/pygments.html#lexers) for shell session and console output
  - [Fixes 50+ bugs](https://kdeldycke.github.io/click-extra/issues.html) from other Click-related projects
  - Rely on [Cloup](https://github.com/janluke/cloup) to add:
    - option groups
    - constraints
    - subcommands sections
    - aliases
    - command suggestion (`Did you mean <subcommand>?`)



  Check these projects to get real-life examples of `click-extra` usage:

  - ![GitHub stars](https://img.shields.io/github/stars/kdeldycke/meta-package-manager?label=%E2%AD%90&style=flat-square) [Meta Package Manager](https://github.com/kdeldycke/meta-package-manager#readme)
    \- A unifying CLI for multiple package managers.
  - ![GitHub stars](https://img.shields.io/github/stars/kdeldycke/mail-deduplicate?label=%E2%AD%90&style=flat-square) [Mail Deduplicate](https://github.com/kdeldycke/mail-deduplicate#readme) - A
    CLI to deduplicate similar emails.
  - ![GitHub stars](https://img.shields.io/github/stars/Sprocket-Security/fireproxng?label=%E2%AD%90&style=flat-square) [fireproxng](https://github.com/Sprocket-Security/fireproxng#readme) - A rewrite of the fireprox tool.
  - ![GitHub stars](https://img.shields.io/github/stars/hugolundin/badger?label=%E2%AD%90&style=flat-square) [badger-proxy](https://github.com/hugolundin/badger#readme) - An mDNS-based reverse
    proxy for naming services on a local network.

  Feel free to send a PR to add your project in this list if you are relying on Click Extra in any way.



  [Development guidelines](https://kdeldycke.github.io/meta-package-manager/development.html)
  are the same as
  [parent project `mpm`](https://github.com/kdeldycke/meta-package-manager), from
  which `click-extra` originated.


pkgId: ea9c57fa9c92aa3088a28631c8fdd528a152308b1e3f24f575a328fa3e9f6a76
name: python-click-log
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: Logging integration for Click
url: https://github.com/click-contrib/click-log
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-log-0.4.0-1.src.rpm
checksum_type: sha256
description:
  Integrates logging with click.
  - `Documentation <https://click-log.readthedocs.org/>`_
  - `Source code <https://github.com/click-contrib/click-log>`_


pkgId: 183d41ec5b565ce7d360da28bf8f79d899c89415443a3f8d447222ab52fc9381
name: python-click-loglevel
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: Log level parameter type for Click
url: https://github.com/jwodder/click-loglevel
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-loglevel-0.5.0-1.src.rpm
checksum_type: sha256
description:
  ``click-loglevel`` requires Python 3.7 or higher.  Just use `pip
  <https://pip.pypa.io>`_ for Python 3 (You have pip, right?) to install it::
      python3 -m pip install click-loglevel


pkgId: f8cc7b75c278db38a69718be71e06f0d85f69c6eaec39149f1a51b9b9870d4ba
name: python-click-loglevel
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Log level parameter type for Click
url: https://pypi.org/project/click-loglevel/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-loglevel-0.5.1-1.src.rpm
checksum_type: sha256
description:
  ``click-loglevel`` requires Python 3.8 or higher.  Just use `pip
  <https://pip.pypa.io>`_ for Python 3 (You have pip, right?) to install it::
      python3 -m pip install click-loglevel


pkgId: 6e0e8eeeefef25d15dd37b9f5e01665fbfe89eeca7bd154c6a33d73efd1199a4
name: python-click-man
arch: src
version: 0.4.1
epoch: 0
release: 1
summary: Generate man pages for click based CLI applications
url: https://github.com/click-contrib/click-man
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-man-0.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/click-contrib/click-man.svg?branch=master)](https://travis-ci.org/click-contrib/click-man) [![PyPI Package version](https://badge.fury.io/py/click-man.svg)](https://pypi.python.org/pypi/click-man)

  Create **man pages** for [click](https://github.com/pallets/click) application as easy as this:

  ```bash
  python3 setup.py --command-packages=click_man.commands man_pages
  ```

  → Checkout the [debian packaging example](https://github.com/timofurrer/click-man#debian-packages)



  *click-man* will generate one man page per command of your click CLI application specified in `console_scripts` in your `setup.py`.



  ```bash
  pip3 install click-man
  ```

  **click-man** is also available for Python 2:

  ```bash
  pip install click-man
  ```



  The following sections describe different usage example for *click-man*.



  **click-man** provides its own command line tool which can be passed the name of
  an installed script:

  ```bash
  click-man commandname
  ```

  where `commandname` is the name of an installed `console_script` entry point.

  To specify a target directory for the man pages, use the `--target` option:

  ```bash
  click-man --target path/to/man/pages commandname
  ```



  **click-man** provides a sane setuptools command extension which can be used like the following:

  ```bash
  python3 setup.py --command-packages=click_man.commands man_pages
  ```

  or specify the man pages target directory:

  ```bash
  python3 setup.py --command-packages=click_man.commands man_pages --target path/to/man/pages
  ```



  This approach of installing man pages is problematic for various reasons:



  Python in general and with that pip and setuptools are aimed to be platform independent.
  Man pages are **not**: they are a UNIX thing which means setuptools does not provide a sane
  solution to generate and install man pages.
  We should consider using automatic man page installation only with vendor specific packaging, e.g. for `*.deb` or `*.rpm` packages.



  Even on systems that support man pages, Python packages can be installed in
  virtualenvs via pip and setuptools, which do not make commands available
  globally. In fact, one of the "features" of a virtualenv is the ability to
  install a package without affecting the main system. As it is imposable to
  ensure a man page is only generated when not installing into a virtualenv,
  auto-generated man pages would pollute the main system and not stay contained in
  the virtualenv. Additionally, as a user could install multiple different
  versions of the same package into multiple different virtualenvs on the same
  system, there is no guarantee that a globally installed man page will document
  the version and behavior available in any given virtualenv.



  First, we do not want to commit man pages to our source control.
  We want to generate them on the fly. Either
  during build or installation time.

  With setuptools and pip we face two problems:

  1. If we generate and install them during installation of the package pip does not know about the man pages and thus cannot uninstall it.
  2. If we generate them in our build process and add them to your distribution we do not have a way to prevent installation to */usr/share/man* for non-UNIX-like Operating Systems or from within virtualenvs.



  The `debhelper` packages provides a very convenient script called `dh_installman`.
  It checks for the `debian/(pkg_name.)manpages` file and it's content which is basically a line by line list of man pages or globs:

  ```
  debian/tmp/manpages/*
  ```

  We override the rule provided by `dh_installman` to generate our man pages in advance, like this:

  ```Makefile
  override_dh_installman:
  	python3 setup.py --command-packages=click_man.commands man_pages --target debian/tmp/manpages
  	dh_installman -O--buildsystem=pybuild
  ```

  Now we are able to build are debian package with the tool of your choice, e.g.:

  ```debuild -us -uc```

  Checkout a working example here: [repo debian package](https://github.com/timofurrer/click-man/tree/master/examples/debian_pkg)


pkgId: dd667a379bf2144af36795e3900a1f2bf5fe6df53f39e4c760d0b60077cbbb15
name: python-click-odoo
arch: src
version: 1.6.0
epoch: 0
release: 1
summary: Beautiful, robust CLI for Odoo
url: http://github.com/acsone/click-odoo
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-odoo-1.6.0-1.src.rpm
checksum_type: sha256
description:
  ``click-odoo`` helps you create and run beautiful and robust command line scripts
  for Odoo. It is based on the excellent Click_ library.
  Useful community-managed scripts can be found in click-odoo-contrib_.
  Quick start
  ~~~~~~~~~~~
  Check Odoo is correctly installed: ``python -c "import odoo"`` must
  work when run from another directory than the Odoo root directory.
  Install ``click-odoo``::
    pip install click-odoo
  Assuming the following script named ``list-users.py``.
     
     from __future__ import print_function
     for u in env['res.users'].search([]):
         print(u.login, u.name)
  It can be run with::
    python -m click_odoo -d dbname --log-level=error ./list-users.py
  or::
    click-odoo -d dbname --log-level=error ./list-users.py
  or::
    ./list-users.py -d dbname --log-level=error
  The other technique to create scripts looks like this. Assuming
  the following script named ``list-users2.py``.
    
    from __future__ import print_function
    import click
    import click_odoo
    @click.command()
    @click_odoo.env_options(default_log_level='error')
    @click.option('--say-hello', is_flag=True)
    def main(env, say_hello):
        if say_hello:
            click.echo("Hello!")
        for u in env['res.users'].search([]):
            print(u.login, u.name)
    if __name__ == '__main__':
        main()
  It can be run like this::
    $ ./list-users2.py --help
    Usage: list-users2.py [OPTIONS]
    Options:
      -c, --config PATH    Specify the Odoo configuration file. Other ways to
                           provide it are with the ODOO_RC or OPENERP_SERVER
                           environment variables, or ~/.odoorc (Odoo >= 10) or
                           ~/.openerp_serverrc.
      -d, --database TEXT  Specify the database name. If present, this
                           parameter takes precedence over the database
                           provided in the Odoo configuration file.
      --log-level TEXT     Specify the logging level. Accepted values depend on
                           the Odoo version, and include debug, info, warn,
                           error, critical. [default: error]
      --logfile PATH       Specify the log file.
      --rollback           Rollback the transaction even if the script
                           does not raise an exception. Note that if
                           the script itself commits, this option has no
                           effect, this is why it is not named dry run.
                           This option is implied when an interactive
                           console is started.
      --say-hello
      --help               Show this message and exit.
    $ ./list-users2.py --say-hello -d dbname
    Hello!
    admin Administrator
  Finally, you can start an interactive shell by simply typing
  ``python -m click_odoo -d dbname`` or ``click-odoo -d dbname``.
  This will launch the python REPL with an Odoo ``env`` available
  as a global variable.
  Supported Odoo versions
  ~~~~~~~~~~~~~~~~~~~~~~~
  Odoo version 11, 12, 13, 14, 15 and 16 are supported.
  An important design goal is to provide a consistent behaviour
  across Odoo versions.
    ``click-odoo`` does not mandate any particular method of installing odoo. The only
    prerequisiste is that ``import odoo`` must work when run from another directory than
    the Odoo root directory.
    You may also rely on the fact that python adds the current directory to
    ``sys.path``, so ``import odoo`` works from the Odoo root directory.
    In such case, the only working invocation method may be
    ``python -m click_odoo``.
  Database transactions
  ~~~~~~~~~~~~~~~~~~~~~
  By default ``click-odoo`` commits the transaction for you, unless your script
  raises an exception. This is so that you don't need to put explicit commits
  in your scripts, which are therefore easier to compose in larger transactions
  (provided they pass around the same env).
  There is a ``--rollback`` option to force a rollback.
  A rollback is always performed after an interactive session. If you need to
  commit changes made before or during an interactive session, use ``env.cr.commit()``.
  Logging
  ~~~~~~~
  Logging is controlled by the usual Odoo logging options (``--log-level``,
  ``--logfile``) or the Odoo configuration file.
  Note the ``--log-level`` option applies to the ``odoo`` package only.
  Command line interface (click-odoo)
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Usage: click-odoo [OPTIONS] [SCRIPT] [SCRIPT_ARGS]...
      Execute a python script in an initialized Odoo environment. The script has
      access to a 'env' global variable which is an odoo.api.Environment
      initialized for the given database. If no script is provided, the script
      is read from stdin or an interactive console is started if stdin appears
      to be a terminal.
    Options:
      -c, --config FILE               Specify the Odoo configuration file. Other
                                      ways to provide it are with the ODOO_RC or
                                      OPENERP_SERVER environment variables, or
                                      ~/.odoorc (Odoo >= 10) or
                                      ~/.openerp_serverrc.
      --addons-path TEXT              Specify the addons path. If present, this
                                      parameter takes precedence over the addons
                                      path provided in the Odoo configuration
                                      file.
      -d, --database TEXT             Specify the database name. If present, this
                                      parameter takes precedence over the database
                                      provided in the Odoo configuration file.
      --log-level TEXT                Specify the logging level. Accepted values
                                      depend on the Odoo version, and include
                                      debug, info, warn, error.  [default: info]
      --logfile FILE                  Specify the log file.
      --rollback                      Rollback the transaction even if the script
                                      does not raise an exception. Note that if
                                      the script itself commits, this option has
                                      no effect. This is why it is not named dry
                                      run. This option is implied when an
                                      interactive console is started.
      -i, --interactive / --no-interactive
                                      Inspect interactively after running the
                                      script.
      --shell-interface TEXT          Preferred shell interface for interactive
                                      mode. Accepted values are ipython, ptpython,
                                      bpython, python. If not provided they are
                                      tried in this order.
      --help                          Show this message and exit.
  Most options above are the same as ``odoo`` options and behave identically.
  Additional Odoo options can be set in the the configuration file.
  Note however that most server-related options (workers, http interface etc)
  are ignored because no server is actually started when running a script.
  An important feature of ``click-odoo`` compared to, say, ``odoo shell`` is
  the capability to pass arguments to scripts.
  In order to avoid confusion between ``click-odoo`` options and your script
  options and arguments, it is recommended to separate them with ``--``::
    click-odoo -d dbname -- list-users.py -d a b
    ./list-users.py -d dbname -- -d a b
  In both examples above, ``sys.argv[1:]`` will contain ``['-d', 'a', 'b']``
  in the script.
  API
  ~~~


pkgId: 8bd7faa490531ab4fcfa426f6c58391e9bf4660f11835158908b6102cfe7603b
name: python-click-odoo-contrib
arch: src
version: 1.19
epoch: 0
release: 1
summary: click-odoo scripts collection
url: http://github.com/acsone/click-odoo-contrib
rpm_license: LGPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-odoo-contrib-1.19-1.src.rpm
checksum_type: sha256
description:
  ``click-odoo-contrib`` is a set of useful Odoo maintenance functions.
  They are available as CLI scripts (based on click-odoo_), as well
  as composable python functions.
  Scripts
  ~~~~~~~


pkgId: 2270709a76ab6f8c5f3af3369d6c228573bfb1f66e72dd7d52a6a7ef4aaaa507
name: python-click-option-group
arch: src
version: 0.5.6
epoch: 0
release: 1
summary: Option groups missing in Click
url: https://github.com/click-contrib/click-option-group
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-option-group-0.5.6-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/click-option-group.svg)](https://pypi.python.org/pypi/click-option-group)
  [![Build status](https://travis-ci.org/click-contrib/click-option-group.svg?branch=master)](https://travis-ci.org/click-contrib/click-option-group)
  [![Coverage Status](https://coveralls.io/repos/github/click-contrib/click-option-group/badge.svg?branch=master)](https://coveralls.io/github/click-contrib/click-option-group?branch=master)
  ![Supported Python versions](https://img.shields.io/pypi/pyversions/click-option-group.svg)
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)


  **click-option-group** is a Click-extension package that adds option groups
  missing in [Click](https://github.com/pallets/click/).



  Click is a package for creating powerful and beautiful command line interfaces (CLI) in Python,
  but it has no the functionality for creating option groups.

  Option groups are convenient mechanism for logical structuring CLI, also it allows you to set
  the specific behavior and set the relationship among grouped options (mutually exclusive options for example).
  Moreover, [argparse](https://docs.python.org/3/library/argparse.html) stdlib package contains this
  functionality out of the box.

  At the same time, many Click users need this functionality.
  You can read interesting discussions about it in the following issues:

  * [issue 257](https://github.com/pallets/click/issues/257)
  * [issue 373](https://github.com/pallets/click/issues/373)
  * [issue 509](https://github.com/pallets/click/issues/509)
  * [issue 1137](https://github.com/pallets/click/issues/1137)

  The aim of this package is to provide group options with extensible functionality
  using canonical and clean API (Click-like API as far as possible).





  Install and update using pip:

  ```bash
  pip install -U click-option-group
  ```



  Here is a simple example how to use option groups in your Click-based CLI.
  Just use `optgroup` for declaring option groups by decorating
  your command function in Click-like API style.

  ```python


  import click
  from click_option_group import optgroup, RequiredMutuallyExclusiveOptionGroup

  @click.command()
  @optgroup.group('Server configuration',
                  help='The configuration of some server connection')
  @optgroup.option('-h', '--host', default='localhost', help='Server host name')
  @optgroup.option('-p', '--port', type=int, default=8888, help='Server port')
  @optgroup.option('-n', '--attempts', type=int, default=3, help='The number of connection attempts')
  @optgroup.option('-t', '--timeout', type=int, default=30, help='The server response timeout')
  @optgroup.group('Input data sources', cls=RequiredMutuallyExclusiveOptionGroup,
                  help='The sources of the input data')
  @optgroup.option('--tsv-file', type=click.File(), help='CSV/TSV input data file')
  @optgroup.option('--json-file', type=click.File(), help='JSON input data file')
  @click.option('--debug/--no-debug', default=False, help='Debug flag')
  def cli(**params):
      print(params)

  if __name__ == '__main__':
      cli()
  ```

  ```bash
  $ python app.py --help
  Usage: app.py [OPTIONS]

  Options:
    Server configuration:           The configuration of some server connection
      -h, --host TEXT               Server host name
      -p, --port INTEGER            Server port
      -n, --attempts INTEGER        The number of connection attempts
      -t, --timeout INTEGER         The server response timeout
    Input data sources: [mutually_exclusive, required]
                                    The sources of the input data
      --tsv-file FILENAME           CSV/TSV input data file
      --json-file FILENAME          JSON input data file
    --debug / --no-debug            Debug flag
    --help                          Show this message and exit.
  ```



  https://click-option-group.readthedocs.io





  * Add `optgroup.help_option` decorator to add help option to the group (PR [#50](https://github.com/click-contrib/click-option-group/pull/50))
  * Use GitHub Actions instead of Travis CI for CI
  * Delete tox runner
  * Add Python 3.11 to the setup classifiers



  * Add `tests/` directory to tarball
  * Add `tests_cov` extra dependencies for testing with coverage



  * Move frame gathering into error code path (PR [#34](https://github.com/click-contrib/click-option-group/pull/34))
  * Fix typos (PR [#37](https://github.com/click-contrib/click-option-group/pull/37))
  * PEP 561 support (PR [#42](https://github.com/click-contrib/click-option-group/pull/42))
  * Update docs dependencies and Travis CI Python version matrix (PR [#43](https://github.com/click-contrib/click-option-group/pull/43))



  * Update Click dependency version to `<9` (Issue [#33](https://github.com/click-contrib/click-option-group/issues/33))



  * Do not use default option group name. An empty group name will not be displayed
  * Slightly edited error messages
  * All arguments except `name` in `optgroup` decorator must be keyword-only



  * Fix incompatibility with autocomplete: out of the box Click completion and click-repl (Issue [#14](https://github.com/click-contrib/click-option-group/issues/14))



  * Add `AllOptionGroup` class: all options from the group must be set or none must be set (PR [#13](https://github.com/click-contrib/click-option-group/pull/13))
  * Fix type hints
  * Update docs



  * Support multi-layer wrapped functions (PR [#10](https://github.com/click-contrib/click-option-group/pull/10))
  * Fix flake8 issues



  * Add `hidden=True` to `_GroupTitleFakeOption` as a temporary workaroud for issue [#4](https://github.com/click-contrib/click-option-group/issues/4)


  * Add support for hidden options inside groups (PR [#2](https://github.com/click-contrib/click-option-group/pull/2))


  * Transfer the repo to click-contrib organisation


  * Add true lineno in warning when declaring empty option group
  * Update readme


  * Use RuntimeWarning and stacklevel 2 when declaring empty option group
  * Update readme


  * Implement `RequiredMutuallyExclusiveOptionGroup` class instead of `required` argument for `MutuallyExclusiveOptionGroup`
  * Add tests with 100% coverage
  * Update readme


  * First public release


pkgId: 6f46b150a45c088ba50f08a41ccf77d8d2e932c1a67486ed047cab74ce0eee3b
name: python-click-params
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: A bunch of useful click parameter types
url: https://click-params.readthedocs.io/en/stable
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-params-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![Pypi version](https://img.shields.io/pypi/v/click-params.svg)](https://pypi.org/project/click-params/)
  ![](https://github.com/click-contrib/click_params/workflows/CI/badge.svg)
  [![Coverage Status](https://codecov.io/gh/click-contrib/click_params/branch/master/graphs/badge.svg?branch=master)](https://codecov.io/gh/click-contrib/click_params)
  [![Documentation Status](https://readthedocs.org/projects/click_params/badge/?version=latest)](https://click-params.readthedocs.io/en/latest/?badge=latest)
  [![License Apache 2](https://img.shields.io/hexpm/l/plug.svg)](http://www.apache.org/licenses/LICENSE-2.0)
  [![Code Style](https://img.shields.io/badge/code%20style-black-black)](https://github.com/click-contrib/click_params)

  A bunch of useful click parameter types.



  I often find myself wanting to use a click parameter able to handle list of strings, so I decide to put this in a library
  and I ended adding more parameter types that can be useful for various scripts including network, mathematics and so on.




  ```bash
  pip install click-params
  ```

  click-params starts working from **python 3.8**. It has a few dependencies:
  - [click](https://click.palletsprojects.com/en/7.x/) >= 7.0
  - [validators](https://validators.readthedocs.io/en/latest/)
  - [deprecated](https://deprecated.readthedocs.io/en/latest/)



  ```python
  import click
  from click_params import Ipv4AddressListParamType

  @click.command()
  @click.option('-a', '--addresses', help='list of ipv4 addresses', prompt='list of ipv4 addresses to reserve',
   type=Ipv4AddressListParamType())
  def pool(addresses):
      click.echo('reserved ips:')
      for ip in addresses:
          click.echo(ip)
  ```

  ```bash
  $ pool --addresses='192.168.1.1,192.168.1.14'
  reserved ips:
  192.168.1.1
  192.168.1.14
  ```

  You can change the default separator "," by passing it when initializing the parameter type.



  Documentation is available at https://click-params.readthedocs.io/en/latest/.


pkgId: eeec5cc3b17c45b6049019a568b1f8f4cdde8f61091d06479276b69db3bcbdf5
name: python-click-pkg
arch: src
version: 0.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Muhammadali-Akbarov/click-pkg
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-click-pkg-0.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">Click Software Development Kit</h1>

  <p align="center">
    <a href="https://t.me/+lO97J78xBj45MzBi">
      <img src="https://img.shields.io/badge/Support%20Group-blue?logo=telegram&logoColor=white" alt="Support Group on Telegram"/>
    </a>
  </p>




  ```shell
  pip install click-pkg
  ```



  Add `'click_up'` in to your settings.py

  ```python
  INSTALLED_APPS = [
      ...
      'click_up',
      ...
  ]
  ```

  Add `'click_up'` credentials inside to settings.py

  Click configuration settings.py
  ```python
  CLICK_SERVICE_ID = "your-service-id"
  CLICK_MERCHANT_ID = "your-merchant-id"
  CLICK_SECRET_KEY = "your-secret-key"
  CLICK_ACCOUNT_MODEL = "order.models.Order" # your order model path.
  CLICK_AMOUNT_FIELD = "amount" # your amount field that's belongs to your order model
  ```

  Create a new View that about handling call backs
  ```python
  from click_up.views import ClickWebhook


  class ClickWebhookAPIView(ClickWebhook):
      def successfully_payment(self, params):
          """
          successfully payment method process you can ovveride it
          """
          print(f"payment successful params: {params}")

      def cancelled_payment(self, params):
          """
          cancelled payment method process you can ovveride it
          """
          print(f"payment cancelled params: {params}")
  ```

  Add a `payme` path to core of urlpatterns:

  ```python
  from django.urls import path
  from django.urls import include

  from your_app.views import ClickWebhookAPIView


  urlpatterns = [
      ...
      path("payment/click/update/", ClickWebhookAPIView.as_view()),
      ...
  ]
  ```

  Run migrations
  ```shell
  python3 manage.py makemigrations && python manage.py migrate
  ```

  🎉 Congratulations you have been integrated click with django, keep reading docs. After successfull migrations check your admin panel and see results what happened.


