# packages

pkgId: 101b183e76fdcd83d50eb7db4f26328367a635c6aa8c71332f24f0a73ede8a97
name: python-config_wrangler-help
arch: noarch
version: 1.2.5
epoch: 0
release: 1
summary: Development documents and examples for config_wrangler
url: https://github.com/arcann/config_wrangler
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-config_wrangler-1.2.5-1.src.rpm
location_href: Packages/python-config_wrangler-help-1.2.5-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/config-wrangler.svg)](https://pypi.org/project/config-wrangler/)
  [![license](https://img.shields.io/github/license/arcann/config_wrangler.svg)](https://github.com/arcann/config_wrangler/blob/master/LICENSE)
  [![Python package](https://github.com/arcann/config_wrangler/actions/workflows/unit_test.yml/badge.svg)](https://github.com/arcann/config_wrangler/actions/workflows/unit_test.yml)

  pydantic based configuration wrangler. Handles reading multiple ini or toml files with inheritance rules and variable expansions.



  Install using your package manager of choice:
    - `poetry add config-wrangler`
    - `pip install -U config-wrangler`
    - `conda install config-wrangler -c conda-forge`.



  config.ini
  ```ini
  [S3_Source]
  bucket_name=my.exmple-bucket
  key_prefixes=processed/
  user_id=AK123456789ABC


  password_source=CONFIG_FILE
  raw_password=My secret password

  [target_database]
  dialect=sqlite
  database_name=${test_section:my_environment:source_data_dir}/example_db

  [test_section]
  my_int=123
  my_float=123.45
  my_bool=Yes
  my_str=ABC☕
  my_bytes=ABCⓁⓄⓋ☕
  my_list_auto_c=a,b,c
  my_list_auto_nl=
      a
      b
      c
  my_list_auto_pipe=a|b|c
  my_list_c=a,b,c
  my_list_python=['x','y','z']
  my_list_json=["J","S","O","N"]
  my_list_nl=
      a
      b
      c
  my_list_int_c=1,2,3
  my_tuple_c=a,b,c
  my_tuple_nl=
      a
      b
      c
  my_tuple_int_c=1,2,3
  my_dict={1: "One", 2: "Two"}
  my_dict_str_int={"one": 1, "two": 2}
  my_set={'A','B','C'}
  my_set_int=1,2,3
  my_frozenset=A,B,C
  my_date=2021-05-31
  my_time=11:55:23
  my_datetime=2021-05-31 11:23:53
  my_url=https://localhost:6553/

  [test_section.my_environment]
  name=dev

  temp_data_dir=.\temp_data\${test_section:my_environment:name}
  source_data_dir=.
  ```

  python code

  ```py
  import typing
  from datetime import date, time, datetime

  from pydantic import BaseModel, DirectoryPath, Field, AnyHttpUrl

  from config_wrangler.config_data_loaders.base_config_data_loader import BaseConfigDataLoader
  from config_wrangler.config_from_ini_env import ConfigFromIniEnv
  from config_wrangler.config_from_loaders import ConfigFromLoaders
  from config_wrangler.config_templates.config_hierarchy import ConfigHierarchy
  from config_wrangler.config_templates.aws.s3_bucket import S3_Bucket
  from config_wrangler.config_templates.sqlalchemy_database import SQLAlchemyDatabase
  from config_wrangler.config_types.path_types import AutoCreateDirectoryPath
  from config_wrangler.config_types.delimited_field import DelimitedListField


  class S3_Bucket_KeyPrefixes(S3_Bucket):
      key_prefixes: typing.List[str]


  class Environment(ConfigHierarchy):
      name: str = Field(..., env='env_name')
      temp_data_dir: AutoCreateDirectoryPath
      source_data_dir: DirectoryPath


  class TestSection(BaseModel):
      my_int: int
      my_float: float
      my_bool: bool
      my_str: str
      my_bytes: bytes
      my_list_auto_c: list
      my_list_auto_nl: list
      my_list_auto_pipe: list
      my_list_python: list
      my_list_json: list
      my_list_c: list = DelimitedListField(delimiter=',')
      my_list_nl: list = DelimitedListField(delimiter='\n')
      my_list_int_c: typing.List[int] = DelimitedListField(delimiter=',')
      my_tuple_c: tuple = DelimitedListField(delimiter=',')
      my_tuple_nl: tuple = DelimitedListField(delimiter='\n')
      my_tuple_int_c: typing.Tuple[int, int, int] = DelimitedListField(delimiter=',')
      my_dict: dict
      my_dict_str_int: typing.Dict[str, int]
      my_set: set
      my_set_int: typing.Set[int]
      my_frozenset: frozenset
      my_date: date
      my_time: time
      my_datetime: datetime
      my_url: AnyHttpUrl
      my_environment: Environment


  class ETLConfig(ConfigFromIniEnv):
      class Config:
          validate_default = True
          validate_assignment = True

      target_database: SQLAlchemyDatabase

      s3_source: S3_Bucket_KeyPrefixes

      test_section: TestSection


  class ETLConfigAnyLoaders(ETLConfig):
      def __init__(
              self,
              _config_data_loaders: typing.List[BaseConfigDataLoader],
              **kwargs: typing.Dict[str, typing.Any]
      ) -> None:
          
          ConfigFromLoaders.__init__(
              self,
              _config_data_loaders=_config_data_loaders,
              **kwargs
          )


  def main():
      config = ETLConfig(file_name='simple_example.ini')

      print(f"Temp data dir = {config.test_section.my_environment.temp_data_dir}")
      

      print(f"Source data dir = {config.test_section.my_environment.source_data_dir}")
      

      print(f"my_int = {config.test_section.my_int}")
      

      print(f"my_float = {config.test_section.my_float}")
      

      print(f"my_str = {config.test_section.my_str}")
      

      print(f"my_list_auto_c = {config.test_section.my_list_auto_c}")
      

      print(f"my_list_auto_nl = {config.test_section.my_list_auto_nl}")
      

      print(f"my_dict = {config.test_section.my_dict}")
      

      print(f"my_set = {config.test_section.my_set}")
      

      print(f"my_time = {config.test_section.my_time}")
      

      print(f"my_datetime = {config.test_section.my_datetime}")
      

      print(f"my_url = {config.test_section.my_url}")
      

      
      engine = config.target_database.get_engine()
      print(f"target_database.engine = {engine}")
      

      print("Getting S3 Data")
      bucket = config.s3_source.get_bucket()
      print(f"S3 bucket definition = {bucket}")
      for prefix in config.s3_source.key_prefixes:
          print(f"  bucket search prefix = {prefix}")
      
      
      
      


  if __name__ == '__main__':
      main()

  ```


pkgId: 2e2a6a018a14bf79c4e06bc72aaae8c69c14f2039871871dc6e5262ac7750816
name: python-confignest-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for confignest
url: https://github.com/0-1CxH/ConfigNest
rpm_license: MIT Licence
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-confignest-1.0.0-1.src.rpm
location_href: Packages/python-confignest-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  This is for arranging multiple config files.





  This is a file under the config nest subfolder, it has 3 fields:

  ```
  selection_mode: [one, all] # To include all names or select one of them
  if_no_selection: [skip, deafult, error] #  if selection_mode is `one`, and not specified which to select in view file, skip this name, use the default name (next field value), or raise error when parsing
  deafult_selection: [...] # if if_no_selection is `default`, this name will return
  ```

  - The default selection_mode=all, which means, if no manifest file (should be named CONFIGNEST_MANIFEST) all names are included.
  - The default if_no_selection=error, which means, if you do not select any of them in view file, this will raise error.


  For a demo, see the repo: 0-1CxH/megatron-wrap


pkgId: 13a51869555adc92f24dacbde115235b9dae9e0e1f3a6162dac903b7eb6e6937
name: python-conflux-web3-help
arch: noarch
version: 1.3.0
epoch: 0
release: 1
summary: Development documents and examples for conflux-web3
url: https://github.com/conflux-chain/python-conflux-sdk
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conflux-web3-1.3.0-1.src.rpm
location_href: Packages/python-conflux-web3-help-1.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/conflux-chain/python-conflux-sdk/dev?urlpath=tree/docs/en/examples/01-quickstart.ipynb)
  [![Documentation Status](https://readthedocs.org/projects/python-conflux-sdk/badge/?version=latest)](https://python-conflux-sdk.readthedocs.io/en/latest/?badge=latest)
  [![gitlocalized ](https://gitlocalize.com/repo/8175/whole_project/badge.svg)](https://gitlocalize.com/repo/8175/whole_project?utm_source=badge)
  [![codecov](https://codecov.io/github/Conflux-Chain/python-conflux-sdk/branch/dev/graph/badge.svg?token=GZ62V9QW0A)](https://codecov.io/github/Conflux-Chain/python-conflux-sdk)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/conflux-web3)

  [README](https://python-conflux-sdk.readthedocs.io/en/latest/README.html) | [中文文档](https://python-conflux-sdk.readthedocs.io/zh_CN/latest/README.html)

  - [Introduction](#introduction)
    - [Overview](#overview)
    - [Quickstart](#quickstart)
    - [Documentations](#documentations)
      - [Run Code Examples Online!](#run-code-examples-online)
      - [Localization](#localization)




  Python-conflux-sdk helps to interact with Conflux network using python. It is built over [web3.py](https://github.com/ethereum/web3.py) and most of its APIs are consistent with [web3.py](https://github.com/ethereum/web3.py).



  Requirements: python version >= 3.7

  ```bash
  $ pip3 install conflux-web3
  ```

  ```python
  from conflux_web3 import Web3

  w3 = Web3(Web3.HTTPProvider("https://test.confluxrpc.com"))

  acct = w3.account.from_key("0xxxxxxxxxxxxxx")
  w3.cfx.default_account = acct
  w3.cfx.contract(name="Faucet").claimCfx().transact().executed()

  w3.cfx.send_transaction({
      'to': w3.address.zero_address(),
      'value': 10**18,
  }).executed()
  ```

  Or you can also use API as you do in `web3.py`:

  ``` python

  from conflux_web3 import Web3
  w3 = Web3("https://test.confluxrpc.com")
  from conflux_web3.middleware import construct_sign_and_send_raw_middleware
  from cfx_account import Account
  acct = Account.create('KEYSMASH FJAFJKLDSKF7JKFDJ 1530')
  w3.middleware_onion.add(construct_sign_and_send_raw_middleware(acct))
  w3.cfx.default_account = acct.address

  transaction = {
      'to': w3.address.zero_address(),
      'value': 22,
  }
  w3.cfx.send_transaction(transaction)
  ```



  More detailed code examples are provided in the [documentation](https://python-conflux-sdk.readthedocs.io/en/latest/README.html).



  All code examples can be run online in [mybinder](https://mybinder.org/). You can click `🚀` -> `Binder` on the top bar to activate the running environment. All dependencies wil be installed and the example can be run immediately.



  Currently this documentation supports:

  * English version
  * Chinese version

  And welcome to provide translation in [GitLocalize](https://gitlocalize.com/repo/8175).


pkgId: 94480684b5841bf661681a103998599539a36f30f161c9a8e0ba7b4f7fdd154e
name: python-conn2svg-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for conn2svg
url: https://github.com/partmanager/conn2svg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conn2svg-0.0.7-1.src.rpm
location_href: Packages/python-conn2svg-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  **conn2svg** - Connector pinout drawing (SVG) generator used to automatically generate interface control documents.


pkgId: 0bb3b18269940f70f4f7221cabf7de48c7859a5e1943a5a84d65685fb5de5932
name: python-connectus-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for connectus
url: https://github.com/javierquinttana
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-connectus-0.0.5-1.src.rpm
location_href: Packages/python-connectus-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Libreria OPC UA:
  https://pypi.org/project/asyncua/#description
  https://github.com/FreeOpcUa/opcua-asyncio

  Libreria base de datos:

  TimeScaleDB:
  https://pypi.org/project/asyncpg/
  https://github.com/MagicStack/asyncpg


pkgId: 797c94a18044b34550a5204fb035d9b5317534db7b00de7dcd580ccb6ace3496
name: python-conseal-help
arch: noarch
version: 2024.12
epoch: 0
release: 1
summary: Development documents and examples for conseal
url: https://pypi.org/project/conseal/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conseal-2024.12-1.src.rpm
location_href: Packages/python-conseal-help-2024.12-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/conseal.svg)](https://pypi.org/project/conseal/)
  [![Commit CI/CD](https://github.com/uibk-uncover/conseal/actions/workflows/on_commit.yml/badge.svg?branch=dev)](https://github.com/uibk-uncover/conseal/actions/workflows/on_commit.yml)
  [![Release CI/CD](https://github.com/uibk-uncover/conseal/actions/workflows/on_release.yml/badge.svg)](https://github.com/uibk-uncover/conseal/actions/workflows/on_release.yml)
  [![Documentation Status](https://readthedocs.org/projects/conseal/badge/?version=latest)](https://conseal.readthedocs.io/)
  [![PyPI downloads](https://img.shields.io/pypi/dm/conseal)](https://pypi.org/project/conseal/)
  [![Stars](https://img.shields.io/github/stars/uibk-uncover/conseal.svg)](https://GitHub.com/uibk-uncover/conseal)
  [![Contributors](https://img.shields.io/github/contributors/uibk-uncover/conseal)](https://GitHub.com/uibk-uncover/conseal)
  [![Wheel](https://img.shields.io/pypi/wheel/conseal)](https://pypi.org/project/conseal/)
  [![Status](https://img.shields.io/pypi/status/conseal)](https://pypi.com/project/conseal/)
  [![PyPi license](https://badgen.net/pypi/license/pip/)](https://pypi.com/project/conseal/)
  [![Last commit](https://img.shields.io/github/last-commit/uibk-uncover/conseal)](https://GitHub.com/uibk-uncover/conseal)

  <img src="https://raw.githubusercontent.com/uibk-uncover/conseal/main/docs/static/seal.png" width="300" />



  Python package, containing implementations of modern image steganographic algorithms.

  > :warning: The package only simulates the embedding, which is useful for steganalysis research. We do not provide any end-to-end steganography method.




  Simply install the package with pip3


  ```bash
  pip3 install conseal
  ```

  or using the cloned repository

  ```bash
  git clone https://github.com/uibk-uncover/conseal/
  cd conseal
  pip3 install .
  ```



  | Steganography method | Domain | Reference |
  | --- | --- | --- |
  | F5 | JPEG | [Reference](https://doi.org/10.1007/3-540-45496-9_21) |
  | nsF5: no-shrinkage F5 | JPEG | [Reference](https://dde.binghamton.edu/kodovsky/pdf/Fri07-ACM.pdf) |
  | EBS: entropy block steganography | JPEG | [Reference](https://doi.org/10.1109/ICASSP.2012.6288246) |
  | UERD: uniform embedding revisited distortion | JPEG | [Reference](https://doi.org/10.1109/TIFS.2015.2473815) |
  | J-UNIWARD: JPEG-domain universal wavelet relative distortion | JPEG | [Reference](https://dde.binghamton.edu/vholub/pdf/EURASIP14_Universal_Distortion_Function_for_Steganography_in_an_Arbitrary_Domain.pdf) |
  | LSB: least significant bit | Spatial / JPEG | |
  | HILL: high-low-low | Spatial | [Reference](https://projet.liris.cnrs.fr/imagine/pub/proceedings/ICIP-2014/Papers/1569891955.pdf) |
  | HUGO: highly undetectable stego | Spatial | [Reference](http://agents.fel.cvut.cz/stegodata/pdfs/Pev10-Hugo.pdf) |
  | MiPOD: minimizing the power of optimal detector | Spatial | [Reference](https://dde.binghamton.edu/vsedighi/pdf/TIFS2015_Content_Adaptive_Steganography_by_Minimizing_Statistical_Detectability.pdf) |
  | S-UNIWARD: spatial-domain universal wavelet relative distortion | spatial | [Reference](https://dde.binghamton.edu/vholub/pdf/EURASIP14_Universal_Distortion_Function_for_Steganography_in_an_Arbitrary_Domain.pdf) |
  | WOW: wavelet obtained weights | spatial | [Reference](https://dde.binghamton.edu/vholub/pdf/WIFS12_Designing_Steganographic_Distortion_Using_Directional_Filters.pdf) |



  Import the library in Python 3

  ```python
  import conseal as cl
  ```

  This package currently contains the three JPEG steganography methods J-UNIWARD, UERD, and nsF5. The following examples show how to embed a JPEG cover image `cover.jpeg` with an embedding rate of 0.4 bits per non-zero AC coefficient (bpnzAC):



  - F5

  ```python

  jpeg = jpeglib.read_dct("cover.jpeg")


  jpeg.Y = cl.F5.simulate_single_channel(
      y0=jpeg.Y,
      alpha=0.4,
      seed=12345)


  jpeg.write_dct("stego.jpeg")
  ```

  - nsF5

  ```python

  jpeg = jpeglib.read_dct("cover.jpeg")


  jpeg.Y = cl.nsF5.simulate_single_channel(
      y0=jpeg.Y,
      alpha=0.4,
      seed=12345)


  jpeg.write_dct("stego.jpeg")
  ```

  - EBS

  ```python

  jpeg = jpeglib.read_dct("cover.jpeg")


  jpeg.Y = cl.ebs.simulate_single_channel(
      y0=jpeg.Y,
      qt=jpeg.qt[0],
      alpha=0.4,
      seed=12345)


  jpeg.write_dct("stego.jpeg")
  ```

  - UERD

  ```python

  jpeg = jpeglib.read_dct("cover.jpeg")


  jpeg.Y = cl.uerd.simulate_single_channel(
      y0=jpeg.Y,
      qt=jpeg.qt[0],
      embedding_rate=0.4,
      seed=12345)


  jpeg.write_dct("stego.jpeg")
  ```

  - J-UNIWARD

  ```python

  im0 = jpeglib.read_spatial("cover.jpeg", jpeglib.JCS_GRAYSCALE)
  jpeg = jpeglib.read_dct("cover.jpeg")


  jpeg.Y = cl.juniward.simulate_single_channel(
      x0=im0.spatial[..., 0],
      y0=jpeg.Y,
      qt=jpeg.qt[0],
      alpha=0.4,
      seed=12345)


  jpeg.write_dct("stego.jpeg")
  ```

  - HUGO

  ```python

  x0 = np.array(Image.open("cover.png"))


  x1 = cl.hugo.simulate_single_channel(
      x0=x0,
      alpha=0.4,
      seed=12345)


  Image.fromarray(x1).save("stego.png")
  ```

  - WOW


  ```python

  x0 = np.array(Image.open("cover.png"))


  x1 = cl.wow.simulate_single_channel(
      x0=x0,
      alpha=0.4,
      seed=12345)


  Image.fromarray(x1).save("stego.png")
  ```

  - S-UNIWARD

  ```python

  x0 = np.array(Image.open("cover.png"))


  x1 = cl.suniward.simulate_single_channel(
      x0=x0,
      alpha=0.4,
      seed=12345)


  Image.fromarray(x1).save("stego.png")
  ```

  - MiPOD

  ```python

  x0 = np.array(Image.open("cover.png"))


  x1 = cl.mipod.simulate_single_channel(
      x0=x0,
      alpha=0.4,
      seed=12345)


  Image.fromarray(x1).save("stego.png")
  ```

  - HILL

  ```python

  x0 = np.array(Image.open("cover.png"))


  x1 = cl.hill.simulate_single_channel(
      x0=x0,
      alpha=0.4,
      seed=12345)


  Image.fromarray(x1).save("stego.png")
  ```



  Developed by [Martin Benes](https://github.com/martinbenes1996) and [Benedikt Lorch](https://github.com/btlorch/), University of Innsbruck, 2023.

  The J-UNIWARD and nsF5 implementations in this package are based on the original Matlab code provided by the Digital Data Embedding Lab at Binghamton University.
  We also thank Patrick Bas and Rémi Cogranne for sharing their implementations of UERD and EBS with us.

  We have made our best effort to ensure that our implementations produce identical results as the original Matlab implementations. However, it is the user's responsibility to verify this.

rpm_license:
  Mozilla Public License Version 2.0 ==================================  1. Definitions --------------  1.1. "Contributor" means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software.  1.2. "Contributor Version" means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor's Contribution.  1.3. "Contribution" means Covered Software of a particular Contributor.  1.4. "Covered Software" means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof.  1.5. "Incompatible With Secondary Licenses" means  (a) that the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or  (b) that the Covered Software was made available under the terms of version 1.1 or earlier of the License, but not also under the terms of a Secondary License.  1.6. "Executable Form" means any form of the work other than Source Code Form.  1.7. "Larger Work" means a work that combines Covered Software with other material, in a separate file or files, that is not Covered Software.  1.8. "License" means this document.  1.9. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License.  1.10. "Modifications" means any of the following:  (a) any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or  (b) any new file in Source Code Form that contains any Covered Software.  1.11. "Patent Claims" of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version.  1.12. "Secondary License" means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses.  1.13. "Source Code Form" means the form of the work preferred for making modifications.  1.14. "You" (or "Your") means an individual or a legal entity exercising rights under this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.  2. License Grants and Conditions --------------------------------  2.1. Grants  Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license:  (a) under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and  (b) under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version.  2.2. Effective Date  The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution.  2.3. Limitations on Grant Scope  The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor:  (a) for any code that a Contributor has removed from Covered Software; or  (b) for infringements caused by: (i) Your and any other third party's modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or  (c) under Patent Claims infringed by Covered Software in the absence of its Contributions.  This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4).  2.4. Subsequent Licenses  No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3).  2.5. Representation  Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License.  2.6. Fair Use  This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents.  2.7. Conditions  Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1.  3. Responsibilities -------------------  3.1. Distribution of Source Form  All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You may not attempt to alter or restrict the recipients' rights in the Source Code Form.  3.2. Distribution of Executable Form  If You distribute Covered Software in Executable Form then:  (a) such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and  (b) You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients' rights in the Source Code Form under this License.  3.3. Distribution of a Larger Work  You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s).  3.4. Notices  You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies.  3.5. Application of Additional Terms  You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction.  4. Inability to Comply Due to Statute or Regulation ---------------------------------------------------  If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the Covered Software under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.  5. Termination --------------  5.1. The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60 days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30 days after Your receipt of the notice.  5.2. If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate.  5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or Your distributors under this License prior to termination shall survive termination.  ************************************************************************ *                                                                      * *  6. Disclaimer of Warranty                                           * *  -------------------------                                           * *                                                                      * *  Covered Software is provided under this License on an "as is"       * *  basis, without warranty of any kind, either expressed, implied, or  * *  statutory, including, without limitation, warranties that the       * *  Covered Software is free of defects, merchantable, fit for a        * *  particular purpose or non-infringing. The entire risk as to the     * *  quality and performance of the Covered Software is with You.        * *  Should any Covered Software prove defective in any respect, You     * *  (not any Contributor) assume the cost of any necessary servicing,   * *  repair, or correction. This disclaimer of warranty constitutes an   * *  essential part of this License. No use of any Covered Software is   * *  authorized under this License except under this disclaimer.         * *                                                                      * ************************************************************************  ************************************************************************ *                                                                      * *  7. Limitation of Liability                                          * *  --------------------------                                          * *                                                                      * *  Under no circumstances and under no legal theory, whether tort      * *  (including negligence), contract, or otherwise, shall any           * *  Contributor, or anyone who distributes Covered Software as          * *  permitted above, be liable to You for any direct, indirect,         * *  special, incidental, or consequential damages of any character      * *  including, without limitation, damages for lost profits, loss of    * *  goodwill, work stoppage, computer failure or malfunction, or any    * *  and all other commercial damages or losses, even if such party      * *  shall have been informed of the possibility of such damages. This   * *  limitation of liability shall not apply to liability for death or   * *  personal injury resulting from such party's negligence to the       * *  extent applicable law prohibits such limitation. Some               * *  jurisdictions do not allow the exclusion or limitation of           * *  incidental or consequential damages, so this exclusion and          * *  limitation may not apply to You.                                    * *                                                                      * ************************************************************************  8. Litigation -------------  Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party's ability to bring cross-claims or counter-claims.  9. Miscellaneous ----------------  This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a Contributor.  10. Versions of the License ---------------------------  10.1. New Versions  Mozilla Foundation is the license steward. Except as provided in Section 10.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number.  10.2. Effect of New Versions  You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward.  10.3. Modified Versions  If you create software not governed by this License, and you want to create a new license for such software, you may create and use a modified version of this License if you rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License).  10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses  If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached.  Exhibit A - Source Code Form License Notice -------------------------------------------  This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.  If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice.  You may add additional accurate notices of copyright ownership.  Exhibit B - "Incompatible With Secondary Licenses" Notice ---------------------------------------------------------  This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.


pkgId: 18a91bff959ecd7560a4c9a45ae84f4df393a8699a8ba2320610fba1baeeb462
name: python-consentiumthings-help
arch: noarch
version: 0.5.2
epoch: 0
release: 1
summary: Development documents and examples for consentiumthings
url: https://github.com/ConsentiumIoT/consentiumthings-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-consentiumthings-0.5.2-1.src.rpm
location_href: Packages/python-consentiumthings-help-0.5.2-1.noarch.rpm
checksum_type: sha256
description:
  ConsentiumThings is a Python API designed to facilitate sending and receiving data to and from Consentium Cloud. It provides an easy-to-use interface for developers to interact with Consentium Cloud services programmatically.


  You can install ConsentiumThings via pip:
  ```bash
  pip install consentiumthings
  ```




  ```python
  from consentiumthings import consentiumthings
  ```


  To initialize ConsentiumThings, you need to provide your board key.
  ```python
  ct = consentiumthings("board_key")
  ```


  To send data to Consentium Cloud, use the `begin_send()` method followed by `send_data()`.
  ```python
  ct.begin_send("send_key")
  ct.send_data([1, 2, 3, 4], ['info1', 'info2', 'info3'])
  ```


  To receive data from Consentium Cloud, use the `begin_receive()` method followed by `receive_data()`.
  ```python
  ct.begin_receive("receive_key", recent=False)
  print(ct.receive_data())
  ```




  - **Parameters:**
      - `board_key` (str): The key associated with the board.


  - **Parameters:**
      - `send_key` (str): The key associated with the send operation.


  - **Parameters:**
      - `data` (list): The data to be sent.
      - `info_list` (list): List of information associated with each data item.


  - **Parameters:**
      - `receive_key` (str): The key associated with the receive operation.
      - `recent` (bool, optional): If True, only the most recent data will be received. Default is False.


  - **Returns:**
      - List of received data.


  ```python
  from consentiumthings import consentiumthings


  ct = consentiumthings("board_key")


  ct.begin_send("send_key")
  ct.send_data([1, 2, 3, 4], ['info1', 'info2', 'info3'])


  ct.begin_receive("receive_key", recent=False)
  print(ct.receive_data())
  ```


  For any issues or questions regarding ConsentiumThings Python API, please contact consentium.inc@gmail.com.


  This software is licensed under the MIT License. See the LICENSE file for details.


pkgId: 0a71d0b20571d746c774ec9266d4592f44c6effa9a1cc398759efcf3daeffe5e
name: python-constrata-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for constrata
url: https://github.com/Grimrukh/constrata
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-constrata-1.1.3-1.src.rpm
location_href: Packages/python-constrata-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  An efficient Python library for parsing and building binary data structures based on the built-in `dataclasses` module,
  with support for reserving/filling fields, pure field type support (without `= field(...)`), asserted values, and more.

  Pure Python, no dependencies, MIT license. **Requires Python 3.11 or later.**



  ```shell
  pip install constrata
  ```






  Define a subclass of `constrata.BinaryStruct`, and specify the binary format, size, asserted values, and
  unpacking/packing functions of fields using `constrata` field functions with these basic arguments:
  - `binary(fmt, asserted)`
  - `binary_string(fmt_or_byte_size, asserted, encoding)`
  - `binary_array(length, element_format, asserted)`
  - `binary_pad(length, char = b'\0')`

  Each of these field functions also have other advanced arguments, such as custom unpacking/packing callbacks
  (`unpack_func` and `pack_func`), conditional field skipping based on the values of previous fields (`should_skip_func`),
  and `rstrip_null` boolean for `binary_string()`.

  All of these functions also accept standard keyword arguments for `dataclasses.field()` and pass them through directly.
  Additionally, if only a single value is `asserted` (which is always the case for `binary_pad()`), then `init=False` and
  `default=asserted` will be passed through to `field()` by default. However, your IDE (e.g. PyCharm) may not be able to
  detect these arguments; if this interferes with constructor usage, you can just specify these keywords explicitly.

  Alternatively, you can use `dataclasses.field()` directly and pass in double-asterisk metadata generators `**Binary()`,
  `**BinaryString()`, `**BinaryArray()`, and `**BinaryPad()`. This has the exact same effect as using the `constrata`
  field functions above. (These capitalised functions return a dictionary with a single key, 'metadata', which a double
  asterisk will unpack as a keyword into the `field()` call, which looks slightly nicer and more compact than having to
  pass `metadata=Binary(...)` to all the fields.) However, since Python 3.11 introduced `typing.dataclass_transform`
  (which the base `BinaryStruct` uses to reveal its automatic `dataclass` wrapper to IDEs), your IDE should be able to
  see that the standard functions like `binary()` function as `field()` wrappers.

  Rather than using `unpack_func` and `pack_func` in every field, you can also create an instance of `BinaryMetadata` or
  `BinaryArrayMetadata` to support your custom classes (e.g. a `Vector3` class) and add them to the `METADATA_FACTORIES`
  attribute of your `BinaryStruct` subclass (or an intermediate class that all of your `Vector3`-using structs can
  inherit from). This allows direct use of your custom class as a type hint in a `BinaryStruct` with no field call needed
  at all (unless you want to set a default, assert values, etc.). See the examples below.

  `BinaryStruct` subclasses **have `dataclass(slots=True)` wrapping built in to their metaclass.** You must not add an
  additional `dataclass` decorator yourself, with or without `slots`, as this will cause the binary field metadata to be
  lost.



  ```python
  from constrata.binary_struct import BinaryStruct
  from constrata.fields import *
  from constrata.field_types import *


  class MyStruct(BinaryStruct):
      my_int32: int
      my_uint64: uint64
      my_single: float32
      my_double: float64 = binary(asserted=(1.0, 2.0, 3.0))  # only three permitted values
      _padding: bytes = binary_pad(8)
      my_ascii_string: str = binary_string(12, encoding="ascii")
      my_eight_bools: list[bool] = binary_array(8, default_factory=lambda: [False] * 8)
      my_bitflag1: bool = binary(bit_count=1, default=False)
      my_bitflag2: bool = binary(bit_count=1, default=True)
      


  bin_path = "my_struct.bin"
  with open(bin_path, "rb") as f:
      my_struct = MyStruct.from_bytes(f)


  my_struct.my_int32 = 123
  my_struct.my_bitflag2 = True


  my_struct_bytes = my_struct.to_bytes()
  new_bin_path = "my_struct_new.bin"
  with open(new_bin_path, "wb") as f:
      f.write(my_struct_bytes)


  new_struct = MyStruct(0, 0, 0.0, 1.0, my_ascii_string="helloworld")
  ```



  The flexible `BinaryReader` and `BinaryWriter` classes can also serve as useful tools for managing binary IO streams.
  They manage byte order, variable-sized ints, and (in the case of `BinaryWriter`) handle field *reserving and filling*.

  When converting a `BinaryStruct` instance to a `BinaryWriter`, fields can also be left as `None` (or explicitly set to
  the unique value `RESERVED`) and filled in later using the `binary_writer.fill()` method. This is useful for fields that
  store offsets or otherwise depend on future state. (The `binary_writer.fill_with_position()` method can be used in this
  case, too.)

  Field positions in the writer are reserved with reference to the `id()` of the `BinaryStruct` instance, so numerous
  instances can all reserve the same field name in a single writer without conflict.

  If any reserved fields are not filled before the final conversion of the writer to `bytes`, an error will be raised.

  Example:

  ```python
  from typing import NamedTuple
  from constrata import BinaryStruct, binary_string, BinaryReader, BinaryWriter, RESERVED
  from constrata.field_types import float32


  class Vector(NamedTuple):
      name: str
      x: float
      y: float
      z: float


  class VectorListHeader(BinaryStruct):
      magic: bytes = binary_string(4, asserted=b"VEC\0")
      vector_count: int
      names_offset: int  # offset to packed null-terminated vector name data
      data_offset: int  # offset to packed (x, y, z) vector float data
      file_size: int  # total file size in bytes


  class VectorData(BinaryStruct):
      x: float32
      y: float32
      z: float32
      name_offset: int
      next_vector_offset: int


  bin_path = "my_vector_list.vec"

  reader = BinaryReader(bin_path)
  vector_list_header = VectorListHeader.from_bytes(reader)

  names = []
  with reader.temp_offset(vector_list_header.names_offset):
      for _ in range(vector_list_header.vector_count):
          name = reader.unpack_string()  # null-terminated with default UTF-8 encoding
          names.append(name)
  vectors = []
  with reader.temp_offset(vector_list_header.data_offset):
      for i in range(vector_list_header.vector_count):
          data = VectorData.from_bytes(reader)
          
          vector = Vector(names[i], data.x, data.y, data.z)
          vectors.append(vector)




  vectors.append(Vector("new_vector", 1.0, 2.0, 3.0))


  writer = BinaryWriter()
  new_header = VectorListHeader(
      
      
      vector_count=len(vectors),
      names_offset=RESERVED,
      data_offset=RESERVED,
      file_size=RESERVED,
  )

  new_header.to_writer(writer)

  new_header.fill(writer, "names_offset", writer.position)


  vector_name_offsets = []
  for vector in vectors:
      vector_name_offsets.append(writer.position)  # record offset before writing
      writer.pack_z_string(vector.name)  # default UTF-8 encoding


  writer.pad_align(0x10)

  new_header.fill(writer, "data_offset", writer.position)


  vector_data_structs = []
  for i, vector in enumerate(vectors):
      if i > 0:
          
          vector_data_structs[i - 1].fill(writer, "next_vector_offset", writer.position)
      if i == len(vectors) - 1:
          
          next_vector_offset = 0
      else:
          
          next_vector_offset = RESERVED
      name_offset = vector_name_offsets[i]
      
      vector_data = VectorData(vector.x, vector.y, vector.z, name_offset, next_vector_offset=next_vector_offset)
      vector_data.to_writer(writer)
      vector_data_structs.append(vector_data)


  new_header.fill(writer, "file_size", writer.position)


  new_bin_path = "my_vector_list_new.vec"
  with open(new_bin_path, "wb") as f:
      f.write(bytes(writer))
  ```



  By default, you can only omit binary metadata when the field type hint is a built-in type with a known
  size. You can extend this support by adding custom metadata factories to `BinaryStruct.METADATA_FACTORIES`, most easily
  done with a subclass.

  The example below defines a `Vector` metadata factory for use with the example above, which allows `Vector` fields to be
  explicitly used in the `VectorData` struct without needing to read or write the three `float` components manually. (In
  this case, since the `name` field of each `Vector` must be changed after object initialization, we use a `dataclass` for
  it instead of an immutable `NamedTuple`.)

  ```python
  from dataclasses import dataclass
  from constrata import BinaryStruct, binary
  from constrata.metadata import BinaryMetadata


  @dataclass(slots=True)
  class Vector:
      name: str
      x: float
      y: float
      z: float


  def unpack_vector(values: list[float]) -> Vector:
      """Name will be set later. The field metadata will have already read three floats (see below)."""
      return Vector("", *values)


  def pack_vector(value: Vector) -> list[float]:
      """This function must convert the custom type to a list of values that can be packed with `struct.pack()`.

      Name is ignored and handled separately by our script.

      Note that if `Vector` defined `__iter__`, we could omit this, as the asterisk operator would unpack the values for
      us as we call `struct.pack(*value)`.
      """
      return [value.x, value.y, value.z]





  class VectorData(BinaryStruct):
      vector: Vector = binary("3f", unpack_func=unpack_vector, pack_func=pack_vector)
      name_offset: int
      next_vector_offset: int




  class EnhancedBinaryStruct(BinaryStruct):

      METADATA_FACTORIES = {
          "Vector": lambda: BinaryMetadata("3f", unpack_func=unpack_vector, pack_func=pack_vector),
      }



  class VectorData_Enhanced(EnhancedBinaryStruct):
      vector: Vector  # replaces `x`, `y`, `z` separate fields; no `field()` call needed here!
      name_offset: int
      next_vector_offset: int



  ```

  You can also natively use other `BinaryStruct` subclasses as field types in your `BinaryStruct` subclasses, as long as
  they do not create a circular reference. This can be useful for defining complex binary structures with nested fields.



  More documentation and examples to come. For now, please refer to the source code and docstrings.



  ```
  MIT License

  Copyright (c) 2017-2024 Scott Mooney (aka Grimrukh)

  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: 03b733cc55349f1bc553df297ecde1ad05e0f0a10cf14608cae71fb27707b9be
name: python-controller-companion-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for controller-companion
url: https://pypi.org/project/controller-companion/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-controller-companion-0.5.0-1.src.rpm
location_href: Packages/python-controller-companion-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
  [![PyPI version](https://badge.fury.io/py/controller-companion.svg)](https://pypi.org/project/controller-companion/)



  Easily map controller shortcuts to an action.
  The following actions are supported:
  - Kill a task by its name.
  - Execute a keyboard shortcut.
  - Execute an arbitrary console command.


  - GUI and CLI options available
  - Supports a wide variety of controllers (those supported by [pygame](https://www.pygame.org))
  - Runs on Windows, Linux and Mac
  - Auto start on system boot (windows only for now)
  - GUI app can be compiled as a standalone executable (using [PyInstaller](https://pyinstaller.org)



  ![demo](https://raw.githubusercontent.com/Johannes11833/controller-companion/master/demo/app.png)

  ![demo](https://raw.githubusercontent.com/Johannes11833/controller-companion/master/demo/add_new_shortcut.png)



  - Using pip:
      ```console
      pip install controller-companion
      ```
  - For the GUI version, executables are additionally available [here](https://github.com/Johannes11833/controller-companion/releases) for Windows, Mac and Linux. In addition for windows, an installer is available.


  - CLI and GUI versions available
  - CLI:
      - Multiple mappings can be created.
      - One or multiple input controller key combination that triggers an action can be defined using --input. The keys of one individual input combination are separated by commas, while each distinct input combination is separated by a space.
      - One or multiple actions can be defined using either `--task-kill`, `--console` or `--shortcut`. These actions will be mapped to the previously defined controller `--input` key combinations in the order `--task-kill`, `--console` and finally `--shortcut`
      - Example with 2 mappings:
          ```console
          controller_companion --input A,B Back,Left --console explorer.exe --shortcut alt+f4
          ```
          will result in the following mapping:
          ```console
          Controller<A,B> --> Action<name: Run command "explorer.exe", target: explorer.exe, type: CONSOLE_COMMAND>
          Controller<Back,Left> --> Action<name: Shortcut "alt+f4", target: alt+f4, type: KEYBOARD_SHORTCUT>
          ```

      - Run `controller_companion --help` to see all available arguments


  With [poetry](https://python-poetry.org/) installed, run the following command to build the executable using [PyInstaller](https://pyinstaller.org):
  ```console
  poetry run build_controller_companion_executable
  ```


pkgId: f1e3d45a880de69daaa6f0fb270cc983e668bf3faa045408a88afe5feeab84b8
name: python-convertkit-py-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for convertkit-py
url: https://github.com/andreskull/convertkit-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-convertkit-py-0.3.0-1.src.rpm
location_href: Packages/python-convertkit-py-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  A Python client for the ConvertKit API.



  ```bash
  pip install convertkit-py
  ```



  Copy the sample environment file:

  ```bash
  cp .env-sample .env
  ```

  Edit `.env` with your ConvertKit credentials:

  ```text
  CONVERTKIT_API_KEY=your_api_key_here
  CONVERTKIT_API_SECRET=your_secret_key_here
  CONVERTKIT_FORM_NAME=your_form_name_here
  ```



  ```python
  from convertkit import ConvertKit
  from dotenv import load_dotenv
  import os


  load_dotenv()


  kit = ConvertKit(
      api_key=os.getenv('CONVERTKIT_API_KEY'),
      api_secret=os.getenv('CONVERTKIT_API_SECRET'),
      form_name=os.getenv('CONVERTKIT_FORM_NAME')
  )


  subscriber_data = {
      'email': 'example@example.com',
      'fields': {'first_name': 'John'},
      'tags': ['tag1', 'tag2']
  }
  kit.create_subscriber_with_fields_and_tags(subscriber_data)
  ```



  - Manage subscribers
  - Handle custom fields
  - Manage tags
  - Work with forms
  - Full API coverage





  1. Clone the repository
  2. Install development dependencies: `pip install -e ".[dev]"`
  3. Install test dependencies: `pip install pytest python-dotenv`



  1. Create a `.env` file in the project root:
  ```text
  KIT_API_KEY=your_api_key_here
  KIT_API_SECRET=your_secret_here
  ```

  2. Run tests:
  ```bash
  pytest tests -v
  ```



  MIT License


pkgId: cef36b654f04a003e2d6688336df0b9a2b23924a5d5aa57254ef7347b70be252
name: python-conviso-cli-help
arch: noarch
version: 2.2.16
epoch: 0
release: 1
summary: Development documents and examples for conviso-cli
url: https://pypi.org/project/conviso-cli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-conviso-cli-2.2.16-1.src.rpm
location_href: Packages/python-conviso-cli-help-2.2.16-1.noarch.rpm
checksum_type: sha256
description:
  This is a command line tool to interact with [convisoappsec] API.


  Please visit the [official documentation] for further information.

  [official documentation]: <https://docs.convisoappsec.com/cli/installation>


pkgId: 3998ca91190c6157a428ededc0e3dc2204125c5b5c909186af3e51b7d0efdee3
name: python-cookie-api-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for cookie-api
url: https://pypi.org/project/cookie-api/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cookie-api-0.2.2-1.src.rpm
location_href: Packages/python-cookie-api-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/v/cookie-api.svg?style=for-the-badge&logo=pypi&color=yellow&logoColor=white)](https://pypi.org/project/cookie-api/)
  [![](https://img.shields.io/pypi/l/cookie-api?style=for-the-badge&color=5865F2)](https://github.com/tibue99/cookie-api/blob/main/LICENSE)
  [![](https://img.shields.io/readthedocs/cookie-api?style=for-the-badge)](https://cookie-api.readthedocs.io/)
  [![](https://img.shields.io/badge/Cookie-Website-orange?style=for-the-badge)](https://cookieapp.me/)

  Official wrapper for the [Cookie](https://cookieapp.me) API.


  Python 3.9 or higher is required
  ```
  pip install cookie-api
  ```


  1. Invite [Cookie](https://cookieapp.me) to your Discord server or to your Discord account
  2. Run `/premium api`


  The API key can be passed as a parameter or set as the environment variable `COOKIE_KEY`.
  For more information, see to our [documentation](https://cookie-api.readthedocs.io/).


  ```python
  from cookie import CookieAPI

  api = CookieAPI(api_key="[YOUR_API_KEY]")

  user_stats = api.get_user_stats(123456789)  # Replace with user ID
  ```

  ```python
  import asyncio
  from cookie import AsyncCookieAPI

  api = AsyncCookieAPI(api_key="[YOUR_API_KEY]")

  async def main():
      user_stats = await api.get_user_stats(123456789)  # Replace with user ID
      await api.close()

  asyncio.run(main())
  ```
  You can also use an asynchronous context manager (recommended)
  ```python
  async def main():
      async with api as con:
          user_stats = await con.get_user_stats(123456789)  # Replace with user ID
  ```


  If you want to use the API without this wrapper, you can find the FastAPI docs [here](https://api.cookie-bot.xyz/docs).


pkgId: b4d1f2c6b07007f5fc75ce24d3aef99af70f6abae2ca3b41c42e1896d2a503b9
name: python-coordinax-help
arch: noarch
version: 0.17.0
epoch: 0
release: 1
summary: Development documents and examples for coordinax
url: https://github.com/GalacticDynamics/coordinax
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coordinax-0.17.0-1.src.rpm
location_href: Packages/python-coordinax-help-0.17.0-1.noarch.rpm
checksum_type: sha256
description:
  Coordinax enables calculations with coordinates in
  [JAX](https://jax.readthedocs.io/en/latest/). Built on
  [Equinox](https://docs.kidger.site/equinox/) and
  [Quax](https://github.com/patrick-kidger/quax).

  [![PyPI platforms][pypi-platforms]][pypi-link]
  [![PyPI version][pypi-version]][pypi-link]
  <!-- [![Conda-Forge][conda-badge]][conda-link] -->
  ```bash
  pip install coordinax
  ```

  [![Read The Docs](https://img.shields.io/badge/read_docs-here-orange)](https://unxt.readthedocs.io/en/)
  Coming soon. In the meantime, if you've used `astropy.coordinates`, then
  `coordinax` should be fairly intuitive.

  ```python
  import jax.numpy as jnp
  import unxt as u
  import coordinax as cx
  q = cx.CartesianPos3D(
      x=u.Quantity(jnp.arange(0, 10.0), "km"),
      y=u.Quantity(jnp.arange(5, 15.0), "km"),
      z=u.Quantity(jnp.arange(10, 20.0), "km"),
  )
  print(q)






  q2 = cx.vconvert(cx.SphericalPos, q)
  print(q2)






  p = cx.CartesianVel3D(
      d_x=u.Quantity(jnp.arange(0, 10.0), "m/s"),
      d_y=u.Quantity(jnp.arange(5, 15.0), "m/s"),
      d_z=u.Quantity(jnp.arange(10, 20.0), "m/s"),
  )
  print(p)






  p2 = cx.vconvert(cx.SphericalVel, p, q)
  print(p2)






  ```

  [![DOI][zenodo-badge]][zenodo-link]
  If you found this library to be useful in academic work, then please cite.

  [![Actions Status][actions-badge]][actions-link]
  [![Documentation Status][rtd-badge]][rtd-link]
  [![codecov][codecov-badge]][codecov-link]
  [![SPEC 0 — Minimum Supported Dependencies][spec0-badge]][spec0-link]
  [![pre-commit][pre-commit-badge]][pre-commit-link]
  [![ruff][ruff-badge]][ruff-link]
  We welcome contributions!
  <!-- prettier-ignore-start -->
  [actions-badge]:            https://github.com/GalacticDynamics/coordinax/workflows/CI/badge.svg
  [actions-link]:             https://github.com/GalacticDynamics/coordinax/actions
  [codecov-badge]:            https://codecov.io/gh/GalacticDynamics/unxt/graph/badge.svg
  [codecov-link]:             https://codecov.io/gh/GalacticDynamics/unxt
  [pre-commit-badge]:         https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit
  [pre-commit-link]:          https://pre-commit.com
  [pypi-link]:                https://pypi.org/project/coordinax/
  [pypi-platforms]:           https://img.shields.io/pypi/pyversions/coordinax
  [pypi-version]:             https://img.shields.io/pypi/v/coordinax
  [rtd-badge]:                https://readthedocs.org/projects/coordinax/badge/?version=latest
  [rtd-link]:                 https://coordinax.readthedocs.io/en/latest/?badge=latest
  [ruff-badge]:               https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
  [ruff-link]:                https://docs.astral.sh/ruff/
  [spec0-badge]:              https://img.shields.io/badge/SPEC-0-green?labelColor=%23004811&color=%235CA038
  [spec0-link]:               https://scientific-python.org/specs/spec-0000/
  [zenodo-badge]:             https://zenodo.org/badge/755708966.svg
  [zenodo-link]:              https://zenodo.org/doi/10.5281/zenodo.10850557
  <!-- prettier-ignore-end -->

rpm_license:
  Copyright 2024 Galactic Dynamics maintainers  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: 89549399e28fd0422f42d0200034fde4245609aa6d0cedbd347f566f26cc57f3
name: python-coqpit-config-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for coqpit-config
url: https://pypi.org/project/coqpit-config/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coqpit-config-0.1.2-1.src.rpm
location_href: Packages/python-coqpit-config-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - License](https://img.shields.io/pypi/l/coqpit-config)](https://github.com/idiap/coqui-ai-coqpit/blob/main/LICENSE.txt)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/coqpit-config)
  [![PyPI - Version](https://img.shields.io/pypi/v/coqpit-config)](https://pypi.org/project/coqpit-config)
  [![CI](https://github.com/idiap/coqui-ai-coqpit/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/idiap/coqui-ai-coqpit/actions/workflows/main.yml)

  Simple, light-weight and no dependency config handling through python data
  classes with to/from JSON serialization/deserialization.

  Fork of the [original, unmaintained repository](https://github.com/coqui-ai/coqpit). New PyPI package: [coqpit-config](https://pypi.org/project/coqpit-config)

  Currently it is being used by [coqui-tts](https://github.com/idiap/coqui-ai-TTS).


  What I need from a ML configuration library...

  1. Fixing a general config schema in Python to guide users about expected values.

      Python is good but not universal. Sometimes you train a ML model and use it on a different platform. So, you
      need your model configuration file importable by other programming languages.

  2. Simple dynamic value and type checking with default values.

      If you are a beginner in a ML project, it is hard to guess the right values for your ML experiment. Therefore it is important
      to have some default values and know what range and type of input are expected for each field.

  4. Ability to decompose large configs.

      As you define more fields for the training dataset, data preprocessing, model parameters, etc., your config file tends
      to get quite large but in most cases, they can be decomposed, enabling flexibility and readability.

  5. Inheritance and nested configurations.

      Simply helps to keep configurations consistent and easier to maintain.

  6. Ability to override values from the command line when necessary.

      For instance, you might need to define a path for your dataset, and this changes for almost every run. Then the user
      should be able to override this value easily over the command line.

      It also allows easy hyper-parameter search without changing your original code. Basically, you can run different models
      with different parameters just using command line arguments.

  7. Defining dynamic or conditional config values.

      Sometimes you need to define certain values depending on the other values. Using python helps to define the underlying
      logic for such config values.

  8. No dependencies

      You don't want to install a ton of libraries for just configuration management. If you install one, then it
      is better to be just native python.


  - `Union` type dataclass fields cannot be parsed from console arguments due to the type ambiguity.
  - `JSON` is the only supported serialization format, although the others can be easily integrated.
  - `List`type with multiple item type annotations are not supported. (e.g. `List[int, str]`).
  - `dict` fields are parsed from console arguments as JSON str without type checking. (e.g `--val_dict '{"a":10, "b":100}'`).
  - `MISSING` fields cannot be avoided when parsing console arguments.




  ```python
  import os
  from dataclasses import asdict, dataclass, field
  from typing import List, Union
  from coqpit import MISSING, Coqpit, check_argument


  @dataclass
  class SimpleConfig(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_d: float = 10.21
      val_c: str = "Coqpit is great!"
      
      
      val_k: int = MISSING
      
      val_dict: dict = field(default_factory=lambda: {"val_aa": 10, "val_ss": "This is in a dict."})
      
      val_listoflist: List[List] = field(default_factory=lambda: [[1, 2], [3, 4]])
      val_listofunion: List[List[Union[str,int]]] = field(default_factory=lambda: [[1, 3], [1, "Hi!"]])

      def check_values(
          self,
      ):  # you can define explicit constraints on the fields using `check_argument()`
          """Check config fields"""
          c = asdict(self)
          check_argument("val_a", c, restricted=True, min_val=10, max_val=2056)
          check_argument("val_b", c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument("val_c", c, restricted=True)


  if __name__ == "__main__":
      file_path = os.path.dirname(os.path.abspath(__file__))
      config = SimpleConfig()

      
      try:
          k = config.val_k
      except AttributeError:
          print(" val_k needs a different value before accessing it.")
      config.val_k = 1000

      
      print(config.serialize())
      print(config.to_json())
      config.save_json(os.path.join(file_path, "example_config.json"))
      config.load_json(os.path.join(file_path, "example_config.json"))
      print(config.pprint())

      
      print(*config)
      print(dict(**config))

      
      config["val_a"] = -999
      print(config["val_a"])
      assert config.val_a == -999
  ```

  ```python
  import os
  from dataclasses import asdict, dataclass, field
  from coqpit import Coqpit, check_argument
  from typing import List, Union


  @dataclass
  class SimpleConfig(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_c: str = "Coqpit is great!"

      def check_values(self,):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_a', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_b', c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument('val_c', c, restricted=True)


  @dataclass
  class NestedConfig(Coqpit):
      val_d: int = 10
      val_e: int = None
      val_f: str = "Coqpit is great!"
      sc_list: List[SimpleConfig] = None
      sc: SimpleConfig = SimpleConfig()
      union_var: Union[List[SimpleConfig], SimpleConfig] = field(default_factory=lambda: [SimpleConfig(),SimpleConfig()])

      def check_values(self,):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_d', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_e', c, restricted=True, min_val=128, max_val=4058, allow_none=True)
          check_argument('val_f', c, restricted=True)
          check_argument('sc_list', c, restricted=True, allow_none=True)
          check_argument('sc', c, restricted=True, allow_none=True)


  if __name__ == '__main__':
      file_path = os.path.dirname(os.path.abspath(__file__))
      
      config = NestedConfig()

      
      config.save_json(os.path.join(file_path, 'example_config.json'))
      
      config2 = NestedConfig(val_d=None, val_e=500, val_f=None, sc_list=None, sc=None, union_var=None)
      
      config2.load_json(os.path.join(file_path, 'example_config.json'))
      
      assert config == config2

      
      print(config.pprint())

      
      config_dict = config.to_dict()
      
      config2 = NestedConfig(val_d=None, val_e=500, val_f=None, sc_list=None, sc=None, union_var=None)
      
      config2.from_dict(config_dict)
      
      assert config == config2
  ```



  ```python
  import argparse
  import os
  from dataclasses import asdict, dataclass, field
  from typing import List

  from coqpit import Coqpit, check_argument
  import sys


  @dataclass
  class SimplerConfig(Coqpit):
      val_a: int = field(default=None, metadata={'help': 'this is val_a'})


  @dataclass
  class SimpleConfig(Coqpit):
      val_req: str # required field
      val_a: int = field(default=10,
                         metadata={'help': 'this is val_a of SimpleConfig'})
      val_b: int = field(default=None, metadata={'help': 'this is val_b'})
      nested_config: SimplerConfig = SimplerConfig()
      mylist_with_default: List[SimplerConfig] = field(
          default_factory=lambda:
          [SimplerConfig(val_a=100),
           SimplerConfig(val_a=999)],
          metadata={'help': 'list of SimplerConfig'})

      

      def check_values(self, ):
          '''Check config fields'''
          c = asdict(self)
          check_argument('val_a', c, restricted=True, min_val=10, max_val=2056)
          check_argument('val_b',
                         c,
                         restricted=True,
                         min_val=128,
                         max_val=4058,
                         allow_none=True)
          check_argument('val_req', c, restricted=True)


  def main():
      
      config_ref = SimpleConfig(val_req='this is different',
                                val_a=222,
                                val_b=999,
                                nested_config=SimplerConfig(val_a=333),
                                mylist_with_default=[
                                    SimplerConfig(val_a=222),
                                    SimplerConfig(val_a=111)
                                ])

      
      parsed = SimpleConfig.init_from_argparse()
      parsed.pprint()

      
      assert parsed == config_ref


  if __name__ == '__main__':
      sys.argv.extend(['--coqpit.val_req', 'this is different'])
      sys.argv.extend(['--coqpit.val_a', '222'])
      sys.argv.extend(['--coqpit.val_b', '999'])
      sys.argv.extend(['--coqpit.nested_config.val_a', '333'])
      sys.argv.extend(['--coqpit.mylist_with_default.0.val_a', '222'])
      sys.argv.extend(['--coqpit.mylist_with_default.1.val_a', '111'])
      main()
  ```


  ```python
  import os
  from dataclasses import dataclass
  from coqpit import Coqpit, check_argument


  @dataclass
  class CoqpitA(Coqpit):
      val_a: int = 10
      val_b: int = None
      val_d: float = 10.21
      val_c: str = "Coqpit is great!"


  @dataclass
  class CoqpitB(Coqpit):
      val_d: int = 25
      val_e: int = 257
      val_f: float = -10.21
      val_g: str = "Coqpit is really great!"


  if __name__ == '__main__':
      file_path = os.path.dirname(os.path.abspath(__file__))
      coqpita = CoqpitA()
      coqpitb = CoqpitB()
      coqpitb.merge(coqpita)
      print(coqpitb.val_a)
      print(coqpitb.pprint())
  ```



  Install the pre-commit hook to automatically check your commits for style and hinting issues:

  ```bash
  uv run pre-commit install
  ```


pkgId: aad56237894014a968db882d5aae8c414011b6005c6b50d2252394a07b8ec458
name: python-coremstools-help
arch: noarch
version: 0.0.8.1
epoch: 0
release: 1
summary: Development documents and examples for coremstools
url: https://github.com/deweycw/corems-tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coremstools-0.0.8.1-1.src.rpm
location_href: Packages/python-coremstools-help-0.0.8.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for processing CoreMS assignments of ultrahigh mass resolution LC-ESI-MS data.



  - Alignment of assigned features across a dataset
  - Calculation of average assignment & feature parameters across a dataset:
      1. measured m/z
      2. calibrated m/z
      3. resolving power
      4. m/z error
      5. feature S/N
      6. confidence score
  - Gap filling of ambiguous assignments
  - Stoichiometric classifications
  - NOSC calucations
  - O/C, H/C, N/C calculations
  - Identification of significant assignment errors in a dataset, based on rolling average and standard deviation


  - Determination of a feature's chromatographic dispersity
  - Generation of calibrant list(s) for data calibration
  - QC checks of retention and intensity of an internal standard across a dataset




      git clone https://github.com/deweycw/corems-tools.git corems-tools
      cd corems-tools/src
      python -m pip install -e . # from root directory of project


      python -m pip install --index-url https://test.pypi.org/simple/ --no-deps coremstools


  See: https://packaging.python.org/en/latest/tutorials/packaging-projects/


      python -m pip install -U build
      python -m build


      python -m pip install -U twine
      python -m twine upload --repository testpypi dist/*




  1. Generate calibrants using calibrant generator function (requires CoreMS)
  2. Perform assignments (requires CoreMS)
  3. Calculate dispersity (requires CoreMS)
  4. Evaluate retention and intensity of internal standard (requires CoreMS)
  5. Generate assignment error plots (error v. m/z; error dist in each time window)


  6. Align features across dataset
  7. Gapfill across dataset
  8. Perform blank correction
  9. Flag features with potentially signficant assignment error (i.e., feature is flagged if difference between rolling average of assignment error (across dataset) and error of individual assignment exceeds 4x the standard deviation of the assignment error for the specific feature)


  10. Determine O/C, H/C, N/C & NOSC for features
  11. Determine stoichiometric classifcations


pkgId: bd54ec34c87774963cbb1ad185b1d573e50a5ab5c27501810bebe3ff260d0862
name: python-cosl-help
arch: noarch
version: 0.0.48
epoch: 0
release: 1
summary: Development documents and examples for cosl
url: https://github.com/canonical/cos-lib
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cosl-0.0.48-1.src.rpm
location_href: Packages/python-cosl-help-0.0.48-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI](https://img.shields.io/pypi/v/cosl)

  This library provides utilities for
  [COS Lite](https://github.com/canonical/cos-lite-bundle/) charms:

  - [`CosTool`](src/cosl/cos_tool.py): bindings for
    [cos-tool](https://github.com/canonical/cos-tool)
  - [`JujuTopology`](src/cosl/juju_topology.py): logic for
    [topology labels](https://ubuntu.com/blog/model-driven-observability-part-2-juju-topology-metrics)
  - [`LokiHandler`](src/cosl/loki_logger.py): python logging handler that forwards logs to a Loki push api endpoint.



  Go to https://github.com/canonical/cos-lib/releases and click on 'Draft a new release'.

  Select a tag from the dropdown, or create a new one from the `main` target branch.

  Enter a meaningful release title and in the description, put an itemized changelog listing new features and bugfixes, and whatever is good to mention.

  Click on 'Publish release'.

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


pkgId: 152f618ca81d3a9c5d211b193ecadda5a3e252fdb1918d84fe0439baa9a00740
name: python-cosmograph-help
arch: noarch
version: 0.0.26
epoch: 0
release: 1
summary: Development documents and examples for cosmograph
url: https://github.com/cosmograph-org/py_cosmograph
rpm_license: GPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cosmograph-0.0.26-1.src.rpm
location_href: Packages/python-cosmograph-help-0.0.26-1.noarch.rpm
checksum_type: sha256
description:
  The **Cosmograph Widget** brings the power of Cosmograph's GPU-accelerated force layout graph visualization right into your Jupyter notebooks. Built on top of [Anywidget](https://anywidget.dev/), this widget provides a seamless, interactive graph exploration experience directly within your data science workflow, making it easier than ever to visualize complex data relationships and embeddings.



  - **Interactive Visualization**: Pan, zoom, select, and hover to explore large, complex network graphs right in your notebook.
  - **GPU-Acceleration**: Powered by [@cosmograph/cosmos](http://github.com/cosmograph-org/cosmos), it delivers smooth interactions and rapid rendering of large-scale graphs.
  - **Seamless Integration**: Embeds naturally into Jupyter notebooks, JupyterLab, and other notebook-based environments.
  - **Rich Configuration API**: Fine-tune graph appearance, behavior, and layout parameters through easy-to-use Python APIs.



  To install the Cosmograph widget, simply run:

  ```sh
  pip install cosmograph
  ```

  Once installed, you can start using it in your notebooks immediately.

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




  After installation, you can import and use the widget in any Python-based notebook environment:

  ```python
  import pandas as pd
  from cosmograph import cosmo

  points = pd.DataFrame({
      'id': [1, 2, 3, 4, 5],
      'label': ['Node A', 'Node B', 'Node C', 'Node D', 'Node E'],
      'value': [10, 20, 15, 25, 30],
      'category': ['A', 'B', 'A', 'B', 'A']
  })

  links = pd.DataFrame({
      'source': [1, 2, 3, 1, 2],
      'target': [2, 3, 4, 5, 4],
      'value': [1.0, 2.0, 1.5, 0.5, 1.8]
  })

  widget = cosmo(
    points=points,
    links=links,
    point_id_by='id',
    link_source_by='source',
    link_target_by='target',
    point_color_by='category',
    point_include_columns=['value'],
    point_label_by='label',
    link_include_columns=['value'],
  )
  widget
  ```

  The widget will render an interactive graph visualization inline, allowing you to
  explore and manipulate your data directly.

  ![image](https://github.com/user-attachments/assets/f057c15a-fc36-4b85-8bfa-fe6af12813c5)

  You also use the widget object to interact with the rendered graph.

  ```python
  widget.fit_view()  # recenter the view (often useful when you've lost your graph (or within your graph)
  widget.selected_point_ids  # if you've selected some points and want to get info about the selection...

  ```




  Try out the Cosmograph widget in Google Colab with these example notebooks:

  - [Cosmograph Widget (Colab notebook) ✌️](https://colab.research.google.com/drive/1d0Gsn6KlCNCjPp8n8fpm82ctBpARasVX)
  - [Mobius in Cosmograph Widget (Colab notebook)🎗️](https://colab.research.google.com/drive/1-FlUSyRAgdhXT6rNyi3uYrIIlGX8gRuk)
  - [Clusters in Cosmograph (Colab notebook) 🫧](https://colab.research.google.com/drive/1Rt8rmmeMuWyFjEqae2DdJ3NYymtjC9cT)




  Submit issues to https://github.com/cosmograph-org/py_cosmograph/issues.



  🌎 [Website](https://cosmograph.app)

  📩 [Email](mailto:hi@cosmograph.app)

  👾 [Join the Cosmograph Discord Community](https://discord.gg/Rv8RUQuzsx)


pkgId: 05dd85a99bd7010da881e9c06ad32b3c090d99d4dbc6c01d79f2e71b43275177
name: python-cosmograph-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for cosmograph
url: https://github.com/cosmograph-org/py_cosmograph
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cosmograph-0.0.5-1.src.rpm
location_href: Packages/python-cosmograph-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  Python binder to the [cosmograph visual analytics tools](https://github.com/cosmograph-org) for big graphs.

  To install:	```pip install cosmograph```




  * [pypi cosmograph page](https://pypi.org/project/cosmograph/)


pkgId: 58339148d2122c4b3bfa57ddf1522a07b643a62ff206d1bf57f7ad3c8f7cc3cb
name: python-cosmoplots-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for cosmoplots
url: https://github.com/uit-cosmo/cosmoplots
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cosmoplots-0.5.0-1.src.rpm
location_href: Packages/python-cosmoplots-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  Routines to get a sane default configuration for production quality plots. Used by complex systems modelling group at UiT.



  The package is published to PyPI and can be installed with

  ```sh
  pip install cosmoplots
  ```

  If you want the development version you must first clone the repo to your local machine,
  then install the project and its dependencies with [poetry](https://python-poetry.org):

  ```sh
  git clone https://github.com/uit-cosmo/cosmoplots.git
  cd cosmoplots
  poetry install
  ```



  The default style uses LaTeX to render text and equations. The default font is Latin Modern.

  ```python
  text.usetex : True
  font.family : "Latin Modern"
  ```

  Installations of [TeX Live](https://www.tug.org/texlive/) should include Latin Modern, but it may be manually downloaded from
  [here](https://www.gust.org.pl/projects/e-foundry/latin-modern).



  Set your `rcparams` before plotting in your code, for example:

  ```python
  import matplotlib.pyplot as plt
  import cosmoplots

  plt.style.use(["cosmoplots.default"])
  ```



  To make a figure with multiple rows or columns, use `cosmoplots.figure_multiple_rows_columns`.
  By default, the labels are $\mathrm{(a)}$, $\mathrm{(b)}$, $\mathrm{(c)}$, ..., but they may be replaced using the `labels` argument.

  ```python
  import matplotlib.pyplot as plt
  import cosmoplots
  plt.style.use(["cosmoplots.default"])

  import numpy as np

  rows = 1
  columns = 2

  fig, ax = cosmoplots.figure_multiple_rows_columns(rows, columns)
  a = np.linspace(-3,3,100)
  for i in range(rows*columns):
      ax[i].set_xlabel("X Axis")
      ax[i].set_ylabel("Y Axis")
      ax[i].plot(i*a)

  plt.show()
  ```

  ![multifig](./assets/multifig.png)



  By default, the x-coordinates of the y-axis labels are aligned with the subfigure labels, but the y-axis label position can be adjusted using
  ```python
  ax[i].yaxis.set_label_coords(x_coordinate, y_coordinate)
  ```



  ```python
  import matplotlib.pyplot as plt
  import cosmoplots
  plt.style.use(["cosmoplots.default"])
  import numpy as np

  a = np.exp(np.linspace(-3, 1, 100))


  fig = plt.figure()
  ax1 = plt.gca()
  ax1.set_xlabel("X Axis")
  ax1.set_ylabel("Y Axis")
  base = 2  # Default is 10, but 2 works equally well

  ax1.semilogx(a)



  cosmoplots.change_log_axis_base(ax1, base=base)

  fig = plt.figure()
  ax2 = plt.gca()
  ax2.set_xlabel("X Axis")
  ax2.set_ylabel("Y Axis")
  base = 2  # Default is 10, but 2 works equally well
  cosmoplots.change_log_axis_base(ax2, "x", base=base)




  ax2.plot(a)
  plt.show()
  ```



  ```python
  import matplotlib.pyplot as plt
  import cosmoplots
  import numpy as np

  def plot() -> None:
      a = np.exp(np.linspace(-3, 5, 100))
      fig = plt.figure()
      ax = fig.add_subplot()
      ax.set_xlabel("X Axis")
      ax.set_ylabel("Y Axis")
      ax.semilogy(a)


  with plt.style.context("default"):
      plot()
      
      plt.show()


  with plt.style.context("cosmoplots.default"):
      plot()
      
      plt.show()
  ```

  | `matplotlib` | `cosmoplots` |
  | :--------: | :--------: |
  | ![matplotlib](./assets/matplotlib.png) | ![cosmoplots](./assets/cosmoplots.png) |



  This function generates the hex numbers for the colours extracted from a `matplotlib` colour map based on the number of points of interest.
  The colors change gradually from bright to dark or vice versa.

  ```python
  import matplotlib.pyplot as plt
  import cosmoplots
  plt.style.use(["cosmoplots.default"])


  color_list = cosmoplots.generate_hex_colors(5, 'viridis', show_swatch=True, ascending=True)



  print(color_list) #['#fde725', '#5ec962', '#21918c', '#3b528b', '#440154']

  fig = plt.figure()
  ax = plt.gca()
  for i, color in enumerate(color_list):
      ax.plot([1,2],[i,i+1], c = color)


  plt.show()
  ```

  | `hex_colors.png` | hex_colors_example.png |
  | :--------: | :--------: |
  | ![colors](./assets/hex_colors.png) | ![colors](./assets/hex_colors_example.png) |



  Sometimes, plots might be related and better placed as subfigures in a larger figure. If
  combining the plots using the `subfigure` environment in latex or similar is not an
  option, this is easily done with [`imagemagick`](https://imagemagick.org/index.php) in a
  systematic way.

  > [!caution]
  >
  > This uses `imagemagick v7`.

  The `Combine` class within the `concat` module implements such procedures, and is also
  conveniently available from the `combine` function in `cosmoplots`.

  An example is shown below. Also see the [`tests`](./tests/) directory for more examples.
  A `help` method that prints the `imagemagick` commands that are used under the hood is
  also available.

  ```python
  import matplotlib.pyplot as plt
  import cosmoplots
  plt.style.use("cosmoplots.default")
  import numpy as np


  def plot(i) -> None:
      """Create a simple plot."""
      a = np.exp(np.linspace(-3, 5, 100))
      fig = plt.figure()
      ax = fig.add_subplot()
      ax.set_xlabel("X Axis")
      ax.set_ylabel("Y Axis")
      ax.semilogy(a)
      plt.savefig(f"./assets/{i}.png")
      plt.close(fig)

  plot(1)
  plot(2)
  plot(3)
  plot(4)
  plot(5)
  plot(6)
  plot(7)
  plot(8)
  plot(9)
  plot(10)

  figs = [f"./assets/{i}.png" for i in range(1, 11)]
  cosmoplots.combine(*figs).using(
      font="JetBrainsMonoNL-NFM-Medium",
      fontsize=30,
      gravity="southeast",
      pos=(100, 200),
      color="green",
  ).in_grid(w=3, h=4).with_labels(  # Specifying labels is optional
      "one", "four", "three", "two", "eight", "six", "seven", "five", "nine", "ten"
  ).save("./assets/concat.png")


  cosmoplots.combine().help()

  cosmoplots.Combine().help()
  ```

  ![concat](./assets/concat.png)


pkgId: e17d131c7bc7280e0de1ae5210d01c8c1f832783c6bd41704187b0a8e8fc4feb
name: python-cosmospl-help
arch: noarch
version: 0.0.13
epoch: 0
release: 1
summary: Development documents and examples for cosmospl
url: https://pypi.org/project/cosmospl/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cosmospl-0.0.13-1.src.rpm
location_href: Packages/python-cosmospl-help-0.0.13-1.noarch.rpm
checksum_type: sha256
description:
  * The MS library does excessive logging so (in my case), Azure Functions logs have to be turned off or are too costly
  https://github.com/Azure/azure-sdk-for-python/issues/12776

  * The MS library always converts the raw json into python lists and dicts immediately using built-in base `json`.

  * If running FastAPI then there is often no point to parsing cosmos results to python objects only for FastAPI to convert them right back to json.

  * Other libraries can parse json faster such as [orjson](https://github.com/ijl/orjson) for python lists and dicts or [polars](https://github.com/pola-rs/polars) to DataFrames. In my experience, polars is better at parsing raw json then row oriented python objects anyway.

  * When you try to read an item that doesn't exist, the MS lib raises an Error so checking if an item exists requires try/except blocks. I'd refer it return None or an empty list.



  Create a Cosmos DB instance
  ```
  from cosmospl import Cosmos

  cosdb = Cosmos('your_db_name', 'your_container_name', 'your_connection_string')


  df = await cosdb.query("select * from c", return_as='pl')
  ```


  All functionality is inside the `Cosmos` class which is similar to the container client in the MS SDK.

  For details please refer to the source.

  To initialize the class pass a database name, container name, and (optionally) the connection string to `Cosmos` as ordered arguments. If the connection string is omitted it'll use the `cosmos` environment variable.

  The methods in that class are:

  `query`: execute a query against the container. Use the `return_as` parameter to specify `pl` for polars dataframe, `dict` for dict/list, `resp` for the httpx response. Unlike MS, it returns everything in one call, it isn't an Async generator.

  `query_stream`: executes a query against the container. It returns an async generator of raw json. It is intended to be used in FastAPI streaming responses so it doesn't have to parse json or accumulate results before sending to end-user.

  In the case of both query methods, Cosmos returns a nested json where the data is inside a Documents key. In order to avoid parsing this in its entirety while only returning data, it looks for `Documents":[` and then only returns from there. Similarly at the end it truncates from  `,"_count"`.

  `create`: creates (not upserts) a record

  `upsert`: upserts a record

  `delete`: deletes a record

  `read`: will read one record based on input id and partition_key

  `get_container_meta`: returns meta data about the container

  `get_pk_ranges`: returns the pk ranges of the container. Can be useful for doing cross partition query requests in chunks using the `pk_id` parameter



  On the Cosmos python sdk page it says:

  > [WARNING] Using the asynchronous client for concurrent operations like shown in this sample will consume a lot of RUs very fast. We strongly recommend testing this out against the cosmos emulator first to verify your code works well and avoid incurring charges.



  1. (optionally) detect datetime columns and automatically convert to pl.Date or pl.Datetime
  2. save a df to cosmos directly (possibly) with metadata so columns can be restored to same types when loaded



  1. Add top level and database classes


pkgId: 040bfd685b53579f5a8833628e21a5e7395ae2c284d3b41ec0a3a21fdf128381
name: python-cosmotech-run-orchestrator-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for cosmotech-run-orchestrator
url: https://www.cosmotech.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cosmotech-run-orchestrator-1.6.0-1.src.rpm
location_href: Packages/python-cosmotech-run-orchestrator-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  This library contains the `csm-orc` cli developed by [Cosmo Tech](https://cosmotech.com/) for its Digital
  Twin platform.

  If you are interested in using it, please contact [Cosmo Tech](https://cosmotech.com/)



  Documentation on the installation is available on
  our [GitHub Page](https://cosmo-tech.github.io/run-orchestrator/)

  Once installed you will have access to the `csm-orc` CLI and all its commands.



  > Copyright - 2023 - 2024 - Cosmo Tech
  >
  > You are authorized to use this Cosmo Tech software following the execution of a specific agreement with Cosmo Tech or with an authorized licensee of Cosmo Tech.
  >
  > Accordingly you should refer to this specific agreement for the purpose of the extent of the use that is permitted. This use shall mainly consist in using, displaying and executing the Cosmo Tech software for your own needs.
  >
  > Except otherwise provided in the above-mentioned specific agreement:
  > - you are not allowed to use this Cosmo Tech software for commercial purpose or to redistribute it without prior authorization from Cosmo Tech;
  > - you are not allowed to copy, duplicate, modify, adapt and translate this Cosmo Tech software except as authorized under section L122-6-1 of the French Intellectual Property Code or specifically under the specific agreement with Cosmo Tech;
  > - you must not remove this notice or any mention related to the copyright of Cosmo Tech;
  >
  > This Cosmo Tech software is provided 'as is', without any express or implied warranty towards the users.
  >
  > Any software generated through the use of this Cosmo Tech software shall be your own property to the extent this software does not contain any part of Cosmo Tech software source code.


pkgId: 48d9803fed43053944cddeb49a0010ecbc6b2026e5124f456dac5ddd5167afdb
name: python-costra-help
arch: noarch
version: 1.1
epoch: 0
release: 1
summary: Development documents and examples for costra
url: https://github.com/barancik/costra
rpm_license: Creative Commons Attribution-Noncommercial-Share Alike license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-costra-1.1-1.src.rpm
location_href: Packages/python-costra-help-1.1-1.noarch.rpm
checksum_type: sha256
description:
  This is a tool for automatic evaluation of Czech sentence embeddings using Costra 1.1 dataset.

  More information can be found in the following paper:

  * Petra Barančíková and Ondřej Bojar: [*Costra 1.1: An Inquiry into Geometric Properties of
      Sentence Spaces*](https://doi.org/10.1007/978-3-030-58323-1_14). In:
      TSD 2020. Lecture Notes in Computer Science, vol 12284. Springer, Cham.

  The presentation of the paper with the accompanying video can be found
    [here](https://www.tsdconference.org/tsd2020/hall/paper_html/1075-omakox.php).




    ```bash
    $ pip install costra

    ```


  1. Get sentences from Costra:

  ```python
  from costra import costra
  CostraEvaluator = costra.CostraEvaluator()
  sentences = CostraEvaluator.get_sentences()
  ```

  2) Generate embeddings (example with SentenceTransformers):

  ```python
  from sentence_transformers import SentenceTransformer

  model = SentenceTransformer("Seznam/retromae-small-cs")
  embeddings = model.encode(sentences)
  ```

  3) Evaluating the embeddings:

  ```python
  results = CostraEvaluator.evaluate(embeddings)
  ```

  4) Results have the following format, with `costra` being the overall score.

  ```python
  {
      'basic': 0.063,
      'modality': 0.079,
      'time': 0.692,
      'style': 0.634,
      'generalization': 0.695,
      'opposite_meaning': 0.751,
      'costra': 0.486
  }
  ```

  For more detail about Costra categories, refer to the original paper.



  If you use the tool, please consider citing
  [the following paper](https://doi.org/10.1007/978-3-030-58323-1_14):

  ```bib
  @inproceedings{Costra,
    author    = {Petra Baran{\v{\c}}{\'{\i}}kov{\'{a}} and Ond{\v{\r}}ej Bojar},
    editor    = {Petr Sojka and Ivan Kope{\v{\c}}ek and Karel Pala and Ales Hor{\'{a}}k},
    title     = {Costra 1.1: An Inquiry into Geometric Properties of Sentence Spaces},
    booktitle = {Text, Speech, and Dialogue - 23rd International Conference, {TSD}
                 2020, Brno, Czech Republic, September 8-11, 2020, Proceedings},
    series    = {Lecture Notes in Computer Science},
    volume    = {12284},
    pages     = {135--143},
    publisher = {Springer},
    year      = {2020},
    url       = {https://doi.org/10.1007/978-3-030-58323-1\_14},
    doi       = {10.1007/978-3-030-58323-1\_14},
  }
  ```



  The data is distributed under the [Creative Commons 4.0 BY](https://creativecommons.org/licenses/by/4.0/).


pkgId: be23be7ad5ac832ca5d42b27a3778effc54a7158d03a084e15aaf9a0495dda31
name: python-coti-web3-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for coti-web3
url: https://github.com/coti-io/coti-web3.py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coti-web3-1.0.2-1.src.rpm
location_href: Packages/python-coti-web3-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  To report an issue, please see the [issues](https://github.com/coti-io/coti-web3.py/issues/new) tab.


pkgId: 014323980576d9056785ce42467f16817ab60d21fe39a0560b2f193a187e1048
name: python-couchbase-haystack-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for couchbase-haystack
url: https://pypi.org/project/couchbase-haystack/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-couchbase-haystack-0.1.0-1.src.rpm
location_href: Packages/python-couchbase-haystack-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Overview](#overview)
  - [Installation](#installation)
  - [Usage](#usage)
  - [License](#license)

  An integration of [Couchbase](https://www.couchbase.com) NoSQL database with [Haystack v2.0](https://docs.haystack.deepset.ai/v2.0/docs/intro)
  by [deepset](https://www.deepset.ai). In Couchbase [Vector search index](https://docs.couchbase.com/server/current/vector-search/vector-search.html)
  is being used for indexing document embeddings and dense retrievals.
  The library allows using Couchbase as a [DocumentStore](https://docs.haystack.deepset.ai/v2.0/docs/document-store), and implements the required [Protocol](https://docs.haystack.deepset.ai/v2.0/docs/document-store#documentstore-protocol) methods. You can start working with the implementation by importing it from `couchbase_haystack` package:
  ```python
  from couchbase_haystack import CouchbaseDocumentStore
  ```
  In addition to the `CouchbaseDocumentStore` the library includes the following haystack components which can be used in a pipeline:
  - [CouchbaseEmbeddingRetriever]() - is a typical [retriever component](https://docs.haystack.deepset.ai/v2.0/docs/retrievers) which can be used to query vector store index and find related Documents. The component uses `CouchbaseDocumentStore` to query embeddings.
  The `couchbase-haystack` library uses [Python Driver](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html).
  `CouchbaseDocumentStore` will store Documents as JSON documents in Couchbase. Embeddings are stored as part of the document, with indexing and querying of vector embeddings managed by Couchbase's dedicated [Vector Search Index](https://docs.couchbase.com/server/current/vector-search/vector-search.html).
  ```text
                                     +-----------------------------+
                                     |       Couchbase Database    |
                                     +-----------------------------+
                                     |                             |
                                     |      +----------------+     |
                                     |      |  Data service  |     |
                  write_documents    |      +----------------+     |
            +------------------------+----->|   properties   |     |
            |                        |      |                |     |
  +---------+--------------+         |      |   embedding    |     |
  |                        |         |      +--------+-------+     |
  | CouchbaseDocumentStore |         |               |             |
  |                        |         |               |index        |
  +---------+--------------+         |               |             |
            |                        |      +--------+--------+    |
            |                        |      |  Search service |    |
            |                        |      +-----------------+    |
            +----------------------->|      |       FTS       |    |
                 query_embeddings    |      |   Vector Index  |    |
                                     |      | (for embedding) |    |
                                     |      +-----------------+    |
                                     |                             |
                                     +-----------------------------+
  ```
  In the above diagram:
  - `Data service` Supports the storing, setting, and retrieving of documents, specified by key. Basically where the documents are stored in key value.
  - `properties` are Document [attributes](https://docs.haystack.deepset.ai/v2.0/docs/data-classes#document) stored as part of the Document.
  - `embedding` is also a property of the Document (just shown separately in the diagram for clarity) which is a vector of type `LIST[FLOAT]`.
  - `Search service` Where indexes specially purposed for Full Text Search and Vector search are created. The Search Service allows for efficient querying
  and retrieval based on both text content and vector embeddings.
  `CouchbaseDocumentStore` requires the vector index to be created manually either by sdk or UI. Before writing documents you should make sure Documents are embedded by one of the provided [embedders](https://docs.haystack.deepset.ai/v2.0/docs/embedders). For example [SentenceTransformersDocumentEmbedder](https://docs.haystack.deepset.ai/v2.0/docs/sentencetransformersdocumentembedder) can be used in indexing pipeline to calculate document embeddings before writing those to Couchbase.

  `couchbase-haystack` can be installed as any other Python library, using pip:
  ```bash
  pip install --upgrade pip # optional
  pip install sentence-transformers # required in order to run pipeline examples given below
  pip install couchbase-haystack
  ```


  You will need a running instance of Couchbase to use the components from this package. There are several options available:
  - [Docker](https://docs.couchbase.com/server/current/getting-started/do-a-quick-install.html)
  - [Couchbase Cloud](https://www.couchbase.com/products/capella) - a fully managed cloud service
  - [Couchbase Server](https://www.couchbase.com/downloads) - installable on various operating systems
  The simplest way to start the database locally is with a Docker container:
  ```bash
  docker run \
      --restart always \
      --publish=8091-8096:8091-8096 --publish=11210:11210 \
      --env COUCHBASE_ADMINISTRATOR_USERNAME=admin \
      --env COUCHBASE_ADMINISTRATOR_PASSWORD=passw0rd \
      couchbase:enterprise-7.6.2
  ```
  In this example, the container is started using Couchbase Server version `7.6.2`. The `COUCHBASE_ADMINISTRATOR_USERNAME` and `COUCHBASE_ADMINISTRATOR_PASSWORD` environment variables set the default credentials for authentication.
  > **Note:**
  > Assuming you have a Docker container running, navigate to <http://localhost:8091> to open the Couchbase Web Console and explore your data.

  Once you have the package installed and the database running, you can start using `CouchbaseDocumentStore` as any other document stores that support embeddings.
  ```python
  from couchbase_haystack import CouchbaseDocumentStore, CouchbasePasswordAuthenticator
  from haystack.utils.auth import Secret
  document_store = CouchbaseDocumentStore(
      cluster_connection_string=Secret.from_env_var("CB_CONNECTION_STRING"),
      authenticator=CouchbasePasswordAuthenticator(
        username=Secret.from_env_var("CB_USERNAME"),
        password=Secret.from_env_var("CB_PASSWORD")
      ),
      bucket = "haystack_bucket_name",
      scope="haystack_scope_name",
      collection="haystack_collection_name",
      vector_search_index = "vector_search_index"
  )
  ```
  Assuming there is a list of documents available and a running couchbase database you can write/index those in Couchbase, e.g.:
  ```python
  from haystack import Document
  documents = [Document(content="Alice has been living in New York City for the past 5 years.")]
  document_store.write_documents(documents)
  ```
  If you intend to obtain embeddings before writing documents use the following code:
  ```python
  from haystack import Document

  from haystack.components.embedders import SentenceTransformersDocumentEmbedder
  documents = [Document(content="Alice has been living in New York City for the past 5 years.")]
  document_embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
  document_embedder.warm_up() # will download the model during first run
  documents_with_embeddings = document_embedder.run(documents)
  document_store.write_documents(documents_with_embeddings.get("documents"))
  ```
  Make sure embedding model produces vectors of same size as it has been set on `Couchbase Vector Index`, e.g. setting `embedding_dim=384` would comply with the "sentence-transformers/all-MiniLM-L6-v2" model.
  > **Note**
  > Most of the time you will be using [Haystack Pipelines](https://docs.haystack.deepset.ai/v2.0/docs/pipelines) to build both indexing and querying RAG scenarios.
  It is important to understand how haystack Documents are stored in Couchbase after you call `write_documents`.
  ```python
  from random import random
  sample_embedding = [random() for _ in range(384)]  # using fake/random embedding for brevity here to simplify example
  document = Document(
      content="Alice has been living in New York City for the past 5 years.", embedding=sample_embedding, meta={"num_of_years": 5}
  )
  document.to_dict()
  ```
  The above code converts a Document to a dictionary and will render the following output:
  ```bash
  >>> output:
  {
      "id": "11c255ad10bff4286781f596a5afd9ab093ed056d41bca4120c849058e52f24d",
      "content": "Alice has been living in New York City for the past 5 years.",
      "dataframe": None,
      "blob": None,
      "score": None,
      "embedding": [0.025010755222666936, 0.27502931836911926, 0.22321073814882275, ...], # vector of size 384
      "num_of_years": 5,
  }
  ```
  The data from the dictionary will be used to create a document in COuchbase after you write the document with `document_store.write_documents([document])`. You could query it with Cypher, e.g. `MATCH (doc:Document) RETURN doc`. Below is a json document Couchbase:
  ```js
  {
    "id": "11c255ad10bff4286781f596a5afd9ab093ed056d41bca4120c849058e52f24d",
    "embedding": [0.6394268274307251, 0.02501075528562069,0.27502933144569397, ...], // vector of size 384
    "content": "Alice has been living in New York City for the past 5 years.",
    "meta": {
      "num_of_years": 5
    }
  }
  ```
  The full list of parameters accepted by `CouchbaseDocumentStore` can be found in
  [API documentation](https://couchbase-ecosystem.github.io/couchbase-haystack/reference/couchbase_document_store).

  With Haystack you can use [DocumentWriter](https://docs.haystack.deepset.ai/v2.0/docs/documentwriter) component to write Documents into a Document Store. In the example below we construct pipeline to write documents to Couchbase using `CouchbaseDocumentStore`:
  ```python
  from haystack import Document
  from haystack.components.embedders import SentenceTransformersDocumentEmbedder
  from haystack.components.writers import DocumentWriter
  from haystack.pipeline import Pipeline
  from haystack.utils.auth import Secret
  from couchbase_haystack import CouchbaseDocumentStore, CouchbasePasswordAuthenticator
  documents = [Document(content="This is document 1"), Document(content="This is document 2")]
  document_store = CouchbaseDocumentStore(
      cluster_connection_string=Secret.from_env_var("CB_CONNECTION_STRING"),
      authenticator=CouchbasePasswordAuthenticator(
        username=Secret.from_env_var("CB_USERNAME"),
        password=Secret.from_env_var("CB_PASSWORD")
      ),
      bucket = "haystack_bucket_name",
      scope="haystack_scope_name",
      collection="haystack_collection_name",
      vector_search_index = "vector_search_index"
  )
  embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
  document_writer = DocumentWriter(document_store=document_store)
  indexing_pipeline = Pipeline()
  indexing_pipeline.add_component(instance=embedder, name="embedder")
  indexing_pipeline.add_component(instance=document_writer, name="writer")
  indexing_pipeline.connect("embedder", "writer")
  indexing_pipeline.run({"embedder": {"documents": documents}})
  ```
  ```bash
  >>> output:
  `{'writer': {'documents_written': 2}}`
  ```

  `CouchbaseEmbeddingRetriever` component can be used to retrieve documents from Couchbase by querying vector index using an embedded query. Below is a pipeline which finds documents using query embedding:
  ```python
  from typing import List
  from haystack.utils.auth import Secret
  from haystack import Document, Pipeline
  from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
  from couchbase_haystack.document_store import CouchbaseDocumentStore, CouchbasePasswordAuthenticator
  from couchbase_haystack.component.retriever import CouchbaseEmbeddingRetriever
  document_store = CouchbaseDocumentStore(
      cluster_connection_string=Secret.from_env_var("CB_CONNECTION_STRING"),
      authenticator=CouchbasePasswordAuthenticator(
        username=Secret.from_env_var("CB_USERNAME"),
        password=Secret.from_env_var("CB_PASSWORD")
      ),
      bucket = "haystack_bucket_name",
      scope="haystack_scope_name",
      collection="haystack_collection_name",
      vector_search_index = "vector_search_index"
  )
  documents = [
      Document(content="Alice has been living in New York City for the past 5 years.", meta={"num_of_years": 5, "city": "New York"}),
      Document(content="John moved to Los Angeles 2 years ago and loves the sunny weather.", meta={"num_of_years": 2, "city": "Los Angeles"}),
  ]

  model_name = "sentence-transformers/all-MiniLM-L6-v2"
  document_embedder = SentenceTransformersDocumentEmbedder(model=model_name)
  document_embedder.warm_up()
  documents_with_embeddings = document_embedder.run(documents)
  document_store.write_documents(documents_with_embeddings.get("documents"))
  print("Number of documents written: ", document_store.count_documents())
  pipeline = Pipeline()
  pipeline.add_component("text_embedder", SentenceTransformersTextEmbedder(model=model_name))
  pipeline.add_component("retriever", CouchbaseEmbeddingRetriever(document_store=document_store))
  pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
  result = pipeline.run(
      data={
          "text_embedder": {"text": "What cities do people live in?"},
          "retriever": {
              "top_k": 5
          },
      }
  )
  documents: List[Document] = result["retriever"]["documents"]
  ```
  ```bash
  >>> output:
  [Document(id=3e35fa03aff6e3c45e6560f58adc4fde3c436c111a8809c30133b5cb492e8694, content: 'Alice has been living in New York City for the past 5 years.', meta: {'num_of_years': 5, 'city': 'New York'}, score: 0.36796408891677856, embedding: "embedding": vector of size 384), Document(id=ca4d7d7d7ff6c13b950a88580ab134b2dc15b48a47b8f571a46b354b5344e5fa, content: 'John moved to Los Angeles 2 years ago and loves the sunny weather.', meta: {'num_of_years': 2, 'city': 'Los Angeles'}, score: 0.3126790523529053, embedding: vector of size 384)]
  ```

  You can find more examples in the implementation [repository](examples):
  - [indexing_pipeline.py](examples/indexing_pipeline.py) - Indexing text files (documents) from a remote http location.
  - [rag_pipeline.py](examples/rag_pipeline.py) - Generative question answering RAG pipeline using `CouchbaseEmbeddingRetriever` to fetch documents from Couchbase document store and answer question using [HuggingFaceAPIGenerator](https://docs.haystack.deepset.ai/v2.0/docs/huggingfacetgigenerator).

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


pkgId: 9521607708e29760085e9b8d51c01b142fb305bc1d44ad01cb6f0a5a90faa382
name: python-coursebox-help
arch: noarch
version: 0.1.20.8
epoch: 0
release: 1
summary: Development documents and examples for coursebox
url: https://lab.compute.dtu.dk/tuhe/coursebox
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coursebox-0.1.20.8-1.src.rpm
location_href: Packages/python-coursebox-help-0.1.20.8-1.noarch.rpm
checksum_type: sha256
description:
  DTU course management software.


  ```terminal
  pip install coursebox
  ```

   - Single semester-dependent configuration file
   - Integrates with DTU Inside/DTU Learn
   - Distribution/evalauation of project reports in Learn-compatible format
   - Quiz-generation in DTU Learn/Beamer friendly format
   - Automatic website/syllabus generation
   - Automatic generation of lectures handouts/exercises (you don't have to track dynamic content like dates/lecture titles; it is all in the configuration)
   - Easy compilation to 2/5 day formats (Continuous education)


  Coursebox requires a specific directory structure. It is easier to start with an existing course and adapt to your needs. Please contact me at tuhe@dtu.dk for more information.


  ```bibtex
  @online{coursebox,
  	title={Coursebox (0.1.1): \texttt{pip install coursebox}},
  	url={https://lab.compute.dtu.dk/tuhe/coursebox},
  	urldate = {2021-09-07},
  	month={9},
  	publisher={Technical University of Denmark (DTU)},
  	author={Tue Herlau},
  	year={2021},
  }
  ```


pkgId: 02b73510961d89f0b2dfe0ff97c18d248992deed202a0811edf42bde06a6e037
name: python-coveo-stew-help
arch: noarch
version: 3.1.6
epoch: 0
release: 1
summary: Development documents and examples for coveo-stew
url: https://github.com/coveo/stew
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-coveo-stew-3.1.6-1.src.rpm
location_href: Packages/python-coveo-stew-help-3.1.6-1.noarch.rpm
checksum_type: sha256
description:
  The 3.0 update contains breaking changes:
  `poetry`, `mypy` and `black` are no longer distributed with `coveo-stew`.

  Please refer to the [upgrade guide](./README_UPGRADE.md#upgrading-from-2x-to-3x) for more information and resolution steps.




  coveo-stew delivers a complete Continuous Integration (CI) and Continuous Delivery (CD) solution
  using [poetry](https://python-poetry.org) as its backend.



  - Config-free pytest, mypy and black runners
  - Add your own linters and tools
  - JUnit report generation
  - GitHub Action that runs all your CI tools

  Similar to: tox


  - GitHub Action for Continuous Delivery (CD) (publish to pypi)
  - Automated "patch" version bumps (requires a `pypi` server)
  - Can download locked dependencies into a folder, for offline distribution

  Similar to: poetry, flit, pbr, setuptools


  - Support for several isolated poetry projects in one GitHub repository
  - Support for local path references
  - A "one ring to rule them all" virtual environment that includes all subprojects within the repository
  - Batch operations
  - Note: Single projects are also supported! 😅

  Similar to: nothing! it's unique! 😎



  *Changed in 3.1*: You need python 3.9+ to run stew, but you can still use it on projects requiring older versions of python.

  *Changed in 3.0*: `poetry` is no longer provided out-of-the-box.

  You need [poetry](https://python-poetry.org/) installed on your system, and it must be available through the `PATH`.

  The `3.0` version of `coveo-stew` is designed to work with modern versions of `poetry`.

  While it is compatible with older versions, old poetry issues
  such as [this](https://github.com/python-poetry/poetry/issues/3189)
  and [this](https://github.com/python-poetry/poetry/issues/3254)
  will cause `stew` to misbehave.

  If you need to work with an older version of poetry,
  consider using `coveo-stew < 3.0` which had workarounds implemented around these issues.




  Just like poetry, `stew` is a CLI tool that you install in your system.

  It is recommended to install using [pipx](https://github.com/pipxproject/pipx) in order to isolate this into a nice little space:

  ```
  pip install pipx --user
  pipx install coveo-stew
  ```

  If you don't use pipx, make sure to isolate the installation into a virtual environment.




  This action checkouts the code, installs python, poetry and stew, and proceeds to run "stew ci" on a python project.



  ```yml
  jobs:
    stew-ci:
      runs-on: ubuntu-latest
      steps:
        - uses: coveo/stew@main
          with:
            python-version: "3.10"
            project-name: your-project-name
  ```

  See additional options and documentation in [the action file.](action.yml)




  When running in a GitHub context, a step summary will automatically be generated.
  This summary can be seen in the `Summary` tab of a workflow run view in GitHub.

  You can disable this feature by launching `stew ci` with `--no-github-step-report`.




  Please read these guides in order to learn how to organize your repository for maximum compatibility:

  - [For a single library](README_SINGLE_LIBRARY.md)
  - [For multiple libraries](README_MULTIPLE_LIBRARIES.md)






  Unless a project name is specified, commands will operate on all projects in a git repository based on the current working folder:

  - `stew <command>`
      - Perform a command on all projects
  - `stew <command> --help`
      - Obtain help about a particular command


  Some commands allow specifying a project name:

  - `stew <command> <project-name>`
      - Perform the command on all projects with `<project-name>` in their name (partial, case-insensitive)
      - e.g.: `stew ci tools` will run on `tools`, `tools-common`, `my-tools`, etc.
  - `stew <command> <project-name> --exact-match`
      - Disable partial project name matching
      - e.g.: `stew ci tools --exact-match` will run on `tools` but not on `tools-common`, `my-tools`, etc.
  - `stew <command> .<path>`
      - **v3.1.3** Only consider the project at this location
      - The path must start with `.`
      - Nested projects will not run
      - e.g.: `stew ci .` will only run on the project in the current folder
      - e.g.: `stew ci ./tools` will only run on the project in the `tools` folder

  The main commands are explained below.




  The main show; it runs all CI tools on one or multiple projects.

  Errors will show in the console, and junit xml reports will be generated inside the `.ci` folder.

  Without configuration, this command will run the following checks:

  - mypy (using opinionated, strict rules)
    - Note: `mypy` is not provided with `coveo-stew`. See [builtin-runners](#builtin-runners) for info.
  - poetry check
  - stew check-outdated

  Options:

  - `--fix` will reformat the code if `black` fails. Additional fix routines may be added in the future.
  - `--check <runner>` will launch only that runner. This option can be repeated.
  - `--skip <runner>` will skip that runner. Takes precedence over `--check`. This option can be repeated.
  - `--quick` skips running `poetry install --remove-untracked` before running the checks.
    - **v3.0.30**: You can now customize which checks to run when `--quick` is specified. See the [quick](#configuration) configuration option.
  - `--no-github-step-report` can be used to disable Step Report generation when running in a GitHub context.
  - `--extra <extra>` *(v3.1.1)* will install the specified extra(s) for this run. Can be specified multiple times.
  - `--all-extras` *(v3.1.1)* will install all extras for this run.
  - `--no-extras` *(v3.1.1)* will not install any extra for this run.

  The configuration for this feature is explained in more details in the [runners](#runners-stew-ci) section.



  Store the project and its **locked dependencies** to disk, so it can be installed without contacting a `pypi` server.

  Optimally used to create truly repeatable builds and workflows (e.g.: containerized images, cloud storage, etc).

  The folder can later be installed offline with `pip install --no-index --find-links <folder> <project-name>`.


  Options:

  - `--directory` specifies where the wheels should be downloaded.
  - `--python` may be used to target a different python. It's important to use the same python version, architecture and OS than the target system.

  **Make sure your target `<folder>` is clean**: Keep in mind that `pip` will still use the `pyproject.toml` constraints when installing, not `poetry.lock`.
  The locked version system works when the locked version is the only thing that `pip` can find in the `<folder>`.




  Checks for out-of-date files or automatically update them.

  Summary of actions:
  - `poetry lock` if `pyproject.toml` changed but not the `poetry.lock`
  - `stew pull-dev-requirements` if a pydev project's dev-requirements are out of sync




  Only useful on `pydev` projects (see about [multiple-libraries](README_MULTIPLE_LIBRARIES.md)).
  It pulls the dev requirements from the local projects in order to aggregate them into the dev requirements of the root project.

  Note: This command uses the `dev` group to identify test dependencies.
  This can be defined as `tool.poetry.dev-dependencies` (poetry 1.1.15) or `tool.poetry.group.dev.dependencies`.
  The group name cannot be customized, feel free to contribute the feature if that's useful to you.




  Calls `poetry lock` on all projects.




  Calls `poetry install` on all projects.




  Clears the `.egg-info` folder from your projects. Usually followed by a `poetry install` or a `stew refresh`.

  Use this if you change a `[tool.poetry.scripts]` section, else the changes will not be honored.




  Returns the path to a project:

  ```
  $ stew locate coveo-stew
  /home/jonapich/code/stew/coveo-stew
  ```





  Configuration is done through the `pyproject.toml` file; default values are shown:

  ```
  [tool.stew]
  build-without-hashes = false
  pydev = false
  build-dependencies = {}
  extras = []
  all-extras = false
  quick = {}
  ```

  - **build-without-hashes**: Disables hashes when calling `pip` to download dependencies during `stew build`.
  - **pydev**: See the [multiple-libraries](README_MULTIPLE_LIBRARIES.md) guide.
  - **build-dependencies**: You can specify additional dependencies to be installed during `stew build`.
    - The format is the same as poetry dependencies: `name = "version"` or `name = { version = "version", ... }`
  - **extras**: A list of extras to install during `stew build` and `stew ci`.
    - *(v3.1.1)* Can be specified at execution time with `stew ci --extra <this> --extra <that>`.
  - **all-extras**: If true, all extras will be installed during `stew build` and `stew ci`. Overrides the `extras` list.
    - *(v3.1.1)* Can be specified at execution time with `stew ci --all-extras` and `stew ci --no-extras`.
  - **quick**: *(v3.0.30)* Controls which checks are skipped when calling `stew ci --quick`.
    - The format is a dictionary with either the `check` or `skip` key, followed by a list of runners.
    - The behavior is identical to the `--check` and `--skip` options.
    - e.g.: skip these checks `quick = { skip = ["poetry-check", "check-outdated", "poetry-build", "pytest"] }`
    - e.g.: only run these checks `quick = { check = ["mypy", "black"] }`


  Configuration is done through each `pyproject.toml` file; default values are shown:

  ```
  [tool.stew.ci]
  mypy = true
  pytest = false
  black = false
  poetry-check = true
  check-outdated = true
  offline-build = false
  ```

  You don't have to include the `[tool.stew.ci]` section at all if these defaults suit you!




  *Changed in coveo-stew 3.0*: mypy and black are no longer provided out-of-the-box.

  In order to use a builtin or custom runner, you must have it installed. These locations are supported:

  - Recommended: The runner is in the project's virtual environment (most likely as a dev dependency in `pyproject.toml`)
  - Alternative: The runner is installed in your system and available through the PATH

  We strongly suggest pinning them to your
  `pyproject.toml` file in the `[tool.poetry.dev-dependencies]` section.

  This way, mypy won't surprise you with new failures when they release new versions! 😎

  Note: You can override and customize most runners by [rewriting them as custom runners.](#custom-runners)






  A strict mypy configuration is provided.

  You can provide your own mypy configuration, but you'll have to specify the `set-config` option:

  ```
  [tool.stew.ci]


  mypy = { set-config = False }


  mypy = { set-config = "mypy.ini" }
  ```

  See https://mypy.readthedocs.io/en/stable/config_file.html#using-a-pyproject-toml



  Pytest is configured to run with `--doctest-modules --tb=short --durations=5` as well as JUnit report generation.

  Some additional options are available:

  ```
  [tool.stew.ci]


  pytest = { marker-expression = 'not docker_tests' }


  pytest = { doctest-modules = False }
  ```




  Black supports the `pyproject.toml` file natively:

  ```
  [tool.black]
  line-length = 100
  ```

  Ref: [black documentation](https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#configuration-via-a-file)




  Runs `poetry check` on each project.




  Runs `stew check-outdated`.

  Note: This runner cannot be overridden, but it can be disabled.




  Runs `stew build` to a temporary folder and ensures that pip is able to reinstall everything from there.

  Note: This runner cannot be overridden, but it can be disabled.




  You can add your own runners to `stew ci`.
  You can also redefine a builtin runner completely.

  In this example, we create runners for flake8, bandit and isort. We also redefine the pytest runner:


  ```
  [tool.stew.ci.custom-runners]
  flake8 = true
  bandit = { check-args = ["--quiet", "--recursive", "."] }


  [tool.stew.ci.custom-runners.isort]
  check-args = ["--check", ".", "--profile black"]
  autofix-args = [".", "--profile black"]

  [tool.stew.ci.custom-runners.pytest]
  check-args = ["--tb=long", "--junitxml=.ci/pytest-results.xml"]


  [tool.stew.ci.custom-runners.ruff-check]
  executable = "ruff"
  working-directory = "project"
  check-args = ["check", "."]
  autofix-args = [ "check", "--fix", "."]

  [tool.stew.ci.custom-runners.ruff-format]
  executable = "ruff"
  working-directory = "project"
  check-args = ["format", "--check", "."]
  autofix-args = ["format", "."]
  ```

  When a builtin runner such as pytest is redefined as a custom runner, you must provide all the arguments.
  In this case, not passing `--junitxml` would mean that we lose the report that used to be in the `.ci/` directory.




  - executable: You can specify the executable name if it's different from the tool's name.
    - Runners are called through `python -m <executable>` first to see if it's installed in the virtual environment, else through the shell.
    - Using `executable`, you can create multiple custom runners with the same executable (e.g.: `ruff check` vs `ruff format`)
  - check-args: The arguments to invoke the check.
  - autofix-args: The arguments to invoke the autofix. Provide the empty string "" in order to run without arguments.
  - check-failed-exit-codes: A list of ints denoting the exit codes to consider "failed" (anything else will be "error"). 0 is always a success. default is `[1]`.
  - create-generic-report: Whether to create a generic pass/fail JUnit report for this check.
  - working-directory: The default is "project" which corresponds to the project's `pyproject.toml` file. You can change it to "repository" in order to run from the root.
  - name: You can specify the module name if it differs from the name of the tool.
    - Deprecated: name must be unique. This has been replaced by `executable`.

  The `args` and `check-args` can be:

  - A string
    - Such as a single argument "--check"
    - Such as a path "."
    - Such as an option "--profile black"
    - But NOT as a combo of the above: "--check . --profile black" will most likely not work.

  - A list of string:
    - Any combination of the "string" rules explained above.






  When you call `poetry install`, you end up installing packages based on the `poetry.lock` file.
  The resulting packages will always be the same, no matter what.
  This is the dev scenario.

  When you call `pip install`, you are installing packages based on the constraints placed in a `pyproject.toml` or a `setup.py` file.
  Unless the constraints are hard pinned versions, the resulting packages are not guaranteed and will depend on the point in time when the installation is performed, among other factors.
  This is the shared library scenario.

  When you use poetry, you cover the two scenarios above.

  The third scenario is the private business use case: you want to freeze your dependencies in time so that everything from the developer to the CI servers to the production system is identical.
  Essentially, you want `poetry install` without the dev requirements.

  This functionality is provided out of the box by `stew build`, which creates a pip-installable package from the lock file that you can then stash in a private storage of your choice or pass around your deployments.




  You can keep `poetry` and `stew` off your production environment by creating a frozen archive of your application or library from your CI servers (docker used as example):

  - Use the `stew build` tool which:
      - performs a `poetry build` on your project
      - calls `pip download` based on the content of the lock file
      - Moves the artifacts to the `.wheels` folder of your repo
  - Recommended: Use the `--python` switch when calling `stew build` to specify which python executable to use! Make sure to use a python interpreter that matches the os/arch/bits of the system you want to provision.

  The content in `.wheels` can then be zipped and moved around. A typical scenario is to push it into a Docker Container:

  - Include the `.wheels` folder into your Docker build context
  - In your Dockerfile:
      - ADD the `.wheels` folder
      - Manage the `pip` version! Either update it to latest, or pin it to something.
      - Prepare a python environment
          - Use `python -m venv <location>` to create a virtual environment natively.
          - Note the executable location... typically (`location/bin/python` or `location/Scripts/python.exe`)
      - Install your application into the python environment you just created:
          - Use `<venv-python-executable> -m pip install <your-package> --no-index --find-links <wheels-folder-location>`
      - You may delete the `.wheels` folder if you want. Consider keeping a copy of the lock file within the docker image, for reference.

  To make sure you use the python interpreter that matches the os/arch/bits of the system you want to provision, you can run `stew build` directly when building the container image.
  In order to do so without packaging `stew` in production, you can use [multi-stage builds](https://docs.docker.com/develop/develop-images/multistage-build/).



  If your IDE supports poetry, it should detect and use the `pyproject.toml` file.

  To set it up manually:

  1. Call `poetry install` from the location of the `pyproject.toml` file
  1. Obtain the location of the virtual environment (i.e.: `poetry env list --full-path`)
  1. Configure your IDE to use the python interpreter from that location

  Your IDE should proceed to analyze the environment and will pick up all imports automatically,
  regardless of your PYTHONPATH or your working directory.
  Since the local source is editable, any change to the source code will be reflected on the next interpreter run.

  If you use the multiple-projects approach, you should hook your IDE to the `pydev` environment. See [this documentation](./README_MULTIPLE_LIBRARIES.md) for more information.




  Using the correct interpreter is all you need to do.
  There is no activation script or environment variables to set up: the interpreter executable inside the virtual environment folder is a fully bootstrapped and isolated environment.

  - A python dockerfile may call `<venv-python-exec>` directly in the dockerfile's CMD
  - A service that spawns other processes should receive the path to the `<venv-python-exec>`

  [Use the `-m` switch](https://docs.python.org/3/using/cmdline.html#cmdoption-m) in order to launch your app!


pkgId: 7fefcd8d19a3cb1cf5698b441a5b0ab6ef93a2249bac53766050e2d0a212228d
name: python-covvi-eci-help
arch: noarch
version: 1.1.4rc3
epoch: 0
release: 1
summary: Development documents and examples for covvi-eci
url: https://covvi-robotics.github.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-covvi-eci-1.1.4rc3-1.src.rpm
location_href: Packages/python-covvi-eci-help-1.1.4rc3-1.noarch.rpm
checksum_type: sha256
description:
  Enable logging debug mode if you wish to see debug messages.


  ```python
  import logging
  logging.getLogger().setLevel(logging.DEBUG)
  ```

  Return logging to warning mode if you wish to hide the debug messages.


  ```python
  import logging
  logging.getLogger().setLevel(logging.WARNING)
  ```



  Installing the ECI Python package is a simple process. It is recommended (but not necessary) to create a virtual environment:

  ```python3 -m pip install virtualenv```

  ```python3 -m venv .venv```

  Then activate this virtual environment:

  ```source ./.venv/bin/activate```

  You can check that your terminal is activated with:

  ```type python pip```

  This should output something similar to:

  ```python is /path/to/your/project/.venv/bin/python```

  ```pip is /path/to/your/project/.venv/bin/pip```

  Install the ECI package via:

  ```pip install covvi-eci```



  Below is an example code snippet for programmatically discovering the interface. In this example, the IP address of the network interface to discover on is: ```192.168.1.1```. You can listen on multiple interfaces at the same time with ```DiscoveryInterface('addr1', 'addr2', ..., 'addrN')```.


  ```python
  from eci import DiscoveryInterface
  with DiscoveryInterface('192.168.1.1') as interface:
      for msg, addr in interface.forever_get_eci_list():
          print(msg)
          break
  HOST = msg.ip
  print(f'The HOST has been set to: {HOST}')
  ```

  Here is an example of obtaining the IP address of the hand by providing the serial number:


  ```python
  from eci import DiscoveryInterface, DiscoveryResponseMsg

  def get_discovery_from_serial(serial_number: int) -> DiscoveryResponseMsg:
      with DiscoveryInterface('192.168.1.1') as interface:
          for msg, addr in interface.forever_get_eci_list():
              if msg.device_serial_number == serial_number:
                  return msg

  msg = get_discovery_from_serial(serial_number=1234)
  print(msg)
  HOST = msg.ip
  print(f'The HOST has been set to: {HOST}')
  ```

  Or set the IP address manually:


  ```python
  HOST = '192.168.1.5'
  ```



  To change the discovery information of the ECI, send a ```DiscoveryConfigMsg``` via the ```DiscoveryInterface```. Only the ```ip```, ```subnet_mask```, ```gateway```, ```hostname```, and ```dhcp``` can be changed. The rest of the attributes must match those of the ```DiscoveryResponseMsg```.


  ```python
  from eci import DiscoveryInterface, DiscoveryConfigMsg, DeviceClassType, Product, ProductID
  with DiscoveryInterface('192.168.1.1') as interface:
      interface.send_config(DiscoveryConfigMsg(
          discovery_version      = 2,                                      # cannot be changed
          device_serial_number   = 1008,                                   # cannot be changed
          mac                    = 'D8:47:8F:3F:63:F0',                    # cannot be changed
          device_class_type      = DeviceClassType.RCI,                    # cannot be changed
          manufacturer_id        = 0,                                      # cannot be changed
          product_id             = Product(ProductID.REMOTE),              # cannot be changed
          ip                     = '192.168.1.6',                          # can be changed
          subnet_mask            = '255.255.255.0',                        # can be changed
          gateway                = '192.168.1.1',                          # can be changed
          dns                    = '192.168.1.1',                          # can be changed
          hostname               = 'covvi-robot3',                         # can be changed
          dhcp                   = False,                                  # can be changed
          hand_comms             = False,                                  # cannot be changed
          hand_power             = False,                                  # cannot be changed
          client_connected       = False,                                  # cannot be changed
          client_address         = '0.0.0.0',                              # cannot be changed
          request_source_address = '192.168.1.1',                          # cannot be changed
      ), '192.168.1.5')
  ```



  All interactions with the ECI occur through the context manager: ```CovviInterface```. It opens and closes the interface:


  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      ...
  ```

  If the 'with' clause is a problem in your application, then you can always use the ```start``` and ```stop``` functions to start and stop the COVVI Interface. Using ```start``` and ```stop``` is preferable when your application uses multiple threads and callback functions.


  ```python
  from eci import CovviInterface
  eci = CovviInterface(HOST).start()
  ...
  eci.stop()
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.setHandPowerOn())
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.setHandPowerOff())
  ```

  Subsequent code snippets assume that ```setHandPowerOn()``` has already been called and that the power to the hand is on. Power to the hand can be determined manually via a blue LED on the 'CAN' label on the hand.








  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getHello())
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getFirmware_PIC_ECI())
      print(eci.getFirmware_PIC_HAND()) # Requires power to the hand (blue LED on)
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getDeviceIdentity())
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getDeviceProduct())
  ```










  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.enableAllRealtimeCfg()
  ```


  ```python
  from time import sleep
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      for _ in range(4):
          eci.setRealtimeCfg(
              digit_status    = True,
              digit_posn      = True,
              current_grip    = True,
              electrode_value = True,
              input_status    = True,
              motor_current   = True,
              digit_touch     = True,
              digit_error     = True,
              environmental   = True,
              orientation     = True,
              motor_limits    = True,
          )
          sleep(2)
          eci.setRealtimeCfg(
              digit_status    = False,
              digit_posn      = False,
              current_grip    = False,
              electrode_value = False,
              input_status    = False,
              motor_current   = False,
              digit_touch     = False,
              digit_error     = False,
              environmental   = False,
              orientation     = False,
              motor_limits    = False,
          )
          sleep(2)
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.disableAllRealtimeCfg()
  ```


  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setRealtimeCfg(
          digit_status    = False,
          digit_posn      = False,
          current_grip    = False,
          electrode_value = False,
          input_status    = False,
          motor_current   = False,
          digit_touch     = False,
          digit_error     = False,
          environmental   = False,
          orientation     = False,
          motor_limits    = False,
      )
  ```


  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setRealtimeCfg()
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.callbackDigitStatusAll  = print
      eci.callbackDigitPosnAll    = print
      eci.callbackCurrentGrip     = print
      eci.callbackElectrodeValue  = print
      eci.callbackInputStatus     = print
      eci.callbackMotorCurrentAll = print
      eci.callbackDigitTouchAll   = print
      eci.callbackDigitError      = print
      eci.callbackEnvironmental   = print
      eci.callbackOrientation     = print
      eci.callbackMotorLimits     = print
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.callbackDigitStatusAll  = print
      eci.callbackDigitPosnAll    = print
      eci.callbackCurrentGrip     = print
      eci.callbackElectrodeValue  = print
      eci.callbackInputStatus     = print
      eci.callbackMotorCurrentAll = print
      eci.callbackDigitTouchAll   = print
      eci.callbackDigitError      = print
      eci.callbackEnvironmental   = print
      eci.callbackOrientation     = print
      eci.callbackMotorLimits     = print

      eci.setRealtimeCfg(
          digit_status    = True,
          digit_posn      = True,
          current_grip    = True,
          electrode_value = True,
          input_status    = True,
          motor_current   = True,
          digit_touch     = True,
          digit_error     = True,
          environmental   = True,
          orientation     = True,
          motor_limits    = True,
      )
      from time import sleep
      sleep(60 * 10)
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.resetRealtimeCfg()
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getDigitStatus_all())
  ```




  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          print(digit.name, eci.getDigitStatus(digit))
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getDigitPosn_all())
  ```




  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          print(digit.name, eci.getDigitPosn(digit))
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setDigitPosn(speed=50, thumb=0xFF, index=0xFF, middle=0xFF, ring=0xFF, little=0xFF, rotate=0xFF)
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setDigitPosn(speed=50, thumb=0, index=0, middle=0, ring=0, little=0, rotate=0)
  ```




  ```python
  from time import sleep
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setDigitPosn(speed=50, thumb=0, index=0, middle=0, ring=0, little=0, rotate=0)
      sleep(1)
      eci.setDigitPosn(speed=50, thumb=0, index=0xFF, middle=0xFF, ring=0xFF, little=0xFF, rotate=0)
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getCurrentGrip())
  ```




  ```python
  from eci import CovviInterface, CurrentGripID
  with CovviInterface(HOST) as eci:
      print(eci.setCurrentGrip(grip_id=CurrentGripID.GN0))
  ```




  ```python
  from eci import CovviInterface, CurrentGripID
  with CovviInterface(HOST) as eci:
      print(eci.setCurrentGrip(grip_id=CurrentGripID.PREC_CLOSED))
  ```


  ```python
  from eci import CovviInterface, Percentage
  with CovviInterface(HOST) as eci:
      eci.setDirectControlClose(speed=Percentage(value=100))
  ```


  ```python
  from eci import CovviInterface, Percentage
  with CovviInterface(HOST) as eci:
      eci.setDirectControlOpen(speed=Percentage(value=100))
  ```


  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setDirectControlStop()
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setDirectControlClose(speed=100)
  ```




  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      eci.setDirectControlOpen(speed=100)
  ```






  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          eci.setDigitMove(digit, position=40, speed=50, power=20, limit=0)
  ```




  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          eci.setDigitMove(digit, position=210, speed=50, power=20, limit=0)
  ```




  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      eci.setDigitMove(Digit.INDEX, position=44, speed=50, power=20, limit=0)
  ```




  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      eci.setDigitMove(Digit.INDEX, position=210, speed=50, power=20, limit=0)
  ```




  ```python
  from random import randint
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          eci.setDigitMove(digit, position=randint(40, 200), speed=50, power=20, limit=0)
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getMotorCurrent_all())
  ```




  ```python
  from eci import CovviInterface, Digit5
  with CovviInterface(HOST) as eci:
      for digit in Digit5:
          print(digit.name, eci.getMotorCurrent(digit))
  ```






  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          print(digit.name, eci.getDigitError(digit))
  ```








  ```python
  from eci import CovviInterface, Digit
  with CovviInterface(HOST) as eci:
      for digit in Digit:
          print(digit.name, eci.getDigitConfig(digit))
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getPinchConfig())
  ```








  ```python
  from eci import CovviInterface, GripNameIndex
  with CovviInterface(HOST) as eci:
      for grip_name_i in list(GripNameIndex):
          print(grip_name_i, eci.getGripName(grip_name_i))
  ```








  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getEnvironmental())
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getSystemStatus())
  ```






  ```python
  from eci import CovviInterface
  with CovviInterface(HOST) as eci:
      print(eci.getOrientation())
  ```








  ```python
  from eci import CovviInterface, GripNameIndex, UserGripID
  with CovviInterface(HOST) as eci:
      print(eci.sendUserGrip(GripNameIndex.GN0, UserGripID.THUMBS_UP))
      for grip_name_i in list(GripNameIndex):
          print(grip_name_i, eci.getGripName(grip_name_i))
  ```




  ```python
  from eci import CovviInterface, GripNameIndex
  with CovviInterface(HOST) as eci:
      eci.resetUserGrips()
      for grip_name_i in list(GripNameIndex):
          print(grip_name_i, eci.getGripName(grip_name_i))
  ```






  ```python
  from eci import CovviInterface, GripNameIndex
  with CovviInterface(HOST) as eci:
      print(eci.removeUserGrip(GripNameIndex.GN0))
      for grip_name_i in list(GripNameIndex):
          print(grip_name_i, eci.getGripName(grip_name_i))
  ```


pkgId: 5ac606263eb2758b9d1ac8f5f49752b38dc983cb1d7ba9b699a82bd1de686422
name: python-cp_measure-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for cp_measure
url: https://pypi.org/project/cp_measure/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cp_measure-0.1.7-1.src.rpm
location_href: Packages/python-cp_measure-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  Do you need to use [[https://github.com/CellProfiler][CellProfiler]] features, but you want to do it in a programmatic way? Look no more, this package was developed by and for the click-a-phobic scientists.

  * Quick overview
  ** Installation

    pip install cp-measure

  *** Poetry
  If you want a development environment.

    git clone git@github.com:afermg/cp_measure.git
    cd cp_measure
    poetry install


  ** Usage
  Users usually want to calculate all the features. There are four type of measurements, based on their inputs:
  - Type 1: 1 image + 1 set of masks (e.g., intensity)
  - Type 2: 2 images + 1 set of masks (e.g., colocalization)
  - Type 3: 2 sets of masks (e.g., number of neighbors)
  - Type 4: 1 image + 2 sets of masks  (e.g., skeleton)

  This shows the simplest way to use the first set (1 image, 1 mask set), which currently follows the style of scikit-image (1 image, 1 matrix with non-overlapping labels).

  import numpy as np

  from cp_measure.bulk import get_core_measurements

  measurements = get_core_measurements()
  print(measurements.keys())


  size = 200
  rng = np.random.default_rng(42)
  pixels = rng.integers(low=0, high=10, size=(size, size))

  masks = np.zeros_like(pixels)
  masks[5:-6, 5:-6] = 1

  results = {}
  for name, v in measurements.items():
      results = {**results, **v(masks, pixels)}

  """
  {'RadialDistribution_FracAtD_1of4': array([0.0477544]),
   'RadialDistribution_MeanFrac_1of4': array([0.98888986]),
   'RadialDistribution_RadialCV_1of4': array([0.04705031]),
   ...
   'Granularity_16': array([100.])}
  """


  **** Multimask (Type 3) methods:




  *** Call specific measurements
  If you need a specific measurement/feature you can just import it. Note that measurements come in sets, so you have to fetch the one that you specifically require from the resultant dictionary. Any available measurement can be found using code as follows:

    import numpy as np

    from cp_measure.minimal.measureobjectsizeshape import get_sizeshape

    mask = np.zeros((50, 50))
    mask[5:-6, 5:-6] = 1
    get_sizeshape(mask, None) # pixels, the second argument, is not necessary for this measurement


  The other available functions are as follows:
  - measureobjectintensitydistribution.get_radial_zernikes,
  - measureobjectintensity.get_intensity,
  - measureobjectsizeshape.get_zernike,
  - measureobjectsizeshape.get_ferret,
  - measuregranularity.get_granularity,
  - measuretexture.get_texture,

  And for Type 2 functions:
  - measurecolocalization.get_correlation_pearson
  - measurecolocalization.get_correlation_manders_fold
  - measurecolocalization.get_correlation_rwc
  - measurecolocalization.get_correlation_costes
  - measurecolocalization.get_correlation_overlap

  For Type 3 functions:
  - measureobjectoverlap.measureobjectoverlap
  - measureobjectneghbors.measureobjectneighboors

  * Pending measurements
  You can follow progress [[https://docs.google.com/spreadsheets/d/1_7jQ8EjPwOr2MUnO5Tw56iu4Y0udAzCJEny-LQMgRGE/edit?usp=sharing][here]].

  *** Done
  - Type 1, 2 and 3 measurements in sklearn style (multiple masks per image)
  *** Pending
  - Add a wrapper for type 3 measurements
  - Type 4 measurements


  *** Additional notes
  The Image-wide functions will not be implemented directly, they were originally implemented independently to the Object (mask) functions. We will adjust the existing functions assume that an image-wide measurement is the same as measuring an object with the same size as the intensity image.


  * Additional notes
  - This is not optimised for efficiency (yet). We aim to reproduce the 'vanilla' results of CellProfiler with minimal code changes. Optimisations will be implemented once we come up with a standard interface for functionally-focused CellProfiler components.
  - The functions exposed perform minimal checks. They will fail if provided with empty masks. Not all functions will fail if provided with masks only.


pkgId: f8f5d553025e10c8a98fb32ba76a40af9efd915710db41b15bbd2b67b8f54751
name: python-cpelib-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for cpelib
url: https://pypi.org/project/cpelib/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cpelib-0.0.1-1.src.rpm
location_href: Packages/python-cpelib-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for parsing, representing, and filtering the NVD CPE Dictionary.



  ```bash
  pip install cpelib
  ```


  Before using the package, you need to download the NVD CPE Dictionary V2.3.
  You can download the latest version from the NVD website: https://nvd.nist.gov/products/cpe

  After downloading the file (e.g., `official-cpe-dictionary_v2.3.xml`), you can use the `cpelib` package to parse the
  file.

  By default, the package looks for the file in the `~/.cpelib` directory.

  ```bash
  mkdir ~/.cpelib
  mv official-cpe-dictionary_v2.3.xml ~/.cpelib
  ```

  Or, you can programmatically change the path by providing the path to the file in the `CPEDictionaryLoader` class.

  ```python
  from cpelib.core.loader import CPEDictionaryLoader

  loader = CPEDictionaryLoader(xml_file="path/to/official-cpe-dictionary_v2.3.xml")
  ```



  > [NOTE] It will take around 2 minutes to parse the entire XML file which contains over 1,341,950 CPE items.
  > Also, makes sure you have enough memory to load the entire dictionary (16GB should be safe).

  Use class CPEDictionaryLoader to define and initialize the loader, then call the loader to parse the XML file.
  The loader will return a dictionary with the cpe-item entries.

  ```python
  from cpelib.core.loader import CPEDictionaryLoader

  loader = CPEDictionaryLoader()
  cpe_dict = loader()
  ```

  Additionally, you can explore the examples in the `examples` directory and run them using the following command:

  ```bash
  python3 -m examples.load_cpe_dict
  ```


pkgId: 6e9aec511466e7f78b38ab07015a26c4e4efabf0d3319da800d080d3732a85a0
name: python-cpg-workflows-help
arch: noarch
version: 1.32.1
epoch: 0
release: 1
summary: Development documents and examples for cpg-workflows
url: https://github.com/populationgenomics/production-pipelines
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cpg-workflows-1.32.1-1.src.rpm
location_href: Packages/python-cpg-workflows-help-1.32.1-1.noarch.rpm
checksum_type: sha256
description:
  Key: ['i', 'j']
  ```
  `gs://cpg-fewgenomes-test/large-cohort/v0-1/relateds_to_drop.ht` is a sample-level table which contains related samples to drop, with top ranking sample selected from each family. Sets of unrelated individuals are determined using Hail's [`maximal_independent_set`](https://hail.is/docs/0.2/methods/misc.html?highlight=maximal_independent_set#hail.methods.maximal_independent_set).
  ```
  Row fields:
      's': str


pkgId: d40cc3046aa6d81faa00cbbf13b4221409e73992bd7b7b4ac6abd913ae34bab4
name: python-cpp-linter-hooks
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Automatically check c/c++ code with clang-format and clang-tidy
url: https://pypi.org/project/cpp-linter-hooks/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cpp-linter-hooks-0.6.0-1.src.rpm
location_href: Packages/python-cpp-linter-hooks-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  +++ b/testing/main.c
  @@ -1,3 +1,6 @@
   
  -int main() {for (;;) break; printf("Hello world!\n");return 0;}
  -
  +int main() {
  +  for (;;) break;
  +  printf("Hello world!\n");
  +  return 0;
  +}
  ```
  Use `--dry-run` in `args` of `clang-format` to print instead of changing the format, e.g.:
  ```bash
  clang-format.............................................................Failed
  - hook id: clang-format
  - exit code: 255
  main.c:2:11: warning: code should be clang-formatted [-Wclang-format-violations]
  int main() {for (;;) break; printf("Hello world!\n");return 0;}
            ^
  main.c:2:13: warning: code should be clang-formatted [-Wclang-format-violations]
  int main() {for (;;) break; printf("Hello world!\n");return 0;}
              ^
  main.c:2:21: warning: code should be clang-formatted [-Wclang-format-violations]
  int main() {for (;;) break; printf("Hello world!\n");return 0;}
                      ^
  main.c:2:28: warning: code should be clang-formatted [-Wclang-format-violations]
  int main() {for (;;) break; printf("Hello world!\n");return 0;}
                             ^
  main.c:2:54: warning: code should be clang-formatted [-Wclang-format-violations]
  int main() {for (;;) break; printf("Hello world!\n");return 0;}
                                                       ^
  main.c:2:63: warning: code should be clang-formatted [-Wclang-format-violations]
  int main() {for (;;) break; printf("Hello world!\n");return 0;}
                                                                ^
  ```

  ```bash
  clang-tidy...............................................................Failed
  - hook id: clang-tidy
  - exit code: 1
  522 warnings generated.
  Suppressed 521 warnings (521 in non-user code).
  Use -header-filter=.* to display errors from all non-system headers. Use -system-headers to display errors from system headers as well.
  /home/runner/work/cpp-linter-hooks/cpp-linter-hooks/testing/main.c:4:13: warning: statement should be inside braces [readability-braces-around-statements]
      for (;;)
              ^
               {
  ```

  We welcome contributions! Whether it's fixing issues, suggesting improvements, or submitting pull requests, your support is greatly appreciated.

  cpp-linter-hooks is licensed under the [MIT License](LICENSE)


pkgId: 91786296cbaf538cc318d105d2493c91b9bb1c35c9fd812a0f8fa34fa1074216
name: python-cpppo-help
arch: noarch
version: 5.2.0
epoch: 0
release: 1
summary: Development documents and examples for cpppo
url: https://github.com/pjkundert/cpppo
rpm_license: Dual License; GPLv3 and Proprietary
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cpppo-5.2.0-1.src.rpm
location_href: Packages/python-cpppo-help-5.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Cpppo is used to create event-driven state machines which consume a stream
  of input and generate a series of state changes, or an indication that no
  progress is possible due to (for example) exhaustion of input symbols.

  This is useful for creating parsers for complex grammars describing
  languages, including binary computer protocols.

  An example included with cpppo is an implementation of a subset of the
  EtherNet/IP CIP language used by some industrial control equipment, such as
  Rockwell's ControlLogix Controllers.  The cpppo.server.enip package can be used
  to create Python programs which can parse requests in this protocol (eg. as a
  server, to implement something like a simulated Controller) or originate
  requests in this protocol (eg. as a client, sending commands to a Controller).

  In addition, the ability to read, write and poll remote PLCs of
  various types including Modbus/TCP is provided.


pkgId: 0b137c2eb25ab9cc5daeca2f1299e0040e2df6ef7f0950e524b890b1b8f5be88
name: python-cppyy-help
arch: noarch
version: 3.5.0
epoch: 0
release: 1
summary: Development documents and examples for cppyy
url: http://cppyy.readthedocs.org
rpm_license: LBNL BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cppyy-3.5.0-1.src.rpm
location_href: Packages/python-cppyy-help-3.5.0-1.noarch.rpm
checksum_type: sha256
description:
  cppyy provides fully automatic, dynamic Python-C++ bindings by leveraging
  the Cling C++ interpreter and LLVM.
  It supports both PyPy (natively), CPython, and C++ language standards
  through C++17 (and parts of C++20).
  Details and performance are described in
  `this paper <http://cern.ch/wlav/Cppyy_LavrijsenDutta_PyHPC16.pdf>`_,
  originally presented at PyHPC'16, but since updated with improved performance
  numbers.
  Full documentation: `cppyy.readthedocs.io <http://cppyy.readthedocs.io/>`_.
  Notebook-based tutorial: `Cppyy Tutorial <https://github.com/wlav/cppyy/blob/master/doc/tutorial/CppyyTutorial.ipynb>`_.


pkgId: d6720018f14bf0c2561f44bab78b0239271e33239b2d425f31ca5dd8d8758e90
name: python-cpr_sdk-help
arch: noarch
version: 1.10.1
epoch: 0
release: 1
summary: Development documents and examples for cpr_sdk
url: https://pypi.org/project/cpr_sdk/
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cpr_sdk-1.10.1-1.src.rpm
location_href: Packages/python-cpr_sdk-help-1.10.1-1.noarch.rpm
checksum_type: sha256
description:
  Internal library for persistent access to text data.

  > **Warning**
  > This library is heavily under construction and doesn't work with any of our open data yet. We're working on making it usable for anyone.



  The base document model of this library is `BaseDocument`, which contains only the metadata fields that are used in the parser.



  The `Dataset` class is automatically configured with the Huggingface repos we use. You can optionally provide a document limit, a dataset version, and override the repo that the data is loaded from.

  If the repository is private you must provide a [user access token](https://huggingface.co/docs/hub/security-tokens), either in your environment as `HUGGINGFACE_TOKEN`, or as an argument to `from_huggingface`.

  ```py
  from cpr_sdk.models import Dataset, GSTDocument

  dataset = Dataset(GSTDocument).from_huggingface(
      version="d8363af072d7e0f87ec281dd5084fb3d3f4583a9", # commit hash, optional
      limit=1000,
      token="my-huggingface-token", # required for private repos if not in env
  )
  ```

  The following flag is used for the passage level and flat dataset.

  ```py
  dataset = Dataset(
      document_model=BaseDocument
  ).from_huggingface(
      dataset_name="ClimatePolicyRadar/passage-level-flat-dataset",
      passage_level_and_flat=True
  )
  ```



  ```py


  document = BaseDocument.load_from_local(folder_path="path/to/data/", document_id="document_1234")

  document = BaseDocument.load_from_remote(dataset_key"s3://cpr-data", document_id="document_1234")
  ```

  To manage metadata, documents need to be loaded into a `Dataset` object.

  ```py
  from cpr_sdk.models import Dataset, CPRDocument, GSTDocument

  dataset = Dataset().load_from_local("path/to/data", limit=1000)
  assert all([isinstance(document, BaseDocument) for document in dataset])

  dataset_with_metadata = dataset.add_metadata(
      target_model=CPRDocument,
      metadata_csv="path/to/metadata.csv",
  )

  assert all([isinstance(document, CPRDocument) for document in dataset_with_metadata])
  ```

  Datasets have a number of methods for filtering and accessing documents.

  ```py
  len(dataset)
  >>> 1000

  dataset[0]
  >>> CPRDocument(...)


  dataset.filter("document_id", "1234")
  >>> Dataset()

  dataset.filter_by_language("en")
  >>> Dataset()


  dataset.filter("document_id", lambda x: x in ["1234", "5678"])
  >>> Dataset()
  ```



  This library can also be used to run searches against CPR documents and passages in Vespa.

  ```python
  from src.cpr_sdk.search_adaptors import VespaSearchAdapter
  from src.cpr_sdk.models.search import SearchParameters

  adaptor = VespaSearchAdapter(instance_url="YOUR_INSTANCE_URL")

  request = SearchParameters(query_string="forest fires")

  response = adaptor.search(request)
  ```

  The above example will return a `SearchResponse` object, which lists some basic information about the request, and the results, arranged as a list of Families, which each contain relevant Documents and/or Passages.



  By default, results are sorted by relevance, but can be sorted by date, or name, eg

  ```python
  request = SearchParameters(
      query_string="forest fires",
      sort_by="date",
      sort_order="descending",
  )
  ```



  Matching documents can also be filtered by keyword field, and by publication date

  ```python
  request = SearchParameters(
      query_string="forest fires",
      filters={
          "language": ["English", "French"],
          "category": ["Executive"],
      },
      year_range=(2010, 2020)
  )
  ```



  A subset of families or documents can be retrieved for search using their ids

  ```python
  request = SearchParameters(
      query_string="forest fires",
      family_ids=["CCLW.family.10121.0", "CCLW.family.4980.0"],
  )
  ```

  ```python
  request = SearchParameters(
      query_string="forest fires",
      document_ids=["CCLW.executive.10121.4637", "CCLW.legislative.4980.1745"],
  )
  ```



  The default search approach uses a nearest neighbour search ranking.

  Its also possible to search for exact matches instead:

  ```python
  request = SearchParameters(
      query_string="forest fires",
      exact_match=True,
  )
  ```

  Or to ignore the query string and search the whole database instead:

  ```python
  request = SearchParameters(
      year_range=(2020, 2024),
      sort_by="date",
      sort_order="descending",
  )
  ```



  The response objects include continuation tokens, which can be used to get more results.

  For the next selection of families:

  ```python
  response = adaptor.search(SearchParameters(query_string="forest fires"))

  follow_up_request = SearchParameters(
      query_string="forest fires"
      continuation_tokens=[response.continuation_token],

  )
  follow_up_response = adaptor.search(follow_up_request)
  ```

  It is also possible to get more hits within families by using the continuation token on the family object, rather than at the responses root

  Note that `this_continuation_token` is used to mark the current continuation of the families, so getting more passages for a family after getting more families would look like this:

  ```python
  follow_up_response = adaptor.search(follow_up_request)

  this_token = follow_up_response.this_continuation_token
  passage_token = follow_up_response.families[0].continuation_token

  follow_up_request = SearchParameters(
      query_string="forest fires"
      continuation_tokens=[this_token, passage_token],
  )
  ```



  Users can also fetch single documents directly from Vespa, by document ID

  ```python
  adaptor.get_by_id(document_id="id:YOUR_NAMESPACE:YOUR_SCHEMA_NAME::SOME_DOCUMENT_ID")
  ```

  All of the above search functionality assumes that a valid set of vespa credentials is available in `~/.vespa`, or in a directory supplied to the `VespaSearchAdapter` constructor directly. See [the docs](docs/vespa-auth.md) for more information on how vespa expects credentials.



  Some tests rely on a local running instance of vespa.

  This requires the [vespa cli](https://docs.vespa.ai/en/vespa-cli.html) to be installed.

  Setup can then be run with:

  ```
  poetry install --all-extras --with dev
  poetry shell
  make vespa_dev_setup
  make test
  ```

  Alternatively, to only run non-vespa tests:

  ```
  make test_not_vespa
  ```

  For clean up:

  ```
  make vespa_dev_down
  ```



  - Make updates to the package.
  - Bump the package version in the `cpr_sdk/version.py` module.
  - Make a PR.
    - In CI/CD we will check that the version is greater than the latest release.
  - Merge.
  - Tag a release manually in github with a version that matches the latest on main that you just merged.
    - In CI/CD we will check that the latest release matches the versions defined in code.
  - Check in `pypi`.


pkgId: 40458130e723c95d5d33b9ff1aec0178719caa2b81fb975ddde903f8d4a5ffa8
name: python-cpymad-lhc-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for cpymad-lhc
url: https://pypi.org/project/cpymad-lhc/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cpymad-lhc-0.2.0-1.src.rpm
location_href: Packages/python-cpymad-lhc-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Cron Testing](https://github.com/JoschD/cpymad_lhc/workflows/Cron%20Testing/badge.svg)](https://github.com/JoschD/cpymad_lhc/actions?query=workflow%3A%22Cron+Testing%22)
  [![Code Climate coverage](https://img.shields.io/codeclimate/coverage/JoschD/cpymad_lhc.svg?style=popout)](https://codeclimate.com/github/JoschD/cpymad_lhc)
  [![Code Climate maintainability (percentage)](https://img.shields.io/codeclimate/maintainability-percentage/JoschD/cpymad_lhc.svg?style=popout)](https://codeclimate.com/github/JoschD/cpymad_lhc)
  [![GitHub last commit](https://img.shields.io/github/last-commit/JoschD/cpymad_lhc.svg?style=popout)](https://github.com/JoschD/cpymad_lhc/)
  [![GitHub release](https://img.shields.io/github/release/JoschD/cpymad_lhc.svg?style=popout)](https://github.com/JoschD/cpymad_lhc/)

  [comment]: <> ([![DOI]&#40;https://zenodo.org/badge/DOI/10.5281/zenodo.5070986.svg&#41;]&#40;https://doi.org/10.5281/zenodo.5070986&#41;)



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


pkgId: 656059592f8c00f7ac2b626e75d64e455e655ef8fe65242b3e9db2080a6bd695
name: python-cq-annotate-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for cq-annotate
url: https://github.com/jmwright/cq-annotate
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cq-annotate-1.0.0-1.src.rpm
location_href: Packages/python-cq-annotate-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  An annotation extension designed to work with the CadQuery parametric CAD API.



  This is not published on PyPI yet, but it can be installed from git via `pip`.

  ```
  pip install git+https://github.com/jmwright/cq-annotate.git
  ```



  * `callouts` - Adds callouts like assembly arrows.
  * `dimensioning` - Adds dimensions like diametral and radial dimensions.
  * `overlays` - Adds overlays such as safety warnings.
  * `views` - Adds ability to set the model up for various views, such as exploded views.



  The methods available from this package can be imported like so:
  ```python
  from cq_annotate.callouts import add_assembly_arrows
  from cq_annotate.dimensioning import add_circular_dimensions
  from cq_annotate.views import explode_assembly
  from cq_annotate.overlays import add_safety_warning
  ```



  * `callouts.add_assembly_arrows` - Automatically adds assembly arrows to faces in an assembly tagged "arrow". The arrow will face in the opposite direction of the normal of the face so that in something like an exploded assembly view the arrows should be indicating the direction to reassemble the assembly. The arrow size can be altered using the `arrow_scale_factor` parameter. More information can be found in the docstring for this method.
  * `views.explode_assembly` - Creates an exploded view of an assembly by translating the parts of the assembly by the `explode_loc` value defined by the designer in the `metadata` parameter of each part. This requires more work on the part of the designer, but provides the proper level of control to ensure that exploded views look correct. More information can be found in the docstring for this method.
  * `dimensioning.add_circular_dimensions` - Adds diametral and radial dimension objects as part of an assembly to a given model, based on tagged features. See the method's docstring for more information.
  * `overlays.add_safety_warning` - Adds a safety overlay that can be overlaid on existing SVG content. See the method's docstring for more information.




  * [add_assembly_arrows_example.py](./examples/add_assembly_arrows_example.py) - A fully commented example showing a simple example of how to use assembly arrows.

  ![Assembly Arrows Example](./docs/images/assembly_arrows_example.png)


  * [add_assembly_lines_example.py](./examples/add_assembly_lines_example.py) - Example showing a simple example of how to use assembly lines.

  ![Assembly Lines Example](./docs/images/assembly_lines_example.png)


  * [explode_assembly_example.py](./examples/explode_assembly_example.py) - A fully commented example showing how a simple assembly can be set up to explode to show the individual components better. In the screenshot below, the two blocks would be touching at the origin if they were not set to be exploded.

  ![Explode Assembly Example](./docs/images/explode_assembly_example.png)


  * [circular_dimensions_example.py](./examples/circular_dimensions_example.py) - Shows a basic example of adding a diameter dimension (radius) to a hole.

  ![Circular Dimension Example](./docs/images/circular_dimension_example.png)


  * [safety_warning_example.py](./examples/safety_warning_example.py) - Adds a customizable safety warning to an existing SVG. The `test_add_safety_warning.svg` file can be copied from the `tests` directory and used with this example.

  ![Safety Warning Example](./docs/images/safety_warning_example.png)


pkgId: 47542a20869388266cfab243c2edf0efa5a2c41f7a52827f267918e5e95f8c23
name: python-cqd-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for cqd
url: https://github.com/rayking99/cqd
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cqd-0.1.1-1.src.rpm
location_href: Packages/python-cqd-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  A lightweight Python utility that provides colored visualization of object attributes, making it easier to inspect objects during development and debugging.



  - Color-coded attribute display:
    - 🔵 Blue: Dunder methods
    - 🟡 Yellow: Protected attributes (starting with `_`)
    - 🟢 Green: Public attributes and methods


  For example - here is a snippet of the tokenizer from huggingface.

  ![alt text](assets/example.png)




  You can install the package using pip:

  ```
  pip install cqd
  ```



  To use the `cqd` function, import it from the package:

  ```python
  from cqd import cqd


  cqd(your_object)
  ```



  Feel free to submit issues or pull requests for improvements or bug fixes.



  This project is licensed under the MIT License.


pkgId: b1495a8a6172140bda88485c4bce8eb5232329035ba079a66ccd345d9523cb7d
name: python-craft-ai-sdk-help
arch: noarch
version: 0.58.0
epoch: 0
release: 1
summary: Development documents and examples for craft-ai-sdk
url: https://www.craft.ai/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-craft-ai-sdk-0.58.0-1.src.rpm
location_href: Packages/python-craft-ai-sdk-help-0.58.0-1.noarch.rpm
checksum_type: sha256
description:
  This Python SDK lets you interact with Craft AI MLOps Platform.


  This project relies on **Python 3.8+**. Once a supported version of Python is installed, you can install `craft-ai-sdk` from PyPI with:

  ```console
  pip install craft-ai-sdk
  ```


  You can configure the SDK by instantiating the `CraftAiSdk` class in this way:

  ```python
  from craft_ai_sdk import CraftAiSdk

  CRAFT_AI_SDK_TOKEN =  # your access key obtained from your settings page
  CRAFT_AI_ENVIRONMENT_URL =  # url to your environment

  sdk = CraftAiSdk(sdk_token=CRAFT_AI_SDK_TOKEN, environment_url=CRAFT_AI_ENVIRONMENT_URL)
  ```

  If using the SDK in interactive mode, some additional feedbacks will be printed. You can force disable or enable those logs by either
  * Setting the `verbose_log` SDK parameter
  * Or setting the `SDK_VERBOSE_LOG` env var


pkgId: e9000c0f83afa365f9feb5020f23eeb281a82a9b1f8be8eda0edd458701accd5
name: python-craft-application-help
arch: noarch
version: 4.6.0
epoch: 0
release: 1
summary: Development documents and examples for craft-application
url: https://pypi.org/project/craft-application/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-craft-application-4.6.0-1.src.rpm
location_href: Packages/python-craft-application-help-4.6.0-1.noarch.rpm
checksum_type: sha256
description:
  This project will provide a basis for future projects similar to Snapcraft_, Charmcraft_ and Rockcraft_, with the eventual goal of rebasing those applications on this.


pkgId: 331917f3ad46e37b5564b0627f7dd1cdfc54a0cf747d075b5ded1c8666a930e1
name: python-craft-ls-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for craft-ls
url: https://pypi.org/project/craft-ls/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-craft-ls-0.1.0-1.src.rpm
location_href: Packages/python-craft-ls-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  `craft-ls` is a [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) implementation for *craft[^1] tools.

  `craft-ls` enables editors that support the LSP to get quality of life improvements while working on *craft configuration files.



  - Diagnostics





  Using `uv` or `pipx`

  ```shell
  uv tool install craft-ls

  pipx install craft-ls
  ```





  ```

  [[language]]
  name = "yaml"
  language-servers = ["craft-ls"]

  [language-server.craft-ls]
  command = "craft-ls"
  ```

  TBD: neovim, VSCode



  Project availability:

  - Python package
  - Snap
  - Nix flake
  - VSCode extension

  Features:

  - Autocompletion **on typing**
  - Symbol documentation

  Ecosystem:

  - Encourage *craft tools to refine their JSONSchemas even further



  TBD

  ```

  use flake  # if you are using nix
  source .venv/bin/activate
  export CRAFT_LS_DEV=true
  ```

  [^1]: only snapcraft and rockcraft so far


pkgId: 02433ec3eaaa9845334bcb80c3cb2d81f0c70dc00df95de50979d3baaebb4160
name: python-craft-parts-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for craft-parts
url: https://github.com/canonical/craft-parts
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-craft-parts-2.2.0-1.src.rpm
location_href: Packages/python-craft-parts-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.com/projects/canonical-craft-parts/badge/?version=latest)](https://canonical-craft-parts.readthedocs-hosted.com/en/latest/?badge=latest)

  Craft-parts provides a mechanism to obtain data from different sources,
  process it in various ways, and prepare a filesystem subtree suitable for
  deployment. The components used in its project specification are called
  *parts*, which can be independently downloaded, built and installed, and
  also depend on each other in order to assemble the subtree containing the
  final artifacts.




  Free software: GNU Lesser General Public License v3




  https://canonical-craft-parts.readthedocs-hosted.com/en/latest/



  A `Makefile` is provided for easy interaction with the project. To see
  all available options run:

  ```
  make help
  ```



  In order to develop any `apt` related items, the `python-apt` package is needed.
  The `apt` extra will require this package in general.

  > Ubuntu 22.04 is assumed in the rest of this setup

  Development packages, such as those to build the Apt Python package are required:

  ```bash
  sudo apt install libapt-pkg-dev intltool fuse-overlayfs python3.10-venv python3-dev gcc g++ make
  ```

  The following are required to run integration tests (it is a default target for `make tests`):
  ```bash
  sudo snap install chisel --candidate
  sudo apt install ninja-build cmake scons qt5-qmake p7zip rpm \
                   autoconf automake autopoint gcc git gperf help2man libtool texinfo \
                   pkg-config
  ```

  Create virtual environment to develop in and activate it:

  ```bash
  python3 -m venv .venv
  source .venv/bin/activate
  ```

  Install the required Python packages

  ```bash
  pip install -e .[dev,docs]
  pip install https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.4.0ubuntu1/python-apt_2.4.0ubuntu1.tar.xz
  ```


  * focal (20.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.0.1ubuntu0.20.04.1/python-apt_2.0.1ubuntu0.20.04.1.tar.xz
  * jammy (22.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.4.0ubuntu1/python-apt_2.4.0ubuntu1.tar.xz
  * lunar (23.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.5.3ubuntu1/python-apt_2.5.3ubuntu1.tar.xz
  * noble (24.04): https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/python-apt/2.7.7ubuntu1/python-apt_2.7.7ubuntu1.tar.xz



  To run all tests in the suite run:

  ```bash
  make tests
  ```

  To get coverage information for Craft Parts from the unit tests:

  ```bash
  make coverage
  ```


  If a new dependency is added to the project run:

  ```bash
  make freeze-requirements
  ```



  To locally verify documentation changes run:

  ```bash
  make docs
  ```

  After running, newly generated documentation shall be available at
  `./docs/_build/html/`.




  Please follow these guidelines when committing code for this project:

  - Use a topic with a colon to start the subject
  - Separate subject from body with a blank line
  - Limit the subject line to 50 characters
  - Do not capitalize the subject line
  - Do not end the subject line with a period
  - Use the imperative mood in the subject line
  - Wrap the body at 72 characters
  - Use the body to explain what and why (instead of how)


pkgId: 029cc06ea4d014b8b75f4291df1c228da91a86da1dd43c703d598d204be3075d
name: python-craft-store-help
arch: noarch
version: 3.1.0
epoch: 0
release: 1
summary: Development documents and examples for craft-store
url: https://pypi.org/project/craft-store/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-craft-store-3.1.0-1.src.rpm
location_href: Packages/python-craft-store-help-3.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.com/projects/canonical-craft-store/badge/?version=latest)](https://canonical-craft-store.readthedocs-hosted.com/en/latest/?badge=latest)



  This project aims to provide python interfaces for communicating with
  Canonical Stores, such as Charmhub and the Snap Store.



  Free software: GNU Lesser General Public License v3



  https://canonical-craft-store.readthedocs-hosted.com.





  To install the necessary build tools, first run:

  ```bash
  make setup
  ```



  To run all tests in the suite run:

  ```
  make test
  ```



  Some integration tests require collaborator permission on the `craft-store-test-charm`
  charm package on the staging craft-store. These can be run by creating a pull request.

  Other integration tests simply require a valid login to the staging charmhub store.
  These can be run by exporting charmhub staging credentials to the environment
  variable `CRAFT_STORE_CHARMCRAFT_CREDENTIALS`. An easy way to do this is to
  run the following command:

  ```
  CHARMCRAFT_STORE_API_URL=https://api.staging.charmhub.io charmcraft login --export cc.cred
  ```

  to login and `export CRAFT_STORE_CHARMCRAFT_CREDENTIALS=$(cat cc.cred)` to put the
  credentials into the environment variable. Note that if you do not have collaborator
  permissions on the charm `craft-store-test`, you can override the environment variable
  `CRAFT_STORE_TEST_CHARM` to point to a charm you do own.



  If a new dependency is added to the project run:

  ```
  uv add '<dependency spec>'
  ```




  To locally verify documentation changes run:

  ```
  make lint-docs
  make docs
  ```


  After running, newly generated documentation shall be available at
  `./docs/_build/html/`.

  While writing documentation, it may be useful to run `make docs-auto`, which will run
  sphinx-autobuild.



  craft-store uses the code and commit conventions common to the Starcraft team, which
  can be found
  [in our common base project](https://github.com/canonical/starbase/blob/main/HACKING.rst)


pkgId: bd6564392589a841f5d51c928c08086d253c933b9480f1640eb820ef3342b445
name: python-craftaxlm-help
arch: noarch
version: 0.0.13
epoch: 0
release: 1
summary: Development documents and examples for craftaxlm
url: https://github.com/JoshuaPurtell/craftaxlm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-craftaxlm-0.0.13-1.src.rpm
location_href: Packages/python-craftaxlm-help-0.0.13-1.noarch.rpm
checksum_type: sha256
description:
  A wrapper around the Craftax agent benchmark, for evaluating digital agents over extremely long time horizons.

  <p align="middle">
    <img src="https://raw.githubusercontent.com/MichaelTMatthews/Craftax/main/images/dungeon_crawling.gif" width="200" />
  </p>


  First, download the package with ```pip install craftaxlm```. Next, import the agent-computer interface of your choice via
  ```
  from craftaxlm import CraftaxACI, CraftaxClassicACI
  ```
  This package is early in development, so for implementation examples, please refer to the [baseline ReAct implementation](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax)


  In order to make experiments reasonable to run across a range of LMs, currently the leaderboard evaluates agents in the following manner:
  1. Five rollouts are sampled from the agent, with a hard cap of 300 actions per rollout.
  2. The agent is evaluated using a modified version of the original Crafter score -
      ```
      sum(ln(1 + P(1_achievement_obtained)) for achievement in achievements) / (sum(ln(2) * len(achievements)))
      ```
      where P(1_achievement_obtained) is the probability of the achievement being obtained in a single rollout. The key idea is that incremental progress towards difficult achievements ought to weigh more heavily in the score.


  | LM | Algorithm | Score (% max) |                                              Code                                               |
  |:----------|---------------:|:-----------------------------------------------------------------------------------------------:|:---------------------------------------:|
  | gpt-4o | ReAct   |            29.6 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |
  | gpt-4o-mini | ReAct   |            18.4 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |


  | LM | Algorithm | Score (% max) |                                              Code                                               |
  |:----------|---------------:|:-----------------------------------------------------------------------------------------------:|:---------------------------------------:|
  | gpt-4o-mini | ReAct   |            02.9 | [CraftaxLM_Baselines](https://github.com/JoshuaPurtell/Apropos/blob/main/apropos/bench/craftax/test.py) |


  ```
  pyenv virtualenv craftax_env
  poetry install
  ```

  When in doubt

  ```
  from jax import debug
  ...
  debug.breakpoint()
  ```


  To learn more about Craftax, check out the paper [website](https://craftaxenv.github.io) here.
  To cite the underlying Craftax environment, see:
  ```
  @inproceedings{matthews2024craftax,
      author={Michael Matthews and Michael Beukman and Benjamin Ellis and Mikayel Samvelyan and Matthew Jackson and Samuel Coward and Jakob Foerster},
      title = {Craftax: A Lightning-Fast Benchmark for Open-Ended Reinforcement Learning},
      booktitle = {International Conference on Machine Learning ({ICML})},
      year = {2024}
  }
  ```
  To cite the Crafter benchmark, see:
  ```
  @article{hafner2021crafter,
    title={Benchmarking the Spectrum of Agent Capabilities},
    author={Danijar Hafner},
    year={2021},
    journal={arXiv preprint arXiv:2109.06780},
  }
  ```



  ```
  uv venv craftaxlm-dev
  source craftaxlm-dev/bin/activate
  uv sync
  uv run ruff format .
  ```

  - General code quality suggestions or improvements. Especially those that improve speed or reduce tokens.
  - PRs to fix issues or add afforances that help your LM agent perform well
  - Leaderboard submissions that demonstrate improved performance using algorithms for learning from data


pkgId: b8a07dc3aeb283d75f012377ce82300cdfb79e7a376431243a9a86ed344936d4
name: python-crashlink-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for crashlink
url: https://pypi.org/project/crashlink/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crashlink-0.0.1-1.src.rpm
location_href: Packages/python-crashlink-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![workflow](https://github.com/N3rdL0rd/crashlink/actions/workflows/python-package.yml/badge.svg)

  Pure Python HashLink bytecode parser/disassembler/decompiler/modding tool

  > [!WARNING]
  > This project is under active development. Breaking changes may be made to APIs with zero notice.



  - Pure Python with zero dependencies, integrates nicely in a lot of places (IDAPython compatible!)
  - Allows values to be externally modified and reserialised through a scriptable interface
  - A very nice little CLI with [hlbc](https://github.com/Gui-Yom/hlbc)-compatible mode.



  ```bash
  pip install crashlink
  ```

  Optionally, install `tqdm` for progress bars when parsing large files:

  ```bash
  pip install crashlink[tqdm]
  ```

  You also need to have Graphviz installed to generate control flow graphs. On most *nix systems, on Windows (with Chocolatey or Scoop), and on MacOS (with Homebrew), you can install it with your package manager under `graphviz`.

  - Windows: `choco install graphviz`
  - MacOS: `brew install graphviz`
  - Debian: `sudo apt install graphviz`
  - Arch: `sudo pacman -S graphviz`
  - Fedora: `sudo dnf install graphviz`



  Either:

  ```py
  from crashlink import *
  code = Bytecode.from_path("path/to/file.hl")
  for func in code.functions:
      if func.findex.value == 22 or func.findex.value == 240: # typical entry points that the compiler generates
          print(disasm.func(code, func))






  ```

  Or:

  ```txt
  $ crashlink path/to/file.hl # or python -m crashlink
  crashlink> funcs
  f@22 static Clazz.main () -> Void (from Clazz.hx)
  f@23 Clazz.method (Clazz) -> I32 (from Clazz.hx)
  crashlink> fn 22
  f@22 static Clazz.main () -> Void (from Clazz.hx)
  Reg types:
    0. Void

  Ops:
    0. Ret             {'ret': 0}                                       return
  ```



  > [!NOTE]
  > This project is configured for the [just](https://just.systems/) command runner. If you don't have it installed, you can still run the commands in the `justfile` manually, but I don't recommend it.

  For development purposes, you can clone the repo, install development dependencies, and run the tests:

  ```bash
  git clone https://github.com/N3rdL0rd/crashlink
  cd crashlink

  just install # or pip install -e .[dev]
  just test # or pytest
  ```

  Before committing, please run `just dev` to format the code, run tests, and generate documentation in `docs/`. If you're adding new features to the core serialisation/deserialisation code (`core.py`), please also add a test case in `tests/haxe/` for the new language feature you're adding. If you're adding a feature to the decompiler or disassembler, please add a normal test case (in Python) in `tests/` that tests the new feature.

  Pull requests are always welcome! For major changes, please open an issue first to discuss what you would like to change.

  You can use the following pre-defined commands with `just`:

  - `just dev`: Run tests, format code, and generate documentation.
  - `just build`: Build the package.
  - `just install`: Install development dependencies and the package in editable mode.
  - `just build-tests`: Build test samples.
  - `just test`: Run tests.
  - `just format`: Format code.
  - `just docs`: Generate documentation.
  - `just check`: Run static analysis/typechecking.
  - `just clean`: Clean up build artifacts.
  - `just profile`: Run the test suite with cProfile and then open the results in a browser.
  - `just serve-docs`: Serve the documentation locally.



  ![Architecture](docs/static/flow.svg)

  > [!NOTE]
  > IR and the IR optimization layers have not yet been fully implemented.



  - Thank you to [Gui-Yom](https://github.com/Gui-Yom) for writing hlbc and for maintaining documentation on the HashLink bytecode format, as well as for providing tests and helping me during development.
  - Thank you to [Haxe Foundation](https://haxe.org/) for creating the HashLink VM and the Haxe programming language.
  - And a big thank you to you, dear user, for being at least partially interested in this project.

  :heart: N3rdL0rd

rpm_license:
  MIT License  Copyright (c) 2024 N3rdL0rd  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: d81a9a11f729a6b555d59ef3b41ce155f2ae280f83f869173139ec5c076f07d3
name: python-crawler-user-agents
arch: noarch
version: 0.21.0
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/monperrus/crawler-user-agents
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crawler-user-agents-0.21.0-1.src.rpm
location_href: Packages/python-crawler-user-agents-0.21.0-1.noarch.rpm
checksum_type: sha256
description:
  This repository contains a list of of HTTP user-agents used by robots, crawlers, and spiders as in single JSON file.

  * NPM package: <https://www.npmjs.com/package/crawler-user-agents>
  * Go package: <https://pkg.go.dev/github.com/monperrus/crawler-user-agents>
  * PyPi package: <https://pypi.org/project/crawler-user-agents/>

  Each `pattern` is a regular expression. It should work out-of-the-box wih your favorite regex library.

  If you use this project in a commercial product, [please sponsor it](https://github.com/sponsors/monperrus).





  Download the [`crawler-user-agents.json` file](https://raw.githubusercontent.com/monperrus/crawler-user-agents/master/crawler-user-agents.json) from this repository directly.



  crawler-user-agents is deployed on npmjs.com: <https://www.npmjs.com/package/crawler-user-agents>

  To use it using npm or yarn:

  ```sh
  npm install --save crawler-user-agents

  yarn add crawler-user-agents
  ```

  In Node.js, you can `require` the package to get an array of crawler user agents.

  ```js
  const crawlers = require('crawler-user-agents');
  console.log(crawlers);
  ```



  Install with `pip install crawler-user-agents`

  Then:

  ```python
  import crawleruseragents
  if crawleruseragents.is_crawler("Googlebot/"):
     
  ```

  or:

  ```python
  import crawleruseragents
  indices = crawleruseragents.matching_crawlers("bingbot/2.0")
  print("crawlers' indices:", indices)
  print(
      "crawler's URL:",
      crawleruseragents.CRAWLER_USER_AGENTS_DATA[indices[0]]["url"]
  )
  ```

  Note that `matching_crawlers` is much slower than `is_crawler`, if the given User-Agent does indeed match any crawlers.



  Go: use [this package](https://pkg.go.dev/github.com/monperrus/crawler-user-agents),
    it provides global variable `Crawlers` (it is synchronized with `crawler-user-agents.json`),
    functions `IsCrawler` and `MatchingCrawlers`.

  Example of Go program:

  ```go
  package main

  import (
  	"fmt"

  	"github.com/monperrus/crawler-user-agents"
  )

  func main() {
  	userAgent := "Mozilla/5.0 (compatible; Discordbot/2.0; +https://discordapp.com)"

  	isCrawler := agents.IsCrawler(userAgent)
  	fmt.Println("isCrawler:", isCrawler)

  	indices := agents.MatchingCrawlers(userAgent)
  	fmt.Println("crawlers' indices:", indices)
  	fmt.Println("crawler's URL:", agents.Crawlers[indices[0]].URL)
  }
  ```

  Output:

  ```
  isCrawler: true
  crawlers' indices: [237]
  crawler' URL: https://discordapp.com
  ```



  I do welcome additions contributed as pull requests.

  The pull requests should:

  * contain a single addition
  * specify a discriminant relevant syntactic fragment (for example "totobot" and not "Mozilla/5 totobot v20131212.alpha1")
  * contain the pattern (generic regular expression), the discovery date (year/month/day) and the official url of the robot
  * result in a valid JSON file (don't forget the comma between items)

  Example:

      {
        "pattern": "rogerbot",
        "addition_date": "2014/02/28",
        "url": "http://moz.com/help/pro/what-is-rogerbot-",
        "instances" : ["rogerbot/2.3 example UA"]
      }



  The list is under a [MIT License](https://opensource.org/licenses/MIT). The versions prior to Nov 7, 2016 were under a [CC-SA](http://creativecommons.org/licenses/by-sa/3.0/) license.



  There are a few wrapper libraries that use this data to detect bots:

   * [Voight-Kampff](https://github.com/biola/Voight-Kampff) (Ruby)
   * [isbot](https://github.com/Hentioe/isbot) (Ruby)
   * [crawlers](https://github.com/Olical/crawlers) (Clojure)
   * [isBot](https://github.com/omrilotan/isbot) (Node.JS)

  Other systems for spotting robots, crawlers, and spiders that you may want to consider are:

   * [Crawler-Detect](https://github.com/JayBizzle/Crawler-Detect) (PHP)
   * [BrowserDetector](https://github.com/mimmi20/BrowserDetector) (PHP)
   * [browscap](https://github.com/browscap/browscap) (JSON files)


pkgId: 6f6bd79877e5281341adcf8013c3f53a94ee240a561a61d3368179cd051f31f3
name: python-crazy-thursday-help
arch: noarch
version: 2024.12.14.1
epoch: 0
release: 1
summary: Development documents and examples for crazy-thursday
url: https://github.com/zqmillet/sphinx-console
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crazy-thursday-2024.12.14.1-1.src.rpm
location_href: Packages/python-crazy-thursday-help-2024.12.14.1-1.noarch.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/badge/sponsored%20by-Crazy--Thursday-brightgreen?logo=KFC)](https://www.kfchk.com/index.html)
  [![](https://img.shields.io/badge/powered%20by-Github%20Actions-brightgreen?logo=Github)](https://docs.github.com/actions)
  [![](https://img.shields.io/pypi/v/crazy-thursday?logo=PyPI)](https://pypi.org/project/crazy-thursday/)
  [![](https://github.com/zqmillet/crazy-thursday/actions/workflows/update_curpus.yaml/badge.svg)](https://github.com/zqmillet/crazy-thursday/actions)

  大家好, 我是秦始皇, 其实我并没有死, 我在西安有 100000 吨黄金, 今天肯德基疯狂星期四, 谁可以 V 我 50 元, 我明天直接带部队复活, 让你统领三军!



  ``` bash
  pip3 install crazy-thursday
  ```

  或者
  ```
  python3 -m pip install crazy-thursday
  ```

  ![](./static/install.svg)



  如果成功安装, 系统中便会存在一个名为 `crazy-thursday` 和一个名为 `kfc` 的命令. 直接调用 `crazy-thursday` 或 `kfc` 便会在控制台中随机地输出一段疯狂星期四文案.

  ![](./static/kfc.svg)



  你不需要贡献代码, 只需要[创建 issue](https://github.com/zqmillet/crazy-thursday/issues/new?assignees=&labels=add+article&template=add-article.yaml&title=thanks+for+taking+the+time+to+contribute+article+about+crazy-thursday.), 并且留下文案即可.

  后台有一个定时任务, 定时收集本项目的所有 issue, 并汇总打包成 `.whl` 文件, 发布到 [PyPI](https://pypi.org/project/crazy-thursday/) 上.



  本项目采用 4 位版本号, 其格式为 `<year>.<month>.<day>.<build>`, 其中:

  - `<year>` 为发布时间中的年份.
  - `<month>` 为发布时间中的月份.
  - `<day>` 为发布时间中的日期.
  - `<build>` 为发布当天构建序号, 从 `0` 开始.

  比如版本 `1926.8.16.3` 含义为该版本是 1926 年 8 月 16 日构建的第 4 个版本.



  本项利用 Github Actions 每天自动发布版本, 其工作原理如下图所示.

  ```mermaid
  %{init: {"theme": "base", "themeVariables": {"primaryColor": "#FFFFFF", "primaryBorderColor": "#000000"}}}%

  graph TD
      A("☁️ https://github.com/zqmillet/crazy-thursday") -->|collect issues| B("📄 crazy_thursday/corpus.jsonl")
      B -->|update version| C("📄 crazy_thursday/__init__.py")
      C --> |commit & push| D("☁️ https://github.com/zqmillet/crazy-thursday")
      D --> |build| E("📦 dist/crazy_thursday-*.whl")
      E --> |publish| F("🌐 https://pypi.org/project/crazy-thursday")
  ```

  定时任务的工作流程为:

  - 首先 clone 项目, 配置 Python, 安装依赖.
  - 执行 `scripts/update_curpus.py` 脚本, 自动抓去本项目的所有 issue 并保存到 `crazy_thursday/corpus.jsonl` 文件中.
  - 更新 `crazy_thursday/__init__.py` 文件中的版本号.
  - 提交 commit 并且 push 回代码仓.
  - 将最新的代码打包成 `.whl` 文件, 并发布到 PyPI 上.

  该定时任务每天会执行两次, 你提交的 issue 会出现在第二天的版本中.


pkgId: 6bc6b51be04886e31dd8e2cc63b8a7900311ebb0665bc4c9ac248d17e597684a
name: python-crc-bonfire-help
arch: noarch
version: 6.0.2
epoch: 0
release: 1
summary: Development documents and examples for crc-bonfire
url: https://www.github.com/RedHatInsights/bonfire
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crc-bonfire-6.0.2-1.src.rpm
location_href: Packages/python-crc-bonfire-help-6.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A CLI tool used by Red Hat engineers to deploy console.redhat.com applications into kubernetes/OpenShift. This tool is mainly used for the purpose of creating ephemeral test environments.

  As an example, typing `bonfire deploy host-inventory` leads to the host-inventory application and all its dependencies being deployed and ready to run in under 4 minutes:

  ![Demo gif](demo.gif)




  - [About](#about)
  - [Installation](#installation)
  - [Quick Start](#quick-start)
    - [Deploying](#deploying)
    - [Namespace Management](#namespace-management)
    - [Namespace Context](#namespace-context)
  - [Examples for Common Use Cases](#examples-for-common-use-cases)
  - [Commonly Used CLI Options](#commonly-used-cli-options)
    - [Deploying/Processing](#deployingprocessing)
    - [Trusted/Untrusted Resource Configurations](#trusteduntrusted-resource-configurations)
  - [Interactions with Ephemeral Namespace Operator](#interactions-with-ephemeral-namespace-operator)
  - [Interactions with Clowder Operator](#interactions-with-clowder-operator)
    - [ClowdEnvironments](#clowdenvironments)
    - [Dependency Processing](#dependency-processing)
  - [Configuration Details](#configuration-details)
    - [Using a local config](#using-a-local-config)
    - [Local config examples](#local-config-examples)
      - [Deploying local repo changes](#deploying-local-repo-changes)
      - [Deploying changes changes in a remote git branch](#deploying-changes-changes-in-a-remote-git-branch)
    - [Advanced](#advanced)
      - [Running a local qontract-server](#running-a-local-qontract-server)



  `bonfire` interacts with a running instance of [qontract-server](https://github.com/app-sre/qontract-server) (the component that powers the [AppSRE team](https://github.com/app-sre/)'s internal `app-interface` graphql API) to obtain applications' OpenShift templates, process them, and deploy them. A local configuration file can be defined that allows you to override an application config if you wish.

  It also interacts with the [ephemeral namespace operator](https://github.com/RedHatInsights/ephemeral-namespace-operator) to manage the reservation of ephemeral namespaces for testing.

  It has special functionality related to the [Clowder operator](https://github.com/RedHatInsights/clowder) and [Frontend operator](https://github.com/RedHatInsights/frontend-operator/) such as auto-deploying ClowdApp dependencies.

  A wide range of CLI options allow you to customize exactly what combination of components get deployed into a namespace.

  > NOTE: for information related to app-interface configurations, see the internal [ConsoleDot Docs](https://consoledot.pages.redhat.com/)





  We'd recommend setting up a virtual environment for bonfire:

  ```bash
  VENV_DIR=~/bonfire_venv
  mkdir -p $VENV_DIR
  python3 -m venv $VENV_DIR
  . $VENV_DIR/bin/activate
  pip install crc-bonfire
  ```

  To prevent GitHub rate limiting issues when bonfire reaches out to GitHub APIs,
  [create a personal access token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token)
  on your GitHub account which grants bonfire read access to your repos.

  Configure bonfire to use the token with:
  ```
  echo 'GITHUB_TOKEN=<your api token>' >> ~/.config/bonfire/env
  ```

  **Please note**: When using the Github token (classic), it **must have** the `read:project` scope.
  In addition, since some projects may be private, you will need to add the `repo` (full control of private repositories) scope too.
  for the template fetching to work!



  ```bash
  brew tap redhatinsights/bonfire
  brew install bonfire
  ```



  We provide a container image at quay.io/cloudservices/bonfire. The image wraps a Python virtual environment with **crc-bonfire** installed on it.

  In order to use Bonfire you have to provide either a valid KUBECONFIG or a URL and a TOKEN to connect to the target OpenShift cluster.

  The container's entrypoint already invokes the **bonfire** CLI with the arguments passed to the container, so you should be able to run any bonfire command you'd typically run, for example:

  ```
  podman run -it --rm quay.io/cloudservices/bonfire version
  ```



  The Bonfire image can use the `OC_LOGIN_SERVER` and `OC_LOGIN_TOKEN` variables to connect to an Openshift cluster.

  ```
  podman run -it --rm -e OC_LOGIN_SERVER=https://api.openshift.example.com:6443 \
      -e OC_LOGIN_TOKEN=some-api-token \
      quay.io/cloudservices/bonfire namespace list
  ```

  You can also make use of the kubeconfig file on your host by mounting it into the container's `$HOME` directory:

  ```
  podman run -it --rm --userns=keep-id:uid=1000,gid=1000 -v ${KUBECONFIG:="$HOME/.kube/config"}:/opt/bonfire/.kube/config:Z \
      quay.io/cloudservices/bonfire namespace list
  ```

  If you desire for the kubeconfig to live in a non-standard location in the container, you can mount the kubeconfig into another path in the container, and set the KUBECONFIG environment variable:

  ```
  podman run -it --rm --userns=keep-id:uid=1000,gid=1000 -v $HOME/.kube/config:/opt/kubeconfig:Z \
      -e KUBECONFIG=/opt/kubeconfig \
      quay.io/cloudservices/bonfire namespace list
  ```



  Start with `bonfire --help` to familiarize yourself with the basic command groups. Don't forget to use the `--help` flag on sub-commmands as well if you are curious to learn more about different CLI commands, options, and arguments.



  The command you are most likely to use is `bonfire deploy`.

  If you are on the Red Hat VPN, `bonfire` will communicate with an internal instance of the App-SRE team's `qontract-server` API. You need to use `oc login` to log in to the ephemeral cluster.

  Once logged in, you should be able to type `bonfire deploy advisor`

  This will cause `bonfire` to do the following:
  1. reserve a namespace
  2. fetch the templates for all components in the 'advisor' app and process them. By default, bonfire will look up the template and commit hash using the 'main'/'master' branch of each component defined in the app. It will look up the git commit hash for this branch and automatically set the `IMAGE_TAG` parameter passed to the templates.
  3. if ClowdApp resources are found, figure out which additional ClowdApps to fetch and process
  4. apply all the processed template resources into your reserved namespace
  5. wait for all the resources to reach a 'ready' state

  Run `bonfire namespace list --mine` and you will see your namespace.

  Switch into that namespace with `oc project <NAMESPACE>`

  Run `oc get clowdapp` in your namespace and you should see several ClowdApps have been deployed.

  If you want to to extend the time you have to work with your namespace, use `bonfire namespace extend <NAMESPACE>`

  When you are done working with your namespace, type `bonfire namespace release <NAMESPACE>` to instruct the ephemeral namespace operator to delete your reservation.

  The deploy command is an 'all-in-one' command that ties together 4 steps:
  1. `bonfire namespace reserve` to reserve a namespace
  2. `bonfire process` to fetch and process app templates
  3. `oc apply` to apply the processed app templates into the namespace
  4. `bonfire namespace wait-on-resources <NAMESPACE>` to wait on all resources in the namespace to reach 'ready' state



  * Reserve a namespace with: `bonfire namespace reserve`
      * By default, the duration is 1 hour. Increase it with `-d/--duration <time>` -- example time format: `48h`
      * Different namespace pools are set up to provide different test environment configurations. Use `--pool <pool>` if you need to select a non-default pool. To get a list of valid pools, use `bonfire pool list`
  * Look up namespaces with: `bonfire namespace list`
      * use `--mine` to see only ones reserved in your name
  * Extend your reservation with: `bonfire namespace extend <NAMESPACE> -d <time>` -- example time format: `48h`
  * Release your namespace reservation with: `bonfire namespace release <NAMESPACE>`



  As of v4.12.0, `bonfire` now analyzes the namespace set in your oc/kubectl context. This means you can run commands such as `namespace extend`, `namespace release`, or `deploy` after you have switched into a namespace using `oc project` and you no longer need to specify the namespace on the CLI. `bonfire` will attempt to use your current namespace (it will run checks to ensure that you own it first and warn if you do not). In addition, when a new namespace is reserved using `bonfire deploy` or `bonfire namespace reserve`, bonfire will also go ahead and run `oc project <NAMESPACE>` for you to switch your context into that new namespace.

  The `deploy` command can be run using the `--reserve` flag if you wish to ignore the current namespace and force a namespace reservation to occur.

  The automatic 'oc' context switching into a newly reserved namespace is disabled when bonfire is operating in "bot" mode (i.e. when the env var `BONFIRE_BOT` is set to `true`). When using bonfire in an automated CI/CD environment such as Jenkins, you should run in bot mode to disable automatic context switching.



  In these examples, we will use the 'advisor' app which has a ClowdApp component named 'advisor-backend'

  * Deploy advisor-backend using a custom git branch:
  ```
  bonfire deploy advisor --set-template-ref advisor-backend=custom_branch
  ```

  * Deploy advisor-backend using a custom git commit:
  ```
  bonfire deploy advisor --set-template-ref advisor-backend=df0d7a620b1ac02e59c5718eb22fe82b8a4cfd3d
  ```

  * Use a certain branch to process the advisor-backend template, but set a different image tag on the container:
  ```
  bonfire deploy advisor --set-template-ref advisor-backend=some_branch --set-parameter advisor-backend/IMAGE_TAG=some_tag
  ```

  * Deploy the production version of advisor and its dependencies:
  ```
  bonfire deploy advisor --ref-env insights-production
  ```

  * Deploy the production version of everything but use a dev branch for advisor-backend:
  ```
  bonfire deploy advisor --ref-env insights-production --set-template-ref advisor-backend=dev_branch
  ```

  * Adjust the 'REPLICAS' parameter value at deploy time:
  ```
  bonfire deploy advisor --set-parameter advisor-backend/REPLICAS=3
  ```

  * Override the tag for all occurences of a specific container image:
  ```
  bonfire deploy advisor --set-image-tag quay.io/cloudservices/advisor-backend=my_tag
  ```




  * `--frontends=true` -- by default, bonfire will not deploy Frontend resources. Use this flag to enable the deployment of app frontends.
  * `--set-image-tag <image uri>=<tag>` -- use this to change the image tag of a container image that appears in your templates. This does a search/replace for all occurences of `<image uri>` and sets the tag to be `<tag>`
  * `--target-env` -- this changes which deploy target `bonfire` looks up to determine the parameters to apply when processing app templates. By default, the target env is set to `insights-ephemeral`
  * `--ref-env` -- this changes which deploy target `bonfire` looks up to determine the git ref to fetch for your app configuration. For example, using `--ref-env insights-stage` would cause bonfire to deploy the stage git ref of your app and `--ref-env insights-production` would cause bonfire to deploy the production git ref of your app. If a target matching the environment is not found, `bonfire` defaults back to deploying the 'main'/'master' branch.
  * `--set-template-ref <component>=<ref>` -- use this to change the git ref deployed for just a single component.
  * `--set-parameter <component>/<name>=<value>` -- use this to set a parameter value on a specific component's template.
  * `--optional-deps-method <hybrid|all|none>` -- change the way that bonfire processes ClowdApp optional dependencies (see "Dependency Processing" section)
  * `--prefer PARAM_NAME=PARAM_VALUE` -- in cases where bonfire finds more than one deployment target, use this to set the parameter names and values that should be used to select a "preferred" deployment target. This option can be passed in multiple times. `bonfire` will select the target with the highest amount of "preferred parameters" on it. Default is currently set to `ENV_NAME=frontends` to select "stable" frontends in the consoledot environments.



  When templates are processed, bonfire removes all untrusted CPU/Memory requests and limits from ClowdApp/ClowdJob/ClowdJobInvocation objects within OpenShift templates (this is because the default value for `--remove-resources` is `all`). If the resource config is unset in a ClowdApp, Clowder will set the deployments to use default values defined in the “ClowdEnvironment” to take effect.

   The reason for this behavior is because many app templates tend to request far more CPU/memory in their template compared to what they actually need in a test environment.

  You can use the `--no-remove-resources` option to turn this behavior off for certain apps or components but the preferred approach is to audit your CPU/memory configurations and set up a resource configuration that bonfire trusts.

  Once you have audited your container CPU/mem usage in test environments and have determined efficient values that you want to use, you can indicate that bonfire should trust the CPU/Memory requests and limits by adhering to the following requirements:

  1. Any ClowdApp/ClowdJob/ClowdJobInvocation in your template asking for CPU/mem using requests or limits should use a parameter with a name formatted like this:
  * `CPU_REQUEST_<NAME>`
  * `CPU_LIMIT_<NAME>`
  * `MEM_REQUEST_<NAME>` or `MEMORY_REQUEST_<NAME>`
  * `MEM_LIMIT_<NAME>` or `MEMORY_LIMIT_<NAME>`

    Where `<NAME>` can be whatever arbitrary name you'd like to use containing `A-Z`, `0-9,` and `_`. For example, either of these would be valid:
    * `CPU_REQUEST_MQ_CONSUMER`
    * `MEM_LIMIT_API`

    **NOTE:** If you only have a single component in your template, you can omit `_<NAME>` from the parameter names if you desire.

  2. Your deployment configuration for the component must explicitly define values for these parameters. For ephemeral environments normally this will mean that your parameters are defined under the ephemeral deploy target in app-interface.

  If these steps are followed then your resource config is considered "trusted" and bonfire will not remove the requests/limits configurations.


  **NOTE:** a couple things that will change in the future:
  * The "host-inventory" app is trusted by default, but once their configurations are tweaked to be trusted we will remove this
  * Object types such as Deployment/StatefulSet/DaemonSet/etc. are not currently analyzed. In future once teams have audited all container resource configurations, we will begin to have bonfire check for trusted configurations on all object types.




  `bonfire` creates/modifies `NamespaceReservation` resources on the cluster to reserve and release namespaces. The template for the object that bonfire applies into the cluster can be found [here](bonfire/resources/reservation-template.yaml)

  For more information about how the ephemeral namespace operator works, see its documentation [here](https://github.com/RedHatInsights/ephemeral-namespace-operator)





  * `bonfire` expects a Clowder `ClowdEnvironment` resource to be created for a namespace before it can deploy into it. This `ClowdEnvironment` is already created by the ephemeral namespace operator.

  * When `bonfire deploy` is executed for a namespace, it will attempt to find the ClowdEnvironment associated with that namespace and set the `ENV_NAME` parameter accordingly for all templates it processes. All templates that define a `ClowdApp` resource should set the `environment` mapping in their spec using a parameter named `${ENV_NAME}`.



  In a ClowdApp definition, an app listed under `dependencies` is considered an app that MUST be present for your app to function, while an app listed under `optionalDependencies` is considered an app that might be absent, but your app could still come up and function without it.

  When bonfire processes templates, if it finds a ClowdApp, it will do the following:
  * if the ClowdApp has `dependencies`, it will try to look up the config for that ClowdApp in app-interface and also fetch its templates
  * if the ClowdApp has `optionalDependencies`, it will behave differently based on which optional dependencies method is selected:

    * `hybrid` (default): if an app group was explicitly specified on the CLI (example: when running `bonfire deploy app-a` the app group 'app-a' is being explicitly specified) then the `optionalDependencies` will be deployed for it. For any ClowdApp `bonfire` comes across that is not a member of an explicitly specified app group, the `optionalDependencies` will NOT be deployed. As an example:
      * `app-a` has `app-b-clowdapp` listed under `optionalDependencies`
      * `app-b-clowdapp` has `app-c-clowdapp` listed under its `optionalDependencies`
      * You will end up with all components of `app-a` and `app-b-clowdapp` in your namespace. `app-c-clowdapp` would NOT be deployed into the namespace.
    * `all`: `bonfire` will deploy all `optionalDependencies` for all ClowdApps it encounters. It will recursively process dependencies. As an example:
      * `app-a` has `app-b-clowdapp` listed under `optionalDependencies`
      * `app-b-clowdapp` has `app-c-clowdapp` listed under its `optionalDependencies`
      * You will end up with all components of `app-a`, `app-b-clowdapp`, AND `app-c-clowdapp` deployed into the namespace.
    * `none`: `bonfire` will ignore the `optionalDependencies` on all ClowdApps that it encounters



  > NOTE: for information related to app-interface configurations, see the internal [ConsoleDot Docs](https://consoledot.pages.redhat.com/)

  When running `bonfire process`/`bonfire deploy`, by default the app-sre team's internal GraphQL API server is used. `bonfire` will query the GraphQL API and read the application's deploy configuration.

  *NOTE*: You need to be on the internal VPN in order to access the default GraphQL API URL.

  `bonfire` relies on a few key pieces of info to process app configs:

  1. The application name. This is typically the name of the listed in `app.yaml` in `app-interface`
  2. A 'target env' -- the name of the `app-interface` environment that bonfire looks at to determine the parameters to apply when processing app templates. An app's config will only be processed if it has a deploy target set up that is pointing to a namespace in this environment (default: "ephemeral")
  3. A 'ref env' -- the name of the `app-interface` environment that we want to use in order to figure out which git ref of the components to deploy and which `IMAGE_TAG` value to set. By default, none is set which causes bonfire to use the 'main'/'master' git branch for all components.
  4. Any template refs you wish to override (optional)
  5. Any image tags you wish to override (optional)
  6. Any parameters you wish to override (optional)

  By default, if app components use `ClowdApp` resources in their templates, then `bonfire` will dynamically load dependencies (see "Dependency Processing" section)



  `bonfire` ships with a [default config](bonfire/resources/default_config.yaml) that should be enough to get started for most internal Red Hat employees.

  By default, the configuration file will be stored in `~/.config/bonfire/config.yaml`.

  If you wish to override any app configurations, you can edit your local configuration file by typing `bonfire config edit`. You can then define an app under the `apps` key of the config. You can reset the config to default at any time using `bonfire config write-default`.

  As of `bonfire` v5, there are two options for how the local configuration is loaded (controlled by the `--local-config-method` CLI option). Let's say we have an app configured in app-interface like this:

  ```
  resourceTemplates:
  - name: mycomponent1
    path: /deployment.yaml
    url: https://github.com/myorg/myrepo1
    targets:
    - namespace:
        $ref: /services/insights/ephemeral/namespaces/ephemeral-base.yml
      parameters:
        MIN_REPLICAS: 1
  - name: mycomponent2
    path: /deployment.yaml
    url: https://github.com/myorg/myrepo2
    targets:
    - namespace:
        $ref: /services/insights/ephemeral/namespaces/ephemeral-base.yml
      parameters:
        MIN_REPLICAS: 2
        SOME_OTHER_PARAM: some_other_value
  ```

  and the local config file has this entry:

  ```
  apps:
  - name: myapp
    components:
    - name: mycomponent2
      parameters:
        MIN_REPLICAS: 10
  ```

  `bonfire` can override the remote configuration using one of two methods:

  1. `--local-config-method merge` (default). In this mode, the apps config in your local config is merged with the configuration that bonfire fetched remotely. With the above config, only the 'MIN_REPLICAS' parameter of 'mycomponent2' within app 'myapp' will be overridden. The 'SOME_OTHER_PARAM' parameter will still be present, and 'mycomponent1' would be unchanged.

  2. `--local-config-method override`. In this mode, the local app configuration will take precedence over the app's configuration that bonfire fetched remotely. In other words, defining a local app configuration will replace the configuration defined in app-interface for ALL components within that app. So 'mycomponent1' would be completely removed, and 'mycomponent2' would only have the parameters you defined in the local config.





  If you wanted to test out some changes you're making to an app but you have not yet pushed these changes to a git repo, the local config could look similar to:

  ```
  apps:
  - name: my_app
    components:
      - name: service
        host: local
        repo: ~/dev/projects/my-app
        path: /clowdapp.yaml
        parameters:
          SOME_PARAMETER: some_value
  ```

  - Where **host** set `local` indicates to look for the repo in a local directory
  - Where **repo** indicates the path to your git repo folder
  - Where **path** specifies the relative path to your ClowdApp template file in your git repo

  By default, `bonfire` will run `git rev-parse` to determine the current working commit hash in your repo folder, and this determines what IMAGE_TAG to set when the template is deployed. This means you would need to have a valid container image pushed for this commit hash. However, you can use `--set-image-tag`/`--set-parameter` or define the `IMAGE_TAG` parameter in your config in order to override the image you wish to use during the deployment.



  If you wanted to deploy changes to your app that you were working on which have been pushed to a PR/branch, the local config could look similar to:

  ```
  apps:
  - name: my_app
    components:
      - name: service
        host: github
        repo: MyOrg/MyRepo
        ref: my_branch
        path: /clowdapp.yaml
  ```

  - Where **host** set to `github` or `gitlab` indicates where the repo is hosted
  - Where **repo** indicates the `OrganizationName/RepoName`
  - Where **path** specifies the relative path to your ClowdApp template file in your git repo
  - Where **ref** specifies the branch or commit of the repo you want to deploy

  By default, bonfire will use the latest commit hash found at the specified git ref to determine what IMAGE_TAG pass on to the deployment templates.




  bonfire is configured to point to the app-sre team's internal GraphQL API by default, but by using env variables you can point to your your own instance of `qontract-server`:

  ```bash
  export QONTRACT_BASE_URL="https://localhost:4000/graphql"
  export QONTRACT_USERNAME=myUsername
  export QONTRACT_PASSWORD=myPassword
  ```

  For testing/debug purposes, instead of committing changes directly to app-interface, you can run your own local copy of the app-interface API server.

  1. Clone https://github.com/app-sre/qontract-server
  2. Clone the internal `app-interface` repo

  In `qontract-server`, run:
  ```
  npm install yarn
  yarn install
  yarn build
  make bundle APP_INTERFACE_PATH=/path/to/app-interface
  LOAD_METHOD=fs DATAFILES_FILE=bundle/bundle.json yarn run server
  ```


pkgId: 0444d90b5530776192724d004c67f3f8cd870121e943de0a4ea4e58fc0186559
name: python-crc-ct-debuginfo
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug information for package python-crc-ct
url: https://pypi.org/project/crc-ct/
rpm_license: zlib/libpng License ; https://opensource.org/license/zlib
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-crc-ct-1.3.3-1.src.rpm
location_href: Packages/python-crc-ct-debuginfo-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-crc-ct.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: a7b4d3007acb439fcb7f90b92ae3a5cfaec865bc842af8f8ffc9dca6225a95d2
name: python-crc-ct-debugsource
arch: aarch64
version: 1.3.3
epoch: 0
release: 1
summary: Debug sources for package python-crc-ct
url: https://pypi.org/project/crc-ct/
rpm_license: zlib/libpng License ; https://opensource.org/license/zlib
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-crc-ct-1.3.3-1.src.rpm
location_href: Packages/python-crc-ct-debugsource-1.3.3-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-crc-ct.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 865748f614ac106843e091273c29cb6dfec086bc2d80fe21861c6a0abea7df94
name: python-createllm-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for createllm
url: https://github.com/khushaljethava/createllm
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-createllm-0.1.6-1.src.rpm
location_href: Packages/python-createllm-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![image](https://img.shields.io/pypi/v/createllm.svg)](https://pypi.python.org/pypi/createllm)
  [![image](https://img.shields.io/conda/vn/conda-forge/createllm.svg)](https://anaconda.org/conda-forge/createllm)


  **A Python package that enables users to create and train their own Language Learning Models (LLMs) from scratch using custom datasets. This package provides a simplified approach to building, training, and deploying custom language models tailored to specific domains or use cases.**


  -   Free software: MIT License
  -   Documentation: https://khushaljethava.github.io/createllm




  -   TODO


pkgId: 86444e1768bcc6667909ac0c0cb6c7896210f54b7f951e016635a46e203aff9d
name: python-credsweeper-help
arch: noarch
version: 1.10.0
epoch: 0
release: 1
summary: Development documents and examples for credsweeper
url: https://github.com/Samsung/CredSweeper
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-credsweeper-1.10.0-1.src.rpm
location_href: Packages/python-credsweeper-help-1.10.0-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub release (latestSemVer)](https://img.shields.io/github/v/release/Samsung/CredSweeper)](https://github.com/Samsung/CredSweeper/releases)
  [![Documentation Status](https://readthedocs.org/projects/credsweeper/badge/?version=latest)](https://credsweeper.readthedocs.io/en/latest/?badge=latest)
  [![License](https://img.shields.io/badge/licence-MIT-green.svg?style=flat)](LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/credsweeper)](https://pypi.org/project/credsweeper/)
  [![Python](https://img.shields.io/pypi/pyversions/credsweeper.svg)](https://badge.fury.io/py/credsweeper)
  [![Test](https://github.com/Samsung/CredSweeper/actions/workflows/test.yml/badge.svg)](https://github.com/Samsung/CredSweeper/actions/workflows/test.yml)
  [![codecov](https://codecov.io/gh/Samsung/CredSweeper/branch/main/graph/badge.svg)](https://codecov.io/gh/Samsung/CredSweeper)
  [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/6055/badge)](https://bestpractices.coreinfrastructure.org/projects/6055)
  [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Samsung/CredSweeper/badge)](https://api.securityscorecards.dev/projects/github.com/Samsung/CredSweeper)

  <img src="https://raw.githubusercontent.com/Samsung/CredSweeper/main/docs/images/Logo.png" width="500"/>

  - [CredSweeper](#credsweeper)
    - [Introduction](#introduction)
    - [How To Use](#how-to-use)
      - [Main Requirements](#main-requirements)
      - [Installation](#installation)
      - [Run](#run)
      - [Config](#config)
    - [Develop](#develop)
      - [Tests](#tests)
      - [Benchmark](#benchmark)
    - [Overall Architecture](#overall-architecture)
    - [Retrain Model](#retrain-model)
    - [License](#license)
    - [How to Get Involved](#how-to-get-involved)
      - [Project Roles](#project-roles)
        - [Contributor](#contributor)
        - [Maintainer](#maintainer)
    - [How to Contact](#how-to-contact)



  CredSweeper is a tool to detect credentials in any directories or files.
  CredSweeper could help users to detect unwanted exposure of credentials
  (such as tokens, passwords, api keys etc.) in advance.
  By scanning lines, filtering, and using AI model as option,
  CredSweeper reports lines with possible credentials, where the line is,
  and expected type of the credential as a result.

  Full documentation can be found here: <https://credsweeper.readthedocs.io/>





  - Python 3.8, 3.9, 3.10, 3.11, 3.12



  Details [here](https://credsweeper.readthedocs.io/en/latest/install.html).

  ```bash
  pip install credsweeper
  ```



  [How to use](https://credsweeper.readthedocs.io/en/latest/guide.html).

  Get all argument list:

  ``` bash
  python -m credsweeper --help
  ```

  Run CredSweeper:

  ``` bash
  python -m credsweeper --path tests/samples/password.gradle --save-json output.json
  ```

  To check JSON file run:

  ```bash
  cat output.json
  ```

  ``` json
  [
      {
          "api_validation": "NOT_AVAILABLE",
          "ml_validation": "VALIDATED_KEY",
          "ml_probability": 0.99755,
          "rule": "Password",
          "severity": "medium",
          "confidence": "moderate",
          "line_data_list": [
              {
                  "line": "password = \"cackle!\"",
                  "line_num": 1,
                  "path": "tests/samples/password.gradle",
                  "info": "",
                  "value": "cackle!",
                  "value_start": 12,
                  "value_end": 19,
                  "variable": "password",
                  "entropy_validation": {
                      "iterator": "BASE64_CHARS",
                      "entropy": 2.120589933192232,
                      "valid": false
                  }
              }
          ]
      }
  ]
  ```



  [credsweeper/secret/config.json](credsweeper/secret/config.json) - Configuration file for pre-processing of CredSweeper. For more details please check [here](https://credsweeper.readthedocs.io/en/latest/overall_architecture.html#pre-processing).

  You can set the `pattern`, `extension` and `path` you want to exclude from scanning as below.

  ``` json
  {
      "exclude": {
          "pattern": [
              "AKIA[0-9A-Z]{9}EXAMPLE",
              ...
          ],
          "extension": [
              "gif",
              "jpg",
              ...
          ],
          "path": [
              "/.git/",
              "/openssl/",
              ...
          ]
      },
      ...
  }
  ```

  And you can also set `source_ext`, `source_quote_ext`, `find_by_ext_list`, `check_for_literals`, `line_data_output`, and `candidate_output` as below.

  - `source_ext`: List of extensions for scanning categorized as source files.
  - `source_quote_ext`: List of extensions for scanning categorized as source files that using quote.
  - `find_by_ext_list`: List of extensions to detect only extensions.
  - `check_for_literals`: Bool value for whether to check line has string literal declaration or not.
  - `line_data_output`: List of attributes of [line_data](credsweeper/credentials/line_data.py) for output.
  - `candidate_output`: List of attributes of [candidate](credsweeper/credentials/candidate.py) for output.

  ``` json
  {
      ...
      "source_ext": [
          ".py",
          ".cpp",
          ...
      ],
      "source_quote_ext": [
          ".py",
          ".cpp",
          ...
      ],
      "find_by_ext_list": [
          ".pem",
          ".cer",
          ...
      ],
      "check_for_literals": true,
      "line_data_output": [
          "line",
          "line_num",
          ...
      ],
      "candidate_output": [
          "rule",
          "severity",
          ...
      ]
  }
  ```

  [credsweeper/rules/config.yaml](credsweeper/secret/config.yaml) - Configuration file for setting Rule. For more details please check [here](https://credsweeper.readthedocs.io/en/latest/overall_architecture.html#rule).

  ``` yaml
  ...
  - name: API
  severity: medium
  confidence: moderate
  type: keyword
  values:
  - api
  filter_type: GeneralKeyword
  use_ml: true
  validations: []
  - name: AWS Client ID
  ...
  ```





  To run all tests:

  ``` bash
  python -m pytest --cov=credsweeper --cov-report=term-missing -s tests/
  ```

  To run only tests independent of external api:

  ``` bash
  python -m pytest -m "not api_validation_test" tests/
  ```

  To obtain manageable (without subprocesses) coverage:

  ``` bash
  python -m pytest --cov=credsweeper --cov-report=html tests/ --ignore=tests/test_app.py
  ```



  We have a dataset for testing credential scanners that called [CredData](https://github.com/Samsung/CredData). If you want to test CredSweeper with this dataset please check [here](https://github.com/Samsung/CredData/blob/main/README.md#benchmark).



  To check overall architecture of CredSweeper please check [here](https://credsweeper.readthedocs.io/en/latest/overall_architecture.html).



  If you want to check how model was trained or retrain it on your own data, please refer to the [experiment](experiment/README.md) folder



  The CredSweeper is an Open Source project released under the terms of [MIT License V2](https://opensource.org/licenses/mit-license.php).



  In addition to developing under an Open Source license, A use an Open Source Development approach, welcoming everyone to participate, contribute, and engage with each other through the project.



  A recognizes the following formal roles: Contributor and Maintainer. Informally, the community may organize itself and give rights and responsibilities to the necessary people to achieve its goals.



  A Contributor is anyone who wishes to contribute to the project, at any level. Contributors are granted the following rights, to:

  - Contribute code, documentation, translations, artwork, and etc.
  - Report defects (bugs) and suggestions for enhancement.
  - Participate in the process of reviewing contributions by others.

  If you want to participate in the project development, check out the [how to contribute guideline](./docs/howto/how-to-contribute.md) in advance.

  Contributors who show dedication and skill are rewarded with additional rights and responsibilities. Their opinions weigh more when decisions are made, in a fully meritocratic fashion.



  A Maintainer is a Contributor who is also responsible for knowing, directing and anticipating the needs of a given a Module. As such, Maintainers have the right to set the overall organization of the source code in the Module, and the right to participate in the decision-making. Maintainers are required to review the contributor’s requests and decide whether to accept or not.

  Name | E-Mail
  -- | --
  [Jaeku Yun](https://github.com/silentearth) | jk0113.yun@samsung.com
  [Shinhyung Choi](https://github.com/csh519) | sh519.choi@samsung.com
  [Roman Babenko](https://github.com/babenek) | r.babenko@samsung.com
  [Yuliia Tatarinova](https://github.com/Yullia) | yuliia.t@samsung.com



  Please post questions, [issues, or suggestions in issues](https://github.com/Samsung/CredSweeper/issues). This is the best way to communicate with the developers.


pkgId: 08c55701135fe7c3b369ab0ef8c68c3629d0f986f2ccec808567019d4b8342eb
name: python-crl-datacube-help
arch: noarch
version: 0.1.27
epoch: 0
release: 1
summary: Development documents and examples for crl-datacube
url: https://git.ucsc.edu/chlowrie/datacube
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crl-datacube-0.1.27-1.src.rpm
location_href: Packages/python-crl-datacube-help-0.1.27-1.noarch.rpm
checksum_type: sha256
description:
  See the examples directory and DataCube class for more information on the API.

  Modified from a [tutorial](https://earthmover.io/blog/serverless-datacube-pipeline) by Ryan Abernathy and the Earthmover team.


  This package is intended to be distributed via pip, or with the attached Dockerfile.  It may need some updating to handle volume mounts for data, which can be done in the Makefile.  And I had some trouble publishing to PyPI from my local Mac M1, but it has been running fine on Linux.


pkgId: 27389ac016addce3f8e0c482ac58afaadf6be56efbe5df2bccd203d64c3b19ae
name: python-crosshair-tool-debuginfo
arch: aarch64
version: 0.0.79
epoch: 0
release: 1
summary: Debug information for package python-crosshair-tool
url: https://github.com/pschanely/CrossHair
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-crosshair-tool-0.0.79-1.src.rpm
location_href: Packages/python-crosshair-tool-debuginfo-0.0.79-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-crosshair-tool.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 62af532ae0bd3ec2707b5ab0cd65e82b4ad5721c55a2b499d3469989b610ddd7
name: python-crosshair-tool-debugsource
arch: aarch64
version: 0.0.79
epoch: 0
release: 1
summary: Debug sources for package python-crosshair-tool
url: https://github.com/pschanely/CrossHair
rpm_license: MIT
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-crosshair-tool-0.0.79-1.src.rpm
location_href: Packages/python-crosshair-tool-debugsource-0.0.79-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-crosshair-tool.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: c140c0a55183d406afef5e3336d3fe109ba3280bb76782bf79b206d08464e2e1
name: python-crosshair-tool-help
arch: aarch64
version: 0.0.79
epoch: 0
release: 1
summary: Development documents and examples for crosshair-tool
url: https://github.com/pschanely/CrossHair
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crosshair-tool-0.0.79-1.src.rpm
location_href: Packages/python-crosshair-tool-help-0.0.79-1.aarch64.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/pschanely/CrossHair/main/doc/source/logo-gray.png" width="5%" align="left">



  [![Join the chat at https://gitter.im/Cross_Hair/Lobby](https://badges.gitter.im/Cross_Hair/Lobby.svg)](https://gitter.im/Cross_Hair/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![Check status](https://github.com/pschanely/CrossHair/workflows/Check/badge.svg)](https://github.com/pschanely/CrossHair/actions?query=workflow%3ACheck)
  [![Downloads](https://static.pepy.tech/badge/crosshair-tool/week)](https://pepy.tech/project/crosshair-tool)

  An analysis tool for Python that blurs the line between testing and
  type systems.

  > **_THE LATEST NEWS:_**
  Python's most popular property-based testing tool,
  [Hypothesis](https://hypothesis.readthedocs.io/en/latest/),
  now supports running CrossHair as an
  [optional backend](https://hypothesis.readthedocs.io/en/latest/strategies.html#alternative-backends)!


  If you have a function with
  [type annotations](https://www.python.org/dev/peps/pep-0484/) and add a
  contract
  [in a supported syntax](https://crosshair.readthedocs.io/en/latest/kinds_of_contracts.html),
  CrossHair will attempt to find counterexamples for you:

  ![Animated GIF demonstrating the verification of a python function](https://raw.githubusercontent.com/pschanely/CrossHair/main/doc/source/duplicate_list.gif)

  CrossHair works by repeatedly calling your functions with symbolic inputs.
  It uses an [SMT solver] (a kind of theorem prover) to explore viable
  execution paths and find counterexamples for you.
  This is not a new idea; a Python approach was first described in
  [this paper].
  However, to my knowledge, CrossHair is the most complete implementation:
  it can use symbolic reasoning for the built-in types, user-defined classes, and much
  of the standard library.

  [SMT solver]: https://en.wikipedia.org/wiki/Satisfiability_modulo_theories
  [this paper]: https://hoheinzollern.files.wordpress.com/2008/04/seer1.pdf

  Try CrossHair right now, in your browser, at [crosshair-web.org]!

  CrossHair has [IDE integrations] for [VS Code], [PyCharm], and more.

  Finally, CrossHair can do more than check contracts. It can also
  [generate unit tests](https://crosshair.readthedocs.io/en/latest/cover.html)
  and
  [find behavioral differences](https://crosshair.readthedocs.io/en/latest/diff_behavior.html)
  between functions.

  [IDE integrations]: https://crosshair.readthedocs.io/en/latest/ide_integrations.html
  [VS Code]: https://marketplace.visualstudio.com/items?itemName=CrossHair.crosshair
  [PyCharm]: https://plugins.jetbrains.com/plugin/16266-crosshair-pycharm

  [crosshair-web.org]: https://crosshair-web.org

  Want to help?
  Sign up for
  [email](http://eepurl.com/hGTLRH)
  or
  [RSS](https://pschanely.github.io/feed.xml)
  updates.
  Star ⭐️ the repository.
  There are
  [other ways to help](https://crosshair.readthedocs.io/en/latest/how_can_i_help.html)
  too.



  * [Introduction](https://crosshair.readthedocs.io/en/latest/introduction.html)
  * [Get Started](https://crosshair.readthedocs.io/en/latest/get_started.html)
  * [The Details: Contracts](https://crosshair.readthedocs.io/en/latest/contracts.html)
  * [The Details: cover](https://crosshair.readthedocs.io/en/latest/cover.html)
  * [The Details: diffbehavior](https://crosshair.readthedocs.io/en/latest/diff_behavior.html)
  * [Kinds of Contracts](https://crosshair.readthedocs.io/en/latest/kinds_of_contracts.html)
  * [Hints for Your Classes](https://crosshair.readthedocs.io/en/latest/hints_for_your_classes.html)
  * [IDE Integrations](https://crosshair.readthedocs.io/en/latest/ide_integrations.html)
  * [Case Studies](https://crosshair.readthedocs.io/en/latest/case_studies.html)
  * [Limitations](https://crosshair.readthedocs.io/en/latest/limitations.html)
  * [Plugins](https://crosshair.readthedocs.io/en/latest/plugins.html)
  * [How Does It Work?](https://crosshair.readthedocs.io/en/latest/how_does_it_work.html)
  * [How Can I Help?](https://crosshair.readthedocs.io/en/latest/how_can_i_help.html)
  * [Related Work](https://crosshair.readthedocs.io/en/latest/related_work.html)
  * [Contributing](https://crosshair.readthedocs.io/en/latest/contributing.html)
  * [Changelog](https://crosshair.readthedocs.io/en/latest/changelog.html)


pkgId: e9f612f3018ffd09d1deb0d4fe48b82a9e6091099fa57b5a77c6945cb8aaf144
name: python-crossref-lmdb-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for crossref-lmdb
url: https://pypi.org/project/crossref-lmdb/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crossref-lmdb-0.1.2-1.src.rpm
location_href: Packages/python-crossref-lmdb-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  * Create a Lightning database from the CrossRef public data export, with optional filtering of DOI items based on custom Python code.
  * Update the database with items from the CrossRef web API that have been added or modified since a given date.
  * Read from the database in Python via a dict-like data structure.


pkgId: a7daaa51f418db2fe36cbbd97f149ea3731434ee8662d2eef4da26feb61d1d42
name: python-crow-client-help
arch: noarch
version: 0.1.dev868
epoch: 0
release: 1
summary: Development documents and examples for crow-client
url: https://pypi.org/project/crow-client/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crow-client-0.1.dev868-1.src.rpm
location_href: Packages/python-crow-client-help-0.1.dev868-1.noarch.rpm
checksum_type: sha256
description:
  A client for interacting with endpoints of the FutureHouse crow service.



  ```bash
  uv pip install crow-client
  ```



  The CrowClient provides simple functions to deploy and monitor your crow.

  ```python
  from pathlib import Path
  from crow_client import CrowJob

  client = CrowClient()

  client.create_crow(
      path=Path("../envs/dummy_env"),
      environment="dummy_env.env.DummyEnv",
      requires_aviary_internal=False,
      environment_variables={"SAMPLE_ENV_VAR": "sample_val"},
      agent="ldp.agent.SimpleAgent",
  )


  client.get_build_status()
  ```

  This client also provides functions that let you send tasks to an existing crow:

  ```python
  from crow_client import CrowJob

  client = CrowClient()

  job_data = {"name": "your-job-name", "query": "your task"}
  client.create_job(job_data)


  client.get_job()
  ```

  The CrowJobClient provides an interface for managing environment states and agent interactions in the FutureHouse crow service.

  ```python
  from crow_client import CrowJobClient
  from crow_client.models.app import Stage

  client = CrowJobClient(
      environment="your_environment_name",
      agent="your_agent_id",
      auth_token="your_auth_token",
      base_uri=Stage.DEV,
      trajectory_id=None
  )
  ```

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


pkgId: d128228d3511247ff4885bee4f895d863780e236337ea7b0f4e9f13583e71c27
name: python-crux-odin-help
arch: noarch
version: 1.5.11
epoch: 0
release: 1
summary: Development documents and examples for crux-odin
url: https://pypi.org/project/crux-odin/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crux-odin-1.5.11-1.src.rpm
location_href: Packages/python-crux-odin-help-1.5.11-1.noarch.rpm
checksum_type: sha256
description:
  ![Odin logo](https://github.com/cruxinformatics/crux-python/blob/master/crux-odin-logo.png?raw=true)


  **Open Data Integration Nomenclature** (ODIN) is Crux’s standard for declarative
  data delivery. ODIN provides a nomenclature for delivery that incentivizes
  industry-standard GitOps practices. ODIN specs are inherently abstracted from
  their underlying control planes and workflow frameworks, but work with the
  Crux External Data Platform.


  This project depends on pyenv for python version management and Poetry for package management and configuration. For instruction on local machine setup please refer to the below resources:

  [Pyenv Install](https://github.com/pyenv/pyenv#installation)
  [Poetry Install](https://python-poetry.org/docs/#installation)




  Right now we store `crux-odin` in the [Google Artifact Registry](https://console.cloud.google.com/artifacts/python/crux-ci/us/crux-python/crux-odin?project=crux-ci).
  This will be changed when we promote to Pypi. For now, make sure you have a file called `~/.pypirc` in your
  home directory with the following content:

  ```ini
  [distutils]
  index-servers = crux-python

  [crux-python]
  repository: https://us-python.pkg.dev/crux-ci/crux-python/
  ```

  To install with the various tools:


  Add the following section to your `Pipfile`:
  ```ini
  [[source]]
  name = "google"
  url = "https://us-python.pkg.dev/crux-ci/crux-python/simple"
  verify_ssl = true

  [pipenv]
  disable_pip_input = false
  ```
  and add
  ```
  keyring = "*"
  "keyrings.google-artifactregistry-auth" = "*"
  crux-odin = "*"
  ```
  under the `[packages]` section. Then do a `pipenv sync --dev`.


  ```bash
  pip install crux-odin==1.5.7 --index-url https://us-python.pkg.dev/crux-ci/crux-python/simple
  ```


  Set up the poetry authentication with
  ```bash
  poetry config http-basic.google oauth2accesstoken $(gcloud auth print-access-token)
  ```
  Add a `gcp` entry to your `pyproject.toml`:
  ```bash
  poetry source add --priority=supplemental gcp https://us-python.pkg.dev/crux-ci/crux-python/simple/
  ```
  and also add the `crux-odin` dependency with
  ```
  poetry add crux-odin=1.5.7 --source=gcp
  ```
  to edit the `pyproject.toml`. Then do a `poetry install`.

  For all installation methods, you can always uninstall `crux-odin` with `pip uninstall crux-odin`.



  ```python
  from crux_odin.dict_utils import yaml_file_to_dict
  from crux_odin.dataclass import create_workflow

  workflow = create_workflow(yaml_file_to_dict("file.yaml"))  # Version of Workflow gotten from YAML file
  ```


  ```python
  from crux_odin.validate_yaml import validate_yaml

  validate_yaml('file.yaml')
  ```


  To update a version
  1. create a branch
  ```bash
  git checkout -b release/[VERSION]
  ```

  2. bump version
  ```bash
  poe version_check # shows output without bumping version
  poe version_bump # to bump version default
  poe version_bump_patch # to increment patch version
  poe version_bump_minor # to increment minor version
  poe version_bump_major # to increment major version
  ```

  3. create PR and merge in main branch
  4. push git tag
  ```bash
  git push origin [VERSION]
  ```

  Reference: https://commitizen-tools.github.io/commitizen/commands/bump/



  See [this page](https://cruxinformatics.atlassian.net/wiki/spaces/TECH/pages/773685252/Description+of+Odin+YAML+fields)
  for a description of the YAML fields.





  * ID (airflow specific)
  * Connection info + extraction info
  * Normalizer spec
  * Schema history + schema validations
  * Context / Environment Variables

  ```yaml
  id: sample_id
  run_uber_step: true

  global:
    global:
      encoding: ascii
      timedelta:
        days: -1
      schema_def:
        na_values: [ "", " " ]
      crux_api_conf: ${SAMPLE_ID_API}
      endpoint: ${API_HOST}
    extract:
      action_class: pipeline.crux_pdk.actions.extract.extractor.ShortCircuitExtractor
      connection_lib: pipeline.custom_libs.sample.connector
      fetch_method: fetch_directory
      remote_path: /pub/sparx/
      connection:
        type: SAMPLE_ID_CONNECTOR
        conf: ${CRUX_SPARTA_SFTP}
        zendesk_conf:
          wait_time: 60
          payload:
            organization_id: 123123123123
            role: end-user
            ticket_restriction: organization
            skip_verify_email: true

  pipelines:
    - id: sample_id
      global:
        global:
          supplier_implied_date_regex: active_users_(?P<YYYY>\d{4})(?P<MM>\d{2})(?P<DD>\d{2})
          provenance_file_patterns:
            origin_patterns:
              - active_ts_users_(?P<YYYY>\d{4})(?P<MM>\d{2})(?P<DD>\d{2})
            return_patterns:
              - active_ts_users_(?P<YYYY>\d{4})(?P<MM>\d{2})(?P<DD>\d{2})
      steps:
        - id: extract
          category: short_circuit
          conf:
            file_patterns:
              - active_users_{FD_YYYY}{FD_MM}{FD_DD}\.csv
  ```
  Note: the outside global is inherited by the pipelines, the 'inside' global is inherited by the steps.
  The IDs have to match, `extract` above matches `- id: extract`


  This is the first version of the spec that replaces the .py DAG files with full declarative syntax in YAML.

  **Newly supported capabilities**

  * Schedule
  ```yaml
  ...:
    dag:
     dag_catchup: false            # (schedule catch up runs to current date starting from start date)
     dag_start_date: '2023-03-12'  # (when the dag start running)
     enable_delivery_cache: false  # (required for dag files)
     max_active_runs: 10.          # (max active run in airflow system for this dag)
     owner: CruxInformatics        # (owner of the dag)
     priority_weight: 1            # (the order in which this dag is given priority compared to others)
     schedule_interval: '@once'    # (dag schedule, when dag will be triggered after dag start date)
     queue: kubernetes             # (the worker pool to run the jobs,
                                   
     tags:                         # (enable the tag searches/filtering on optional and only available in cloud composer)
     - spm
     - delivery-dispatch
  ```


  Version 1.2 brings Dataset ID, a grouping of all data delivered or failed together, Data Product ID, a catalog-oriented collection of Datasets, and Org ID, a useful organizational grouping of Datasets. These fields are opinionated to Crux's control plane, but we find these concepts are widely used and necessary for most Control Plane implementations of ODIN. We will be reviewing generic versions of this in the future. The `dataset_id` and `data_product_id` will be validated to make sure they are in the `org_id`. `crux_api_conf` _is not_ deprecated in this version (yet).
  `data_product_id` is optional while `dataset_id` and `org_id` are required.

  **Newly supported capabilities**
  * Dataset ID
  * Data Product ID
  * Org ID
  ```yaml
  ...:
    metadata:
        dataset_id: 'Ds012345'          # a grouping of transactional data. 1:1 with ODIN spec
        data_product_id: 'Dp012345'     # a collection of Datasets for cataloging and productization
        org_id: 'Or012345'              # organizational identifier for a control plane
  ```


  Version 1.3 adds support for users to track schemas that are declared in vendor documentation, as well as observed from profiling the data. These schemas are only advisory, as the configured schema is what is primarily used in  control plane implementations. These new fields are made optional, and the vendor-declared schema is defined and validated according to the requirements needed for ODIN to support hydration of the Crux Catalog. Frame description is also added as an optional field to the configured schema.

  **Newly supported capabilities**
  * declared_schema_def
  * observed_schema_def
  * vendor_doc
  * frame_description

  ```yaml
  ...:
  pipelines:
    - id:
      vendor_doc:                   # URI (optional)
      global:
        global:
            schema_def:                   # Already exists
              ...
            declared_schema_def:          # declared or curated schema (optional)
              vendor_table_name:
              vendor_table_description:
              vendor_schedule:
              fields:
              - name:
                data_type:
                configured_data_type:   # must exist in schema_def and have same type
                configured_name:        # must exist in schema_def and have same name
                column_number:
                is_primary_key:
                page_number:
                vendor_description:
              - name: ...
            observed_schema_def:          # observed from profiling the data
              fields:
              - data_type:
                name:
                configured_data_type:   # must exist in schema_def and have same type
                configured_name:        # must exist in schema_def and have same name
              - name: ...
  ```


  Allows the Control Plane the ability to apply to hydrate delivery deadlines. This provides users visibility into upstream data availability issues by specifying a cadence for expected new data.

  **Newly supported capabilities**
  * Deadline
  ```yaml
  availability_deadlines:
  - deadline_minute: '30' # The minute to run the check
    deadline_hour: '8' # The hour to evaluate the
    deadline_day_of_month: '*' # Used for monthly and longer frequencies
    deadline_month: '*' # Used for yearly frequency
    deadline_day_of_week: '1' # supports cron pattern day range and *W (for weekdays)
    deadline_year: '*' # Must be *
    file_frequency: 'weekly' # One of "intraday", "daily", "weekly", "bi-weekly", "monthly", "semi-annual", "yearly"
    timezone: 'UTC'
  - deadline_minute: '30' # Supports multiple deadlines
    deadline_hour: '8'
    deadline_day_of_month: '*'
    deadline_month: '*'
    deadline_day_of_week: '5'
    deadline_year: '*'
    file_frequency: 'weekly'
    timezone: 'UTC'
  piplines:
  ...
  ```


  This allows a list of Destinations selected from the domain model to be used by Delivery Dispatch.

  **Newly supported capabilities**
  * Destinations
  ```yaml
  destinations:
    - id: AQxxxxxxxxxx
      name: Customer FTP site
  ...
  ```


  This roadmap outlines the incremental modeling capabilities that we plan to support in ODIN, but is not a commitment.


  This allows for notification channels.


pkgId: 7eba7e28b5dd19c95080c0e8a07851a5ba88aab1f095e14d20dc9378340990af
name: python-cruxctl-help
arch: noarch
version: 2.1.4
epoch: 0
release: 1
summary: Development documents and examples for cruxctl
url: https://pypi.org/project/cruxctl/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cruxctl-2.1.4-1.src.rpm
location_href: Packages/python-cruxctl-help-2.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Herein contains the source code for the cruxctl command line tool. Currently it only supports managing delivery
  deadlines, but new subcommands can be added to it as it grows.


  Crux user with private registry access:
  Zip private upstream dependency [crux-odin](https://github.com/cruxinformatics/crux-odin/releases) and [cruxctl](https://github.com/cruxinformatics/cruxctl/releases) dependency



  ```
  source scripts/setup.sh
  ```


  Given a zipped public distribution with python whl.

  Setup steps:
  - Unzip distribution
  - Ensure python 3.10 installed
  - Create virtual environment
  ```
  python -m venv venv
  source venv/bin/activate
  ```
  - Install private upstreams and cruxctl (Replace with the versions in the zipped distribution)
  ```
  venv/bin/pip install crux_odin-1.5.9-py3-none-any.whl cruxctl-2.1.4-py3-none-any.whl
  ```
  - Verify install
  ```
  cruxctl version
  ```


  Given a zipped public distribution with python whl.

  Setup steps:
  - Unzip distribution
  - Ensure python 3.10 installed
  ```
  winget install --id "Python.Python.3.10"
  ```
  - Install private upstreams and cruxctl (Replace with the versions in the zipped distribution)
  ```
  pip install crux_odin-1.5.9-py3-none-any.whl cruxctl-2.1.4-py3-none-any.whl
  ```
  - Verify install
  ```
  cruxctl version
  ```





  - Assumes install of:
      - Homebrew ([Install](https://brew.sh/))
      - pyenv ([Install](https://github.com/pyenv/pyenv?tab=readme-ov-file#installation))
      - (Temporary) gcloud auth config
      - postgres (brew install postgres)
  - Google Cloud default app credentials setup (instructions [here](https://cloud.google.com/docs/authentication/application-default-credentials#personal))


  Use compatible python version in downstream project:
  Switch to python 3.10
  ```commandline
  pyenv install 3.10.13
  pyenv local 3.10.13
  ```


  Install GCP keyring to consume Crux's Private packages:
  ```shell
  pip install keyring keyrings.google-artifactregistry-auth
  ```
  Select the latest version (Ex: 1.11.1), and install via pip:
  ```shell
  pip install -e git+ssh://git@github.com/cruxinformatics/cruxctl.git@1.11.1#egg=cruxctl --extra-index-url https://us-python.pkg.dev/crux-ci/crux-python/simple
  ```

  Or if provided a wheel distribution:
  ```shell
  pip install <Path to wheel file> --extra-index-url https://us-python.pkg.dev/crux-ci/crux-python/simple
  ```

  Reference: https://cloud.google.com/artifact-registry/docs/python/authentication#keyring



  Assumes [install of poetry](https://python-poetry.org/docs/#installation)



  ```commandline
  pre-commit install
  ```


  [Poe the Poet](https://poethepoet.natn.io/index.html) is a task runner for poetry allowing the execution of `[tool.poe.tasks]` by running `poetry {{task_name}}`

  Configure the task runner:
  ```
  poetry self add 'poethepoet[poetry_plugin]'
  ```



  * Add new dependencies to `pyproject.toml` under the [tool.poetry.dependencies] section


  ```commandline
  poetry config http-basic.google oauth2accesstoken $(gcloud auth print-access-token)
  poetry install
  ```


  ```commandline
  poetry shell
  ```


  It is important that commits to master use conventional commits. The convention is to use a seperate `release/*` branch for cutting releases — prodiving a separate approval process for versioning.

  This process does the following:
  1. Updates CHANGELOG.md
  2. Updates version files in source code (pyproject.toml & main.py)
  3. Tags the branch
  4. On Tag Push
      - Builds whl
      - Attaches whl and changelog to release

  Step 1: Identify next release
  ```
  poe version_check
  ...
  tag to create: X.Y.Z
  ...
  ```

  Step 2: Cut branch for release
  ```
  git checkout -b release/X.Y.Z
  ```

  Step 3: Version code base — updating changelog, version files, commiting and cutting tag
  ```
  poetry version
  ```
  Bump the version:
  ```
  poe version_bump
  ```

  Step 4: Publish PR
  Publish a PR before pushing the tag

  Step 5: Merge PR and Push tag
  ```
  git push origin X.Y.Z
  ```



  Get calculated delivery deadline:
  ```
  cruxctl ai-schedule get-delivery-deadline -d AQKwpurp8B-G848Qqs7JthWOog -bm 60
  ```



  Onboard data through Crux - run through profiler, upload vendor doc. These would trigger curation to run on event based. After profiling is done, you are now able to download odin yaml. You can check the odin file against curation output using cruxctl command.

  ```
  cruxctl dataset update -f [ODIN_YAML_FILE]
    --profile [ENVIRONMENT] --from-docs
  ```



  See available commands and help:
  ```shell
  cruxctl deadlines --help
  ```

  Get all deadlines:
  ```shell
  cruxctl deadlines get-all
  ```

  Get a specific deadline:
  ```shell
  cruxctl deadlines get dataset-id-abc
  ```

  Insert a deadline:
  ```shell
  cruxctl deadlines insert dataset-id-abc  0 23 '3W' '*' '*' '*'
  ```

  Delete deadlines matching dataset ID:
  ```shell
  cruxctl deadlines delete dataset-id-abc
  ```

  Delete all deadlines:
  ```shell
  cruxctl deadlines delete-all dataset-id-abc
  ```

  Import deadlines from CSV:
  ```shell
  cruxctl deadlines import /path/to/file/deadlines.csv
  ```

  Export deadlines to GCS bucket as CSV file:
  ```shell
  cruxctl deadlines export gs://my-bucket/deadlines.csv
  ```

  Get all notification snoozes:
  ```shell
  cruxctl deadlines get-all-notification-snooze
  ```

  Get a specific notification snooze:
  ```shell
  cruxctl deadlines get-notification-snooze dataset-id-abc
  ```

  Create a notification snooze:
  ```shell
  cruxctl deadlines create-notification-snooze dataset-id-abc 72 hours
  ```

  Delete a notification snooze:
  ```shell
  cruxctl deadlines delete-notification-snooze dataset-id-abc
  ```

  Delete expired notification snooze(s):
  ```shell
  cruxctl deadlines delete-expired-notification-snooze
  ```



  Validate YAML files which possibly point to a parent YAML file.
  There are two forms: one where you just give the YAML file names and the other
  where you give a start directory and the YAML file names. The second form exists
  because normally the data engineers stick the YAML files below a directory named
  after the company. They also often put a parent YAML file there too and a bunch
  of child YAML files refer to it. Therefore, we allow the user to pass this directory
  as the first argument and the child or parent files as the subsequent arguments.
  If you modify the child file and there is a parent, the combined parent/child
  YAML is validated. If you pass a parent file, ALL THE CHILDREN of that parent
  file are validated.

  You can also pass a parent file and a child file with the first form where you
  just give YAML paths. In this case, pass the parent and the child YAML file
  as the same argument separated by a comma. For example

  ```shell
  cruxctl dataset validate a.yaml b.yaml,c.yaml
  ```
  validates `a.yaml` by itself and the combined `b.yaml/c.yaml`. This supposes
  that `b.yaml` is the "parent" of `c.yaml`.

  The full usage syntax is:
  ```shell
  cruxctl dataset validate [--profile local|dev|staging|prod] [--quiet] file_or_dir yaml_file...
  ```
  Normally `cruxctl dataset validate` prints out the progress as it goes. `--quiet` turns this off.



  When we create a new YAML file, we create a new dataset and data product based
  on the file name of the YAML output file. These dataset and data product are
  written to the catalog through our Crux API. The usage of the command is as follows:
  ```shell
  cruxctl dataset init [--dataset-name dataset_name] [--data-product-name data_product_name] [--environment local|dev|staging|prod] yaml_output_file
  ```
  By default the `dataset_name` and `data_product_name` are the same as the output
  file name (minus the `.yaml` extension). The `environment` is `prod` by default.
  When the command runs, it prints out what it is doing like this:
  ```chatinput
  CRUX_API_TOKEN loaded.
  Using org ID "OrEC0NbO"
  Checking if data product "sample10" exists
  It doesn't. Creating it.
  Created data product "sample10" with ID "Prb8CPw0FAkt"
  Created dataset "sample10" with ID "Dspmm40k"
  Mapped dataset ID "Dspmm40k" to data product ID "Prb8CPw0FAkt"
  Created /tmp/sample10.yaml
  ```
  The org ID is looked up via the access token you stored with `cruxctl auth login`.

  If you don't like the `dataset_name` or `data_product_name` to match the file name,
  give the `--dataset-name` or `--data-product-name` options. For the data product ID, you
  can give an existing one too and it will use that data product ID rather than creating
  one. It _always_ creates a new dataset ID.

  To verify your dataset ID was created, go
  [here](https://api.cruxinformatics.com/v2/ops/swagger#/datasets/getV2OpsDatasets)
  and give the filter `name.EQ.yourname`. To see if the data product was created, go
  [here](https://api.cruxinformatics.com/v2/ops/swagger#/data-products-v4/getV4OpsDataproducts)
  and give the filter `name.EQ.yourname`.



  To deploy an Odin dataset YAML file to the control plane, give one or more arguments to
  the `dataset apply` command. This command can deploy multiple YAML files from one command
  line invocation if you give multiple YAML files to apply. Like the `dataset validate` command,
  you can give a directory as the first argument and YAML files to apply after that or you can
  just give the YAML files to apply (or combined YAML files separated by commas. See the
  `dataset validate` command for syntax).

  Usage:
  ```shell
  cruxctl dataset apply [--profile local|dev|staging|prod] [--quiet] file_or_dir yaml_file...
  ```
  Applying starts the processing runs for the YAML files. Normally it prints out as it
  is applying the YAML files. Use `--quiet` to turn this off.



  If you'd like to delete an existing dataset(s) in the control plane, give the following command:

  ```shell
  cruxctl dataset delete [--profile local|dev|staging|prod] [--quiet] dataset_id...
  ```



  To see the events from a deployed dataset, give the following command:
  ```shell
  cruxctl dataset events [--watch] [--environment local|dev|staging|prod] dataset_id
  ```
  This prints out the events for that dataset ID. If you give the `--watch` option,
  then every three second more output is checked for an output. The output looks like
  this:
  ```json
  {'specversion': '1.0', 'type': 'com.crux.cp.dataset.ingest.apply.v1', 'source': '/apilayer', 'subject': '', 'id': 'e0e1936d-e70b-4351-95e4-66fbefbbdf8b', 'time': '2024-09-10T22:39:57.077029Z', 'data': {'id': 0, 'datasetId': 'DssgxkJB', 'orgId': 'test', 'eventId': 'e0e1936d-e70b-4351-95e4-66fbefbbdf8b', 'eventSource': '/apilayer', 'eventType': 'com.crux.cp.dataset.ingest.apply.v1', 'message': 'validation pass', 'statusType': 'Apply'}}
  {'specversion': '1.0', 'type': 'com.crux.cp.dataset.ingest.apply.v1', 'source': '/apilayer', 'subject': '', 'id': 'e69b7204-2cff-4702-a65e-885bb7f77d7d', 'time': '2024-09-10T21:31:01.843591Z', 'data': {'id': 0, 'datasetId': 'DssgxkJB', 'orgId': 'test', 'eventId': 'e69b7204-2cff-4702-a65e-885bb7f77d7d', 'eventSource': '/apilayer', 'eventType': 'com.crux.cp.dataset.ingest.apply.v1', 'message': 'validation pass', 'statusType': 'Apply'}}
  {'specversion': '1.0', 'type': 'com.crux.cp.dataset.ingest.apply.v1', 'source': '/apilayer', 'subject': '', 'id': 'f41f54e3-b9d2-4638-a766-69662c75fbc4', 'time': '2024-09-10T21:59:00.67005Z', 'data': {'id': 0, 'datasetId': 'DssgxkJB', 'orgId': 'test', 'eventId': 'f41f54e3-b9d2-4638-a766-69662c75fbc4', 'eventSource': '/apilayer', 'eventType': 'com.crux.cp.dataset.ingest.apply.v1', 'message': 'validation pass', 'statusType': 'Apply'}}
  ```


  If you'd like to retrieve logs of an existing dataset in the control plane, run the following command:

  ```shell
  cruxctl dataset logs dataset_id [--profile local|dev|staging|prod] -s dispatch
  ```


pkgId: 325d971efd97b734d372a48a22d240a907b9267463c0ae2d5f96b6068d0062b2
name: python-crxsnake-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for crxsnake
url: https://discord.gg/EEp67FWQDP
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crxsnake-1.4.0-1.src.rpm
location_href: Packages/python-crxsnake-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  **CRX-Snake** is a set of utilities designed to simplify the development of projects, including the creation of Discord bots. This library contains a number of features and tools to help you quickly develop and customize bots and other components of your projects.



  CRX-Snake was developed specifically for internal use and is now available to other developers. It provides user-friendly features and solutions for common tasks in bot development and project management. It includes:

  - **Features for working with Discord**: Tools for creating and managing Discord bots using the Disnake library.
  - **File Utilities**: Functions for reading and writing JSON files, making it easy to work with configurations and data.
  - **Database Tools**: Interfaces with Tortoise ORM for data management and query execution.
  - **Logging and debugging**: Includes functions for error logging and debugging.


pkgId: b47d15cffe3971dab2309a4e7f319c085a2e0dd8e1cd46b9e288400f6c7750b9
name: python-crypto-wallet-finder-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for crypto-wallet-finder
url: https://github.com/yourusername/wallet_finder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crypto-wallet-finder-1.0.2-1.src.rpm
location_href: Packages/python-crypto-wallet-finder-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package for finding cryptocurrency wallet seeds by generating and testing permutations of seed phrases. This tool uses parallel processing to efficiently search through possible combinations while providing a user-friendly GUI interface for monitoring progress.



  - **Parallel Processing**: Utilizes all available CPU cores for efficient processing
  - **User-Friendly GUI**: Monitor progress and results in real-time
  - **Progress Management**: Automatic saving and resumption of search progress
  - **Export Functionality**: Export found wallets to CSV format
  - **Device Validation**: Secure API-based device validation system



  You can install the package directly from PyPI:

  ```bash
  pip install crypto-wallet-finder
  ```

  Or install from source:

  ```bash
  git clone https://github.com/RKInnovate/waller-finder-pkg.git
  cd waller-finder-pkg
  pip install -e .
  ```



  - Python 3.6 or higher
  - Required packages (automatically installed):
    - requests>=2.25.0
    - more-itertools>=8.0.0





  Run the GUI application:

  ```bash
  wallet-finder
  ```

  Or use it in your Python code:

  ```python
  from wallet_finder import WalletFinderGUI
  import tkinter as tk

  def main():
      root = tk.Tk()
      app = WalletFinderGUI(root)
      root.mainloop()

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



  Use the core functionality in your own code:

  ```python
  from wallet_finder import WalletFinder


  wordlist = ["word1", "word2", ...]
  target_addresses = {"address1", "address2"}


  def status_callback(message):
      print(f"Status: {message}")

  def result_callback(seed, address):
      print(f"Found: {address} with seed: {seed}")


  WalletFinder.start(
      wordlist=wordlist,
      target_address=target_addresses,
      update_status_func=status_callback,
      update_list_func=result_callback
  )
  ```



  The package creates a configuration directory at `~/.wallet_finder` with:

  - `config.json`: Stores progress and settings
  - `found_wallets.csv`: Stores found wallet addresses
  - `wallet_finder.log`: Application logs



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  This tool is for educational purposes only. Always ensure you have the right to search for specific wallet addresses before using this tool.


pkgId: cfca0891565cfee56610b9af0f7503c8142a7e303213aaa35dad6414dc36079e
name: python-crypto-ws-api-help
arch: noarch
version: 2.0.15
epoch: 0
release: 1
summary: Development documents and examples for crypto-ws-api
url: https://pypi.org/project/crypto-ws-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crypto-ws-api-2.0.15-1.src.rpm
location_href: Packages/python-crypto-ws-api-help-2.0.15-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center"><img align="center" src="https://user-images.githubusercontent.com/77513676/250364389-cbedc171-a930-4467-a0cd-21627a6a41ed.svg" width="75">Crypto WS API connector for ASYNC requests</h1>

  <h2 align="center">Full coverage of all methods provided by the interface</h2>

  <h3 align="center">Provides of connection management, keepalive and rate limits control</h3>

  ***
  <a href="https://pypi.org/project/crypto-ws-api/"><img src="https://img.shields.io/pypi/v/crypto-ws-api" alt="PyPI version"></a>
  <a href="https://codeclimate.com/github/DogsTailFarmer/crypto-ws-api/maintainability"><img src="https://api.codeclimate.com/v1/badges/2d2a654ba393eb88d911/maintainability" /></a>
  <a href="https://app.deepsource.com/gh/DogsTailFarmer/crypto-ws-api/?ref=repository-badge}" target="_blank"><img alt="DeepSource" title="DeepSource" src="https://app.deepsource.com/gh/DogsTailFarmer/crypto-ws-api.svg/?label=resolved+issues&token=TXghPzbi0YWhkCLU8Q1tmDyQ"/></a>
  <a href="https://app.deepsource.com/gh/DogsTailFarmer/crypto-ws-api/?ref=repository-badge}" target="_blank"><img alt="DeepSource" title="DeepSource" src="https://app.deepsource.com/gh/DogsTailFarmer/crypto-ws-api.svg/?label=active+issues&token=TXghPzbi0YWhkCLU8Q1tmDyQ"/></a>
  <a href="https://sonarcloud.io/summary/new_code?id=DogsTailFarmer_crypto-ws-api" target="_blank"><img alt="sonarcloud" title="sonarcloud" src="https://sonarcloud.io/api/project_badges/measure?project=DogsTailFarmer_crypto-ws-api&metric=alert_status"/></a>
  <a href="https://pepy.tech/project/crypto-ws-api" target="_blank"><img alt="Downloads" title="Downloads" src="https://static.pepy.tech/badge/crypto-ws-api"/></a>
  ***
  For :heavy_check_mark:Binance, :heavy_check_mark:OKX, :heavy_check_mark:Bitfinex, :heavy_check_mark:HTX
  ***


  Lightweight and efficient solution to utilize of all available methods** provided through the:
  * [Binance Websocket API v3](https://binance-docs.github.io/apidocs/websocket_api/en)
  * [OKX Websocket API v5](https://www.okx.com/docs-v5/en/#overview-websocket)
  * [Bitfinex Websocket Inputs](https://docs.bitfinex.com/reference/ws-auth-input)
  * [HTX WS Trade](https://www.htx.com/en-us/opend/newApiPages/?id=8cb89359-77b5-11ed-9966-1928f079ab6)

  ** Not for channel by one-way subscription, for **_request <-> response_** mode only


  - Credentials
  - Connection
  - Keepalive
  - Error handling
  - Limits control
  - Methods construction
    + Creating request on-the-fly from method name and params: {}
    + Generating signature if necessary
    + Response handling
  - logging


  - Start session instance
  - Send async request
  - Get response or raised exception
  - Reuse instance for different type requests
  - Stop session instance




  ```console
  pip install crypto_ws_api
  ```
  For upgrade to latest versions use:
  ```console
  pip install -U crypto_ws_api
  ```

  After first install create environment by run
  ```console
  crypto_ws_api_init
  ```
  in terminal window.

  The config directory will be created. You get path to config:

  >ubuntu@ubuntu:~$ crypto_ws_api_init
  >
  >Can't find config file! Creating it...
  >
  >Before first run set account(s) API key into /home/ubuntu/.config/crypto_ws_api/ws_api.toml


  * For test purpose log in at [Binance Spot Test Network](https://testnet.binance.vision/)

  For OKX and Bitfinex, unlike Binance, a limited number of methods are implemented at the WS API level,
  such as creating, modifying, and deleting orders.
  There are no public get-time (), ping-pong, etc., so this demo script is limited to calling Binance
  to demonstrate capabilities.

  * Create API Key
  * After install and create environment specify api_key and api_secret to the config file


  * Run in terminal window
  ```
  crypto_ws_api_demo
  ```



  _*`crypto_ws_api/demo.py` - complete and fully functional example*_



  ```bazaar
  from crypto_ws_api.ws_session import UserWSSession



  exchange, _test_net, api_key, api_secret, passphrase, ws_api_endpoint = get_credentials(account_name)

  session = aiohttp.ClientSession()

  trade_id = shortuuid.uuid()

  user_session = UserWSSession(
      session,
      exchange,
      ws_api_endpoint,
      api_key,
      api_secret,
      passphrase
  )
  ```


  ```bazaar
  async def account_information(user_session: UserWSSession, _trade_id):
      
      try:
          res = await user_session.handle_request(
              _trade_id,
              "account.status",
              _api_key=True,
              _signed=True
          )
          if res is None:
              logger.warning("Here handling state Out-of-Service")
      except asyncio.CancelledError:
          pass  # Task cancellation should not be logged as an error
      except Exception as _ex:
          logger.error(f"Handling exception: {_ex}")
      else:
          logger.info(f"Account information (USER_DATA) response: {res}")
  ```


  ```bazaar
  await account_information(user_session, trade_id)
  ```


  ```bazaar
  await user_session.stop()
  await session.close()
  ```


  ```bazaar
  if self.exchange == 'binance':
      params = {
          "symbol": "BTCUSDT",
          "side": "SELL",
          "type": "LIMIT",
          "timeInForce": "GTC",
          "price": "23416.10000000",
          "quantity": "0.00847000",
      }
      binance_res = await user_session.handle_request(trade_id, "order.place", params, _api_key=True, _signed=True)

  elif self.exchange == 'bitfinex':
      params = {
          "type": "EXCHANGE LIMIT",
          "symbol": "tBTCUSDT",
          "price": "23416.10000000",
          "amount": ('' if side == 'BUY' else '-') + "0.00847000",
      }
      bitfnex_res = await user_session.handle_request(trade_id, "on", params)

  elif self.exchange == 'okx':
      params = {
          "instId": "BTC-USDT",
          "tdMode": "cash",
          "clOrdId": "client_order_id",
          "side": "buy",
          "ordType": "limit",
          "sz": "0.00847000",
          "px": "23416.10000000",
      }
      okx_res = await user_session.handle_request(trade_id, "order", params)
  ```


  For configure logging in multi-module project use next snippet for yours `main()`:
  ```bazaar
  import logging.handlers

  logger = logging.getLogger(__name__)
  formatter = logging.Formatter(fmt="[s: s] s")

  sh = logging.StreamHandler()
  sh.setFormatter(formatter)
  sh.setLevel(logging.DEBUG)

  root_logger = logging.getLogger()
  root_logger.setLevel(logging.DEBUG)
  root_logger.addHandler(sh)
  ```


  Upon reaching the limit threshold of each type, the session switches to the Out-of-Service state.
  If you send a request in this state, the answer will be `None`

  *In any case, you are protected from exceeding limits and blocking for this reason*


  *USDT* (TRC20) TU3kagV9kxbjuUmEi6bUym5MTXjeM7Tm8K


pkgId: eb913dfea6f2a339454534bdd17a8de034478ed3a5be6e62c3d06bf05c38159a
name: python-crystmatch-help
arch: noarch
version: 1.1.2
epoch: 0
release: 1
summary: Development documents and examples for crystmatch
url: https://github.com/Fangcheng-Wang/crystmatch
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-crystmatch-1.1.2-1.src.rpm
location_href: Packages/python-crystmatch-help-1.1.2-1.noarch.rpm
checksum_type: sha256
description:
  If you use this code in your research, please cite the following paper:

  \[1\] [FC Wang, QJ Ye, YC Zhu, and XZ Li, *Physical Review Letters* **132**, 086101 (2024)](https://arxiv.org/abs/2305.05278)

  You are also welcome to contact me at `wfc@pku.edu.cn` for any questions or comments.



  A solid-solid phase transition establishes an *atom-to-atom correspondence* between the initial and final crystal structures $\mathcal A$ and $\mathcal B$. Such correspondence is called a *crystal-structure match* (CSM) [[1]](https://arxiv.org/abs/2305.05278). A CSM can be described by a pair of [POSCAR](https://www.vasp.at/wiki/index.php/POSCAR) files, which specifies how the lattice deforms from $\mathcal A$ to $\mathcal B$ and the correspondence between atoms in a supercell of $\mathcal A$ and those in $\mathcal B$.

  The main goals of `crystmatch` are as follows:

  - **Enumeration**:
      - Provide a complete list of *representative* [[1]](https://arxiv.org/abs/2305.05278) CSMs between two given crystal structures, with user-specified upper bounds on the *multiplicity* [[1]](https://arxiv.org/abs/2305.05278) and root-mean-square strain (RMSS).
      - (In progress) Provide a complete list of CSMs with user-specified upper bounds on the multiplicity, RMSS, and root-mean-square displacement (RMSD).

  - **Analysis**:
      - Read a CSM from a pair of POSCAR files, and save CSMs in the same format.
      - Score CSMs by RMSS and RMSD.
      - Benchmark a CSM by its deviation angle from an orientation relationship (OR).

  Congruent CSMs (those differ only by a space-group transformation) are identified and excluded from the enumeration using the `spglib` library by [Atsushi Togo *et al.*](https://www.tandfonline.com/doi/full/10.1080/27660400.2024.2384822)



  Make sure you have **Python 3.9 or later** installed. You can check it by running:

  ```
  python3 --version
  ```

  Clone [**this repository**](https://github.com/fangcheng-wang/crystmatch) by:

  ```
  git clone https://github.com/fangcheng-wang/crystmatch.git
  ```

  Navigate to the directory where `setup.py` is located, run:

  ```
  pip3 install .
  ```

  Check whether `crystmatch` is successfully installed:

  ```
  crystmatch --version
  ```



  To run `crystmatch`, one of the following modes must be selected:

  1. **Enumeration mode**: Generate a list of CSMs, save them to a `CSM_LIST.npz` file, and perform preliminary analysis. The initial and final crystal structures must be specified in the form of POSCAR files.
  2. **Read mode**: Read CSMs from a `CSM_LIST.npz` file. You can export specific CSMs to POSCARs, perform OR analysis, generate CSV tables of CSM properties, and visualize the RMSD-RMSS-multiplicity distribution in a 2D scatter plot.
  3. **Single-CSM mode**: Directly determine a single CSM by two POSCAR files (must have the same number and species of atoms) and perform detailed analysis.

  **We strongly recommend starting with the [examples](#examples) provided below.** If you are still confused, run `crystmatch` directly in the command line without any arguments for an interactive calculation. To [see all available options](https://fangcheng-wang.github.io/crystmatch/cli/), run:

  ```
  crystmatch --help
  ```





  To generate a list of representative [[1]](https://arxiv.org/abs/2305.05278) CSMs between two crystal structures stored in `./fcc` and `./bcc`, with multiplicity upper bound `MAX_MU = 4` and RMSS upper bound `MAX_RMSS = 0.4`, run:

  ```
  crystmatch --initial fcc --final bcc --enumeration 4 0.4
  ```

  The following files will be created in the current directory:

  ```
  ./
  ├── CSM_LIST-m4s0.40.npz       # stores the enumerated CSMs and metadata.
  ├── PLOT-m4s0.40.pdf           # shows the RMSD-RMSS distribution of the CSMs.
  └── TABLE-m4s0.40.csv          # shows the multiplicity, RMSS, and RMSD of each CSM.
  ```

  > **We recommend you to try `MAX_MU <= 4` and `MAX_RMSS = 0.4` first, and then gradually adjust these upper bounds (usually by increasing `MAX_MU` and decreasing `MAX_RMSS`) to obtain desired results. Otherwise, the enumeration may take a very long time, or find no CSMs at all.**



  After enumeration, you can see the properties of CSMs in the CSV file, which also contains their indices in the NPZ file. If you want to export the CSMs with indices `7` and `10` in `CSM_LIST-foo.npz`, run:

  ```
  crystmatch --read CSM_LIST-foo.npz --export 7 10
  ```

  Two folders will be created in the current directory, each containing a pair of POSCAR files representing the CSM. The current directory will look like this:

  ```
  ./
  ├── CSM_7/
  │   ├── POSCAR_I
  │   └── POSCAR_F
  └── CSM_10/
      ├── POSCAR_I
      └── POSCAR_F
  ```



  To benchmark CSMs in `CSM_LIST-foo.npz` by their deviation angles from the OR $(111)_A\parallel(110)_B$, $[1\overline{1}0]_A\parallel[001]_B$, run:

  ```
  crystmatch --read CSM_LIST-foo.npz --orientation 1 1 1 1 1 0 1 -1 0 0 0 1
  ```

  Note that the arguments after `--orientation` must be **Cartesian coordinates**.

  The ORs are determined via the rotation-free manner by default, and you can also use `--uspfix` to determine ORs via the USF-fixed manner; see Ref. [[1]](https://arxiv.org/abs/2305.05278) for their definitions.



  To analyze a single CSM defined by two POSCAR files, run:

  ```
  crystmatch --initial POSCAR1 --final POSCAR2 --single
  ```

  `crystmatch` will also save the rigid-transformation optimized (with rotation-free orientation and RMSD-minimized overall position) CSM in the current directory like this:

  ```
  ./
  └── CSM_single/
      ├── POSCAR1
      └── POSCAR2-optimized
  ```



  You can also use `crystmatch` as a Python module in your own scripts. See the [documentation](https://fangcheng-wang.github.io/crystmatch/) for details.


pkgId: c574a195c7c9b388d6b0ee46b247f6e0423c7f2b7975a2fdb1d2ff1d0eb382b4
name: python-cs-cmdutils-help
arch: noarch
version: 20241218
epoch: 0
release: 1
summary: Development documents and examples for cs-cmdutils
url: https://pypi.org/project/cs-cmdutils/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cs-cmdutils-20241218-1.src.rpm
location_href: Packages/python-cs-cmdutils-help-20241218-1.noarch.rpm
checksum_type: sha256
description:
  Convenience functions for working with the cmd stdlib module,
  the BaseCommand class for constructing command line programmes,
  and other command line related stuff.

  *Latest release 20241218*:
  BaseCommand: add cmd_repl to the default subcomands.



  A base class for handling nestable command lines.

  This class provides the basic parse and dispatch mechanisms
  for command lines.
  To implement a command line
  one instantiates a subclass of `BaseCommand`:

      class MyCommand(BaseCommand):
          GETOPT_SPEC = 'ab:c'
          USAGE_FORMAT = r"""and provides either a `main` method if the command has no subcommands
  or a suite of `cmd_`*subcommand* methods, one per subcommand.

  Running a command is done by:

      MyCommand(argv).run()

  Modules which implement a command line mode generally look like this:

      ... imports etc ...
      def main(argv=None, **run_kw):
          """ The command line mode.
          """
          return MyCommand(argv).run(**run_kw)
      ... other code ...
      class MyCommand(BaseCommand):
      ... other code ...
      if __name__ == '__main__':
          sys.exit(main(sys.argv))

  Instances have a `self.options` attribute on which optional
  modes are set,
  avoiding conflict with the attributes of `self`.

  Subclasses with no subcommands
  generally just implement a `main(argv)` method.

  Subclasses with subcommands
  should implement a `cmd_`*subcommand*`(argv)` instance method
  for each subcommand.
  If a subcommand is itself implemented using `BaseCommand`
  then it can be a simple attribute:

      cmd_subthing = SubThingCommand

  Returning to methods, if there is a paragraph in the method docstring
  commencing with `Usage:` then that paragraph is incorporated
  into the main usage message automatically.
  Example:

      def cmd_ls(self, argv):
          """ Usage: {cmd} [paths...]
                Emit a listing for the named paths.

              Further docstring non-usage information here.
          """
          ... do the "ls" subcommand ...

  The subclass is customised by overriding the following methods:
  * `apply_opt(opt,val)`:
    apply an individual getopt global command line option
    to `self.options`.
  * `apply_opts(opts)`:
    apply the `opts` to `self.options`.
    `opts` is an `(option,value)` sequence
    as returned by `getopot.getopt`.
    The default implementation iterates over these and calls `apply_opt`.
  * `run_context()`:
    a context manager to provide setup or teardown actions
    to occur before and after the command implementation respectively,
    such as to open and close a database.
  * `cmd_`*subcmd*`(argv)`:
    if the command line options are followed by an argument
    whose value is *subcmd*,
    then the method `cmd_`*subcmd*`(subcmd_argv)`
    will be called where `subcmd_argv` contains the command line arguments
    following *subcmd*.
  * `main(argv)`:
    if there are no `cmd_`*subcmd*` methods then method `main(argv)`
    will be called where `argv` contains the command line arguments.

  Editorial: why not arparse?
  Primarily because when incorrectly invoked
  an argparse command line prints the help/usage messgae
  and aborts the whole programme with `SystemExit`.
  But also, I find the whole argparse `add_argument` thing cumbersome.

  Usage summary:

      Usage: base [common-options...] [-a] [-b bvalue] [-c] [--] arguments...
          -a    Do it all.
          -b    But using bvalue.
          -c    The 'c' option!
        """
        ...
        Subcommands:
          help [common-options...] [-l] [-s] [subcommand-names...]
            Print help for subcommands.
            This outputs the full help for the named subcommands,
            or the short help for all subcommands if no names are specified.
            Options:
              -l  Long listing.
              -r  Recurse into subcommands.
              -s  Short listing.
          info [common-options...] [field-names...]
            Recite general information.
            Explicit field names may be provided to override the default listing.
          repl [common-options...]
            Run a REPL (Read Evaluate Print Loop), an interactive Python prompt.
            Options:
              --banner banner  Banner.
          shell [common-options...]
            Run a command prompt via cmd.Cmd using this command's subcommands.

  *`BaseCommand.__init__(self, argv=None, *, cmd=None, options=None, **kw_options)`*:
  Initialise the command line.
  Raises `GetoptError` for unrecognised options.

  Parameters:
  * `argv`:
    optional command line arguments
    including the main command name if `cmd` is not specified.
    The default is `sys.argv`.
    The contents of `argv` are copied,
    permitting desctructive parsing of `argv`.
  * `cmd`:
    optional keyword specifying the command name for context;
    if this is not specified it is taken from `argv.pop(0)`.
  * `options`:
    an optional keyword providing object for command state and context.
    If not specified a new `self.Options` instance
    is allocated for use as `options`.
    The default `Options` class is `BaseCommandOptions`,
    a dataclass with some prefilled attributes and properties
    to aid use later.
  Other keyword arguments are applied to `self.options`
  as attributes.

  The `cmd` and `argv` parameters have some fiddly semantics for convenience.
  There are 3 basic ways to initialise:
  * `BaseCommand()`: `argv` comes from `sys.argv`
    and the value for `cmd` is derived from `argv[0]`
  * `BaseCommand(argv)`: `argv` is the complete command line
    including the command name and the value for `cmd` is
    derived from `argv[0]`
  * `BaseCommand(argv, cmd=foo)`: `argv` is the command
    arguments _after_ the command name and `cmd` is set to
    `foo`

  The command line arguments are parsed according to
  the optional `GETOPT_SPEC` class attribute (default `''`).
  If `getopt_spec` is not empty
  then `apply_opts(opts)` is called
  to apply the supplied options to the state
  where `opts` is the return from `getopt.getopt(argv,getopt_spec)`.

  After the option parse,
  if the first command line argument *foo*
  has a corresponding method `cmd_`*foo*
  then that argument is removed from the start of `argv`
  and `self.cmd_`*foo*`(argv,options,cmd=`*foo*`)` is called
  and its value returned.
  Otherwise `self.main(argv,options)` is called
  and its value returned.

  If the command implementation requires some setup or teardown
  then this may be provided by the `run_context`
  context manager method,
  called with `cmd=`*subcmd* for subcommands
  and with `cmd=None` for `main`.

  *`BaseCommand.Options`*

  *`BaseCommand.SubCommandClass`*

  *`BaseCommand.apply_opt(self, opt, val)`*:
  Handle an individual global command line option.

  This default implementation raises a `NotImplementedError`.
  It only fires if `getopt` actually gathered arguments
  and would imply that a `GETOPT_SPEC` was supplied
  without an `apply_opt` or `apply_opts` method to implement the options.

  *`BaseCommand.apply_opts(self, opts)`*:
  Apply command line options.

  Subclasses can override this
  but it is usually easier to override `apply_opt(opt,val)`.

  *`BaseCommand.apply_preargv(self, argv)`*:
  Do any preparsing of `argv` before the subcommand/main-args.
  Return the remaining arguments.

  This default implementation applies the default options
  supported by `self.options` (an instance of `self.Options`
  class).

  *`BaseCommand.cmd_help(self, argv)`*:
  Usage: {cmd} [-l] [-s] [subcommand-names...]
  Print help for subcommands.
  This outputs the full help for the named subcommands,
  or the short help for all subcommands if no names are specified.
  Options:
    -l  Long listing.
    -r  Recurse into subcommands.
    -s  Short listing.

  *`BaseCommand.cmd_info(self, argv, *, field_names=None, skip_names=None)`*:
  Usage: {cmd} [field-names...]
    Recite general information.
    Explicit field names may be provided to override the default listing.

  This default method recites the values from `self.options`,
  excluding the basic fields from `BaseCommandOptions` other
  than `cmd` and `dry_run`.

  This base method provides two optional parameters to allow
  subclasses to tune its behaviour:
  - `field_namees`: an explicit list of options attributes to print
  - `skip_names`: a list of option attributes to not print
    if `field_names` is not specified; the default is the
    field names of `BaseCommandOptions` excepting `cmd` and
    `dry_run`

  *`BaseCommand.cmd_repl(self, argv)`*:
  Usage: {cmd}
  Run a REPL (Read Evaluate Print Loop), an interactive Python prompt.
  Options:
    --banner banner  Banner.

  *`BaseCommand.cmd_shell(*a, upd: Optional[cs.upd.Upd] = <function uses_upd.<locals>.<lambda> at 0x10d4e1da0>, **kw)`*:
  Usage: {cmd}
  Run a command prompt via cmd.Cmd using this command's subcommands.

  *`BaseCommand.cmdloop(self, intro=None)`*:
  Use `cmd.Cmd` to run a command loop which calls the `cmd_`* methods.

  *`BaseCommand.extract_usage(cmd=None)`*:
  Extract the `Usage:` paragraph from `cls__doc__` if present.
  Return a 2-tuple of `(doc_without_usage,usage_text)`
  being the remaining docstring and a full usage message.

  *Note*: this actually sets `cls.USAGE_FORMAT` if that does
  not already exist.

  *`BaseCommand.getopt_error_handler(cmd, options, e, usage, subcmd=None)`*:
  The `getopt_error_handler` method
  is used to control the handling of `GetoptError`s raised
  during the command line parse
  or during the `main` or `cmd_`*subcmd*` calls.

  This default handler issues a warning containing the exception text,
  prints the usage message to standard error,
  and returns `True` to indicate that the error has been handled.

  The handler is called with these parameters:
  * `cmd`: the command name
  * `options`: the `options` object
  * `e`: the `GetoptError` exception
  * `usage`: the command usage or `None` if this was not provided
  * `subcmd`: optional subcommand name;
    if not `None`, is the name of the subcommand which caused the error

  It returns a true value if the exception is considered handled,
  in which case the main `run` method returns 2.
  It returns a false value if the exception is considered unhandled,
  in which case the main `run` method reraises the `GetoptError`.

  To let the exceptions out unhandled
  this can be overridden with a method which just returns `False`.

  Otherwise,
  the handler may perform any suitable action
  and return `True` to contain the exception
  or `False` to cause the exception to be reraised.

  *`BaseCommand.handle_signal(self, sig, frame, *, runstate: Optional[cs.resources.RunState] = <function uses_runstate.<locals>.<lambda> at 0x10d4e1760>)`*:
  The default signal handler, which cancels the default `RunState`.

  *`BaseCommand.has_subcommands()`*:
  Test whether the class defines additional subcommands.

  *`BaseCommand.method_cmdname(method_name: str)`*:
  The `cmd` value from a method name.

  *`BaseCommand.poparg(argv: List[str], *specs, unpop_on_error: bool = False, opt_spec_class=None)`*:
  Pop the leading argument off `argv` and parse it.
  Return the parsed argument.
  Raises `getopt.GetoptError` on a missing or invalid argument.

  This is expected to be used inside a `main` or `cmd_*`
  command handler method or inside `apply_preargv`.

  You can just use:

      value = argv.pop(0)

  but this method provides conversion and valuation
  and a richer failure mode.

  Parameters:
  * `argv`: the argument list, which is modified in place with `argv.pop(0)`
  * the argument list `argv` may be followed by some help text
    and/or an argument parser function.
  * `validate`: an optional function to validate the parsed value;
    this should return a true value if valid,
    or return a false value or raise a `ValueError` if invalid
  * `unvalidated_message`: an optional message after `validate`
    for values failing the validation
  * `unpop_on_error`: optional keyword parameter, default `False`;
    if true then push the argument back onto the front of `argv`
    if it fails to parse; `GetoptError` is still raised

  Typical use inside a `main` or `cmd_*` method might look like:

      self.options.word = self.poparg(argv, int, "a count value")
      self.options.word = self.poparg(
          argv, int, "a count value",
         lambda count: count > 0, "count should be positive")

  Because it raises `GetoptError` on a bad argument
  the normal usage message failure mode follows automatically.

  Demonstration:

      >>> argv = ['word', '3', 'nine', '4']
      >>> BaseCommand.poparg(argv, "word to process")
      'word'
      >>> BaseCommand.poparg(argv, int, "count value")
      3
      >>> BaseCommand.poparg(argv, float, "length")
      Traceback (most recent call last):
        ...
      getopt.GetoptError: length 'nine': float('nine'): could not convert string to float: 'nine'
      >>> BaseCommand.poparg(argv, float, "width", lambda width: width > 5)
      Traceback (most recent call last):
        ...
      getopt.GetoptError: width '4': invalid value
      >>> BaseCommand.poparg(argv, float, "length")
      Traceback (most recent call last):
        ...
      getopt.GetoptError: length: missing argument
      >>> argv = ['-5', 'zz']
      >>> BaseCommand.poparg(argv, float, "size", lambda size: size > 0, "size should be >0")
      Traceback (most recent call last):
        ...
      getopt.GetoptError: size '-5': size should be >0
      >>> argv  # -5 was still consumed
      ['zz']
      >>> BaseCommand.poparg(argv, float, "size2", unpop_on_error=True)
      Traceback (most recent call last):
        ...
      getopt.GetoptError: size2 'zz': float('zz'): could not convert string to float: 'zz'
      >>> argv  # zz was pushed back
      ['zz']

  *`BaseCommand.popopts(self, argv, options, **opt_specs)`*:
  OBSOLETE popopts

  A convenience shim which returns `self.options.popopts(argv,**opt_specs)`.

  *`BaseCommand.repl(self, *argv, banner=None, local=None)`*:
  Run an interactive Python prompt with some predefined local names.
  Aka REPL (Read Evaluate Print Loop).

  Parameters:
  * `argv`: any notional command line arguments
  * `banner`: optional banner string
  * `local`: optional local names mapping

  The default `local` mapping is a `dict` containing:
  * `argv`: from `argv`
  * `options`: from `self.options`
  * `self`: from `self`
  * the attributes of `options`
  * the attributes of `self`

  *`BaseCommand.run(self, **kw_options)`*:
  Run a command.
  Returns the exit status of the command.
  May raise `GetoptError` from subcommands.

  Any keyword arguments are used to override `self.options` attributes
  for the duration of the run,
  for example to presupply a shared `Upd` from an outer context.

  If the first command line argument *foo*
  has a corresponding method `cmd_`*foo*
  then that argument is removed from the start of `argv`
  and `self.cmd_`*foo*`(cmd=`*foo*`)` is called
  and its value returned.
  Otherwise `self.main(argv)` is called
  and its value returned.

  If the command implementation requires some setup or teardown
  then this may be provided by the `run_context()`
  context manager method.

  *`BaseCommand.run_context(*a, upd: Optional[cs.upd.Upd] = <function uses_upd.<locals>.<lambda> at 0x10d4e14e0>, **kw)`*:
  The context manager which surrounds `main` or `cmd_`*subcmd*.
  Normally this will have a bare `yield`, but you can yield
  a not `None` value to exit before the command, for example
  if the run setup fails.

  This default does several things, and subclasses should
  override it like this:

      @contextmanager
      def run_context(self):
        with super().run_context():
          try:
            ... subclass context setup ...
              yield
          finally:
            ... any unconditional cleanup ...

  This base implementation does the following things:
  - provides a `self.options` which is a copy of the original
    `self.options` so that it may freely be modified during the
    command
  - provides a prevailing `RunState` as `self.options.runstate`
    if one is not already present
  - provides a `cs.upd.Upd` context for status lines
  - catches `self.options.runstate_signals` and handles them
    with `self.handle_signal`

  *`BaseCommand.subcommand`*

  *`BaseCommand.subcommand_usage_text(self, subcmd, usage_format_mapping=None, short=False)`*:
  Return the usage text for a subcommand.

  *`BaseCommand.subcommands`*

  *`BaseCommand.usage_text(self, **subcommand_kw)`*:
  Compute the "Usage:" message for this class.
  Parameters are as for `SubCommand.usage_text`.



  A `cmd.Cmd` subclass used to provide interactive use of a
  command's subcommands.

  The `BaseCommand.cmdloop()` class method instantiates an
  instance of this and calls its `.cmdloop()` method
  i.e. `cmd.Cmd.cmdloop`.



  A base class for the `BaseCommand` `options` object.

  This is the default class for the `self.options` object
  available during `BaseCommand.run()`,
  and available as the `BaseCommand.Options` attribute.

  Any keyword arguments are applied as field updates to the instance.

  It comes prefilled with:
  * `.dry_run=False`
  * `.force=False`
  * `.quiet=False`
  * `.ssh_exe='ssh'`
  * `.verbose=False`
  and a `.doit` property which is the inverse of `.dry_run`.

  It is recommended that if `BaseCommand` subclasses use a
  different type for their `Options` that it should be a
  subclass of `BaseCommandOptions`.
  Since `BaseCommandOptions` is a data class, this typically looks like:

      @dataclass
      class Options(BaseCommand.Options):
          ... optional extra fields etc ...

  *`BaseCommandOptions.__call__(self, **updates)`*:
  Calling the options object returns a context manager whose
  value is a shallow copy of the options with any `suboptions` applied.

  Example showing the semantics:

      >>> from cs.cmdutils import BaseCommandOptions
      >>> @dataclass
      ... class DemoOptions(BaseCommandOptions):
      ...   x: int = 0
      ...
      >>> options = DemoOptions(x=1)
      >>> assert options.x == 1
      >>> assert not options.verbose
      >>> with options(verbose=True) as subopts:
      ...     assert options is not subopts
      ...     assert options.x == 1
      ...     assert not options.verbose
      ...     assert subopts.x == 1
      ...     assert subopts.verbose
      ...
      >>> assert options.x == 1
      >>> assert not options.verbose

  *`BaseCommandOptions.as_dict(self)`*:
  Return the options as a `dict`.
  This contains all the public attributes of `self`.

  *`BaseCommandOptions.copy(self, **updates)`*:
  Return a new instance of `BaseCommandOptions` (well, `type(self)`)
  which is a shallow copy of the public attributes from `self.__dict__`.

  Any keyword arguments are applied as attribute updates to the copy.

  *`BaseCommandOptions.doit`*:
  I usually use a `doit` flag, the inverse of `dry_run`.

  *`BaseCommandOptions.fields_as_dict(self)`*:
  Return the options' fields as a `dict`.
  This contains all the field values of `self`.

  *`BaseCommandOptions.getopt_spec_map(opt_specs_kw: Mapping, common_opt_specs=None)`*:
  Return a 3-tuple of (shortopts,longopts,getopt_spec_map)` being:
  - `shortopts`: the `getopt()` short options specification string
  - `longopts`: the `getopts()` long option specification list
  - `getopt_spec_map`: a mapping of `opt`->`OptionSpec`
    where `opt` is as from `opt,val` from `getopt()`
    and `opt_spec` is the associated `OptionSpec` instance

  *`BaseCommandOptions.opt_spec_class`*

  *`BaseCommandOptions.perthread_state`*

  *`BaseCommandOptions.popopts(self, argv, **opt_specs_kw)`*:
  Parse option switches from `argv`, a list of command line strings
  with leading option switches and apply them to `self`.
  Modify `argv` in place.

  Example use in a `BaseCommand` `cmd_foo` method:

      def cmd_foo(self, argv):
          options = self.options
          options.popopts(
              c_='config',
              l='long',
              x='trace',
          )
          if self.options.dry_run:
              print("dry run!")

  The expected options are specified by the keyword parameters
  in `opt_specs`.
  Each keyword name has the following semantics:
  * options not starting with a letter may be preceeded by an underscore
    to allow use in the parameter list, for example `_1='once'`
    for a `-1` option setting the `once` option name
  * a single letter name specifies a short option
    and a multiletter name specifies a long option
  * options requiring an argument have a trailing underscore
  * options not requiring an argument normally imply a value
    of `True`; if their synonym commences with a dash they will
    imply a value of `False`, for example `n='dry_run',y='-dry_run'`.

  The `BaseCommand` class provides a `popopts` method
  which is a shim for this method applied to its `.options`.
  So common use in a command method usually looks like this:

      class SomeCommand(BaseCommand):

          def cmd_foo(self, argv):
              
              self.popopts(argv, jobs=1, j='jobs')
              print("jobs =", self.options.jobs)

  The `self.options` object is preprovided as an instance of
  the `self.Options` class, which is `BaseCommandOptions` by
  default. There is presupplies support for some basic options
  like `-v` for "verbose" and so forth, and a subcommand
  need not describe these in a call to `self.options.popopts()`.

  Example:

      >>> import os.path
      >>> from typing import Optional
      >>> @dataclass
      ... class DemoOptions(BaseCommandOptions):
      ...   all: bool = False
      ...   jobs: int = 1
      ...   number: int = 0
      ...   once: bool = False
      ...   path: Optional[str] = None
      ...   trace_exec: bool = False
      ...
      >>> options = DemoOptions()
      >>> argv = ['-1', '-v', '-y', '-j4', '--path=/foo', 'bah', '-x']
      >>> opt_dict = options.popopts(
      ...   argv,
      ...   _1='once',
      ...   a='all',
      ...   j_=('jobs',int),
      ...   x='-trace_exec',
      ...   y='-dry_run',
      ...   dry_run=None,
      ...   path_=(str, os.path.isabs, 'not an absolute path'),
      ...   verbose=None,
      ... )
      >>> opt_dict
      {'once': True, 'verbose': True, 'dry_run': False, 'jobs': 4, 'path': '/foo'}
      >>> options # doctest: +ELLIPSIS
      DemoOptions(cmd=None, dry_run=False, force=False, quiet=False, runstate_signals=(...), verbose=True, all=False, jobs=4, number=0, once=True, path='/foo', trace_exec=False)

  *`BaseCommandOptions.update(self, **updates)`*:
  Modify the options in place with the mapping `updates`.
  It would be more normal to call the options in a `with` statement
  as shown for `__call__`.

  *`BaseCommandOptions.usage_options_format(headline='Options:', *, _common_opt_specs=None, **opt_specs_kw)`*:
  Return an options paragraph describing `opt_specs_kw`.
  or `''` if `opt_specs_kw` is empty.



  Decorator for `cmd.Cmd` subclass methods
  to supply some basic quality of service.

  This decorator:
  - wraps the function call in a `cs.pfx.Pfx` for context
  - intercepts `getopt.GetoptError`s, issues a `warning`
    and runs `self.do_help` with the method name,
    then returns `None`
  - intercepts other `Exception`s,
    issues an `exception` log message
    and returns `None`

  The intended use is to decorate `cmd.Cmd` `do_`* methods:

      from cmd import Cmd
      from cs.cmdutils import docmd
      ...
      class MyCmd(Cmd):
          @docmd
          def do_something(...):
              ... do something ...



  A class to support parsing an option value.

  *`OptionSpec.__post_init__(self)`*:
  Infer `field_name` and `help_text` if unspecified.

  *`OptionSpec.add_argument(self, parser, options=None)`*:
  Add this option to an `argparser`-style option parser.
  The optional `options` parameter may be used to supply an
  `Options` instance to provide a default value.

  *`OptionSpec.from_opt_kw(opt_k: str, specs: Union[str, List, Tuple, NoneType])`*:
  Factory to produce an `OptionSpec` from a `(key,specs)` 2-tuple
  as from the `items()` from a `popopts()` call.

  The `specs` is normally a list or tuple, but a bare string
  will be promoted to a 1-element list containing the string.

  The elements of `specs` are considered in order for:
  - an identifier specifying the `arg_name`,
    optionally prepended with a dash to indicate an inverted option
  - a help text about the option
  - a callable to parse the option string value to obtain the actual value
  - a callable to validate the option value
  - a message for use when validation fails

  *`OptionSpec.getopt_long`*:
  The option specification for a getopt long option.
  Return `None` if `self.opt_name` is only 1 character.

  *`OptionSpec.getopt_opt`*:
  The `opt` we expect from `opt,val=getopt(argv,...)`.

  *`OptionSpec.getopt_short`*:
  The option specification for a getopt short option.
  Return `''` if `self.opt_name` is longer than 1 character.

  *`OptionSpec.help_text_from_field_name(field_name)`*:
  Compute an inferred `help_text` from an option `field_name`.

  *`OptionSpec.needs_arg`*:
  Whether we expect an argument: we have a `self.arg_name`.

  *`OptionSpec.option_terse(self)`*:
  Return the `"-x"` or `"--name"` option string (with the arg name if expected).

  *`OptionSpec.option_usage(self)`*:
  A 2 line usage entry for this option.
  Example:

      -j jobs
        Job limit.

  *`OptionSpec.parse_value(self, value)`*:
  Parse `value` according to the spec.
  Raises `GetoptError` for invalid values.



  A decorator to parse command line options from a `cmd_`*method*'s `argv`
  and update `self.options`. This also updates the method's usage message.

  Example:

      @popopts(x=('trace', 'Trace execution.'))
      def cmd_do_something(self, argv):
          """ Usage: {cmd} [-x] blah blah
                Do some thing to blah.
          """

  This arranges for cmd_do_something to call `self.options.popopts(argv)`,
  and updates the usage message with an "Options:" paragraph.

  This avoids needing to manually enumerate the options in the
  docstring usage and avoids explicitly calling `self.options.popopts`
  inside the method.



  Call `print()` if `options.verbose` and not `options.quiet`.



  Extract a `"Usage:"`paragraph from a docstring
  and return a 3-tuple of `(preusage,usage,postusage)`.

  If the usage paragraph is not present `''` is returned as
  the middle comonpent, otherwise it is the unindented usage
  without the leading `"Usage:"`.



  An implementation for a subcommand.

  *`SubCommand.__call__(self, argv: List[str])`*:
  Run the subcommand.

  Parameters:
  * `argv`: the command line arguments after the subcommand name

  *`SubCommand.get_cmd(self) -> str`*:
  Return the `cmd` string for this `SubCommand`,
  derived from the subcommand's method name or class name
  if `self.cmd` is not set.

  *`SubCommand.get_subcmds(self)`*:
  Return the names of `self.method`'s subcommands in lexical order.

  *`SubCommand.get_subcommands(self)`*:
  Return `self.method`'s mapping of subcommand name to `SubCommand`.

  *`SubCommand.get_usage_format(self, show_common=False) -> str`*:
  Return the usage format string for this subcommand.
  *Note*: no leading "Usage:" prefix.
  If `show_common` is true, include the `Common options:` paragraph.

  *`SubCommand.get_usage_keywords(self, *, cmd: Optional[str] = None, usage_mapping: Optional[Mapping] = None) -> str`*:
  Return a mapping to be used when formatting the usage format string.

  This is an elaborate `ChainMap` of:
  - the optional `cmd` or `self.get_cmd()`
  - the optional `usage_mapping`
  - `self.usage_mapping`
  - `self.method.USAGE_KEYWORDS` if present
  - the attributes of `self.command`
  - the attributes of `type(self.command)`
  - the attributes of the module for `type(self.command)`

  *`SubCommand.has_subcommands`*:
  Whether this `SubCommand`'s `.method` has subcommands.

  *`SubCommand.instance`*:
  An instance of the class for `self.method`.

  *`SubCommand.short_subusages(self, subcmds: List[str], *, recurse=False, short=False)`*:
  Return a list of tabulated one line subcommand summaries.

  *`SubCommand.subusage_table(self, subcmds: List[str], *, recurse=False, short=False)`*:
  Return rows for use with `cs.lex.tabulate`
  for the short subusage listing.

  *`SubCommand.usage_text(self, *, cmd=None, short: bool, recurse: bool = False, show_common: bool = False, show_subcmds: Union[bool, str, List[str], NoneType] = None, usage_mapping: Optional[Mapping] = None, seen_subcommands: Optional[Mapping] = None) -> str`*:
  Return the filled out usage text for this subcommand.



  Call `print()` if `options.verbose`.
  This is a compatibility shim for `qvprint()` with `quiet=False`.





  *Release 20241218*:
  BaseCommand: add cmd_repl to the default subcomands.

  *Release 20241212*:
  SubCommand.short_subusages: use a single tabluate() table for the entire recursive listing, produces a much more readable short listing.

  *Release 20241207*:
  BaseCommandOptions.usage_options_format: support multiline help text via the new tabulate support.

  *Release 20241206.1*:
  SubComand.usage_text: normalise the show_subcmds to match the subcommands mapping.

  *Release 20241206*:
  * New @popopts decorator to run self.options.popopts and fill out the usage message.
  * Add "-e ssh-command" and the .ssh_exe attribute to BaseCommandOptions.

  *Release 20241122.2*:
  * OptionSpec.getopt_long: fix construction of getopt long option specifications, lost during the recent refactor.
  * Two other minor fixes.

  *Release 20241122.1*:
  * SubCommand.usage_format_parts: backport type annotation for older Pythons.
  * BaseCommand.extract_usage: update parameters for usage_text().

  *Release 20241122*:
  * BaseCommand.cmd_help: new -l (long), -r (recurse) and -s (short, not long) options.
  * A big rework of the help/usage output; still one rough edge left.
  * BaseCommandOptions.popopts: infill with False instead of None for missing boolean options.
  * SubCommand: a few new methods and properties to expose various operations.
  * BaseCommand._prerun_setup: revert SUBCOMMAND_ARGV_DEFAULT to None, make a missing subcommand run "help -s" when there's no SUBCOMMAND_ARGV_DEFAULT.

  *Release 20241119*:
  * SubCommand.usage_text: small improvements and a fix.
  * New BaseCommand.SubCommandClass attribute for the SubCommand subclass, supports using additional SubCommand subclasses for eg cs.djutils.

  *Release 20241117*:
  * _COMMON_OPT_SPECS: include a --dry-run option, alter for -n.
  * SubCommand.usage_text: one line listing for common subcommands.

  *Release 20241110*:
  * Various fixes and enhancements to the usage text generation.
  * BaseCommandOptions.COMMON_OPT_SPECS stuff, including inheritance and presentation in usage.
  * BaseCommand.run: if self.run_context() yields not None, exit immediately with that value.
  * Rationalise and improve OptionSpec.
  * Supplant vprint with qvprint which honours quiet and verbose, provide vprint as a shim with a hardwired quiet=False.
  * Make cmd_info the default subcommand and make some improvements.
  * BaseCommandOptions: new fields_as_dict method, update copy() to start with fields_as_dict, overlay as_dict, overlay updates.
  * OptionSpec: new add_argument(parser[,options]) method to add this option to an argparse style option parser (again, for the upcoming cs.djutils module).
  * A heap of small things.

  *Release 20241007*:
  * BaseCommand: drop __init_subclass__, was doing too much to early.
  * BaseCommand.__init__: no cmd and argv[0] ends with ".py" infer cmd from the class name.
  * Other minor updates.

  *Release 20241005*:
  * BaseCommand: provide an options.runstate to allow the command to override the default (almost never happens).
  * BaseCommand.popopts: fix reference to OptionSpec class.
  * BaseCommand.run: put the try/except:CancellationError outside the self.run_context context manager call, as it can directly raise CancellationError.
  * New vprint() function calling print() if options.verbose.

  *Release 20240709*:
  BaseCommand: support putting the top level Usage in the class docstring instead of as .USAGE_FORMAT, append full usage to the class docstring in `BaseCommand.__init_subclass__`.

  *Release 20240630*:
  * BaseCommand: make SUBCOMMAND_ARGV_DEFAULT be 'shell' for an interactive prompt, still a little unsure how sensible this is, aiming at the very cool submode stuff from the Cisco switch config command line.
  * BaseCommandOptions: new as_dict() method.
  * New SubCommand.usage_text() to compose the full usage text for this SubCommand.
  * Many small improvements and internal refactors.

  *Release 20240519*:
  BaseCommand.run_context: attach the runstate to the options.

  *Release 20240422*:
  * BaseCommandOptions.popopts: return the dict from BaseCommand.popopts().
  * BaseCommand.apply_preargv: apply the default options supported by self.options.
  * BaseCommandOptions.update(mapping) method, useful for dropping subcommand-specific defaults onto the options ahead of the local popopts() call.

  *Release 20240412*:
  * BaseCommand.run_context: do not store .upd and .runstate on the options (it confuses options in subcommands and we have @uses_runstate and @uses_upd forthis anyway these days).
  * BaseCommand.run_context: catch SIGQUIT, present the default handler as BaseCommand.handle_signal.

  *Release 20240316*:
  * New @uses_cmd_options decorator to provide an "options" parameter being the prevailing BaseCommandOptions instance.
  * BaseCommandOptions.popopts: get common options from BaseCommandOptions.COMMON_OPT_SPECS.

  *Release 20240211*:
  * Include the first sentence of the subcommand description in the short help.
  * BaseCommandOptions: move the runstate_signals into this directly.
  * BaseCommand: move the run() options stuff into run_context() and have it work on a copy of the original options.
  * BaseCommandCmd: implement get_names(), provide docstrings for the do_* attributes, thus help.
  * BaseCommand.run_context: make runstate and upd keyword only parameters.

  *Release 20240201*:
  * BaseCommand.run: catch CancellationError and return 1.
  * BaseCommandCmd.__getattr__: recognise EOF, exit and quit to terminate the cmdloop.

  *Release 20231129*:
  BaseCommandOptions: define a runstate field.

  *Release 20230703*:
  Small internal changes.

  *Release 20230612*:
  * BaseCommand.cmdloop: fix intro parameter.
  * Other small fixes.

  *Release 20230407*:
  * BaseCommand: use @uses_runstate when preparing the command, store as self.options.runstate.
  * Make BaseCommandOptions a data class.
  * Drop any pretence at python 2 support, we're long past that.
  * BaseCommand: new cmdloop method to run a cmd.Cmd instance to run subcommand interactively.
  * BaseCommand: rename shell to repl, add cmd_shell to call cmdloop().
  * Drop BaseCommand.apply_defaults in favour of the Options dataclass.
  * BaseCommand: do setup_logging before initiating the Options instance.

  *Release 20230212*:
  * BaseCommand.run_context: update RunState support.
  * BaseCommand.run_context: always be having an self.options.upd.

  *Release 20230211*:
  BaseCommand: new shell() method to present an interactive Python prompt for use by subclasses cmd_shell method if desired.

  *Release 20221228*:
  Move a lot of the context logic from BaseCommand.run to BaseCommand.run_context, which now must be correctly overridden in subclasses.

  *Release 20220918*:
  * BaseCommand.run_context: expand default signals to include SIGHUP, expose as BaseCommand.DEFAULT_SIGNALS.
  * BaseCommand.run: pass in the subclass handle_signal method if present.

  *Release 20220626*:
  * BaseCommand.poparg: fix positional argument handling.
  * BaseCommand.poparg: new unpop_on_error=False parameter to support pushing a bad argument back onto the front of the argument list.

  *Release 20220606*:
  BaseCommand.run: remove the Upd bodge, too annoying, now fixed in cs.upd I believe.

  *Release 20220605*:
  * BaseCommand: new popopts(argv,...) compact getopt wrapper.
  * BaseCommand: new poparg(argv,...) compact validating argument consumer.
  * BaseCommand: drop run_argv, provided no utility.
  * BaseCommand.run: get the RunState signal list from self.options.runstate_signals.
  * BaseCommand.apply_opts: support multiple individual options raising GetoptError, as I hate commands which abort at the first bad option.
  * Assorted other small things.

  *Release 20220429*:
  * BaseCommand: fold dots in argv[0] into underscores, supports subcommands like "setup.py".
  * BaseCommand: new popargv(argv[,help_text[,parse[,validate[,unvalidated_message]]]]) helper class method.
  * BaseCommand: accept dashed-form of the underscored_form subcommand name.
  * BaseCommand: new self.options.runstate_signals=SIGINT,SIGTERM specifying singals to catch-and-cancel, shuffle run() context managers.

  *Release 20220318*:
  BaseCommand.__init__: handle main() method in the New Scheme.

  *Release 20220315*:
  _BaseSubCommand.__init__: hook in the class USAGE_KEYWORDS for methods.

  *Release 20220311*:
  BaseCommand: big refactor of subcommand internals and make the "cmd_foo=FooCommand" implementation work properly.

  *Release 20211208*:
  BaseCommand: better handle an unknown subcommand.

  *Release 20210927*:
  * Usage: show only the per subcommand usage for in-subcommand GetoptError.
  * Usage: show terse usage when the subcommand cannot be recognised.
  * Usage: support bare -h, -help, --help.

  *Release 20210913*:
  New BaseCommand.apply_preargv method to gather special arguments before subcommands.

  *Release 20210906*:
  * BaseCommand.cmd_help: bugfix obsolete parameter list.
  * BaseCommand.SUBCOMMAND_ARGV_DEFAULT: support a single str value, turn into list.

  *Release 20210809*:
  Bugfix BaseCommand.cmd_help for modern API.

  *Release 20210731*:
  * BaseCommand.run: apply optional keyword arguments to self.options during the run.
  * Look for self.SUBCOMMAND_ARGV_DEFAULT if no subcommand is supplied.
  * Bugfix case for "main" method and no "cmd_*" methods.
  * Bugfix BaseCommand.cmd_help.

  *Release 20210420*:
  * BaseCommand.getopt_error_handler: replace error print() with warning().
  * Docstring improvements.

  *Release 20210407.1*:
  BaseCommand: bugfix for __init_subclass__ docstring update.

  *Release 20210407*:
  * BaseCommand.__init_subclass__: behave sanely if the subclass has no initial __doc__.
  * BaseCommand: new .run_argv convenience method, obviates the "def main" boilerplate.

  *Release 20210404*:
  BaseCommand subclasses: automatically add the main usage message to the subclass docstring.

  *Release 20210306*:
  * BREAKING CHANGE: rework BaseCommand as a more normal class instantiated with argv and with most methods being instance methods, getting the former `options` parameter from self.options.
  * BaseCommand: provide default `apply_opt` and `apply_opts` methods; subclasses will generally just override the former.

  *Release 20210123*:
  BaseCommand: propagate the format mapping (cmd, USAGE_KEYWORDS) to the subusage generation.

  *Release 20201102*:
  * BaseCommand.cmd_help: supply usage only for "all commands", full docstring for specified commands.
  * BaseCommand: honour presupplied options.log_level.
  * BaseCommand.usage_text: handle missing USAGE_FORMAT better.
  * BaseCommand.run: provide options.upd.
  * BaseCommand subclasses may now override BaseCommand.OPTIONS_CLASS (default SimpleNamespace) in order to provide convenience methods on the options.
  * BaseCommand.run: separate variable for subcmd with dash translated to underscore to match method names.
  * Minor fixes.

  *Release 20200615*:
  BaseCommand.usage_text: do not mention the "help" command if it is the only subcommand (it won't be available if there are no other subcommands).

  *Release 20200521.1*:
  Fix DISTINFO.install_requires.

  *Release 20200521*:
  * BaseCommand.run: support using BaseCommand subclasses as cmd_* names to make it easy to nest BaseCommands.
  * BaseCommand: new hack_postopts_argv method called after parsing the main command line options, for inferring subcommands or the like.
  * BaseCommand: extract "Usage:" paragraphs from subcommand method docstrings to build the main usage message.
  * BaseCommand: new cmd_help default command.
  * Assorted bugfixes and small improvements.

  *Release 20200318*:
  * BaseCommand.run: make argv optional, get additional usage keywords from self.USAGE_KEYWORDS.
  * @BaseCommand.add_usage_to_docstring: honour cls.USAGE_KEYWORDS.
  * BaseCommand: do not require GETOPT_SPEC for commands with no defined options.
  * BaseCommand.run: call cs.logutils.setup_logging.

  *Release 20200229*:
  Improve subcommand selection logic, replace StackableValues with stackattrs, drop `cmd` from arguments passed to main/cmd_* methods (present in `options`).

  *Release 20200210*:
  * New BaseCommand.add_usage_to_docstring class method to be called after class setup, to append the usage message to the class docstring.
  * BaseCommand.run: remove spurious Pfx(cmd), as logutils does this for us already.

  *Release 20190729*:
  BaseCommand: support for a USAGE_FORMAT usage message format string and a getopt_error_handler method.

  *Release 20190619.1*:
  Another niggling docstring formatting fix.

  *Release 20190619*:
  Minor documentation updates.

  *Release 20190617.2*:
  Lint.

  *Release 20190617.1*:
  Initial release with @docmd decorator and alpha quality BaseCommand command line assistance class.


pkgId: bc15e814a7850f6b6125c5d8172153aef5c112cd4b5a468e6df2b1a98aff829d
name: python-cs-naysync-help
arch: noarch
version: 20241214.1
epoch: 0
release: 1
summary: Development documents and examples for cs-naysync
url: https://pypi.org/project/cs-naysync/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cs-naysync-20241214.1-1.src.rpm
location_href: Packages/python-cs-naysync-help-20241214.1-1.noarch.rpm
checksum_type: sha256
description:
  An attempt at comingling async-code and nonasync-code-in-a-thread in an argonomic way.

  *Latest release 20241214.1*:
  Doc update.

  One of the difficulties in adapting non-async code for use in
  an async world is that anything asynchronous needs to be turtles
  all the way down: a single blocking sychornous call anywhere
  in the call stack blocks the async event loop.

  This module presently provides a pair of decorators for
  asynchronous generators andfunctions which dispatches them in
  a `Thread` and presents an async wrapper.



  A decorator for a synchronous function which turns it into
  an asynchronous function.

  The parameters are the same as for `@agen` excluding `maxsize`,
  as this wraps the function in an asynchronous generator which
  just yields the function result.

  Example:

      @afunc
      def func(count):
          time.sleep(count)
          return count

      slept = await func(5)



  A decorator for a synchronous generator which turns it into
  an asynchronous generator.

  Parameters:
  * `maxsize`: the size of the `Queue` used for communication,
    default `1`; this governs how greedy the generator may be
  * `poll_delay`: the async delay between polls of the `Queue`
    after it was found to be empty twice in succession, default `0.25`s
  * `fast_poll_delay`: the async delay between polls of the
    `Queue` after it was found to be empty the first time after the
    start or after an item was obtained

  Exceptions in the generator are reraised in the synchronous generator.

  Example:

      @agen
      def gen(count):
          for i in range(count):
              yield i
              time.sleep(1.0)

      async for item in gen(5):
          print(item)





  *Release 20241214.1*:
  Doc update.

  *Release 20241214*:
  Initial release with @agen and @afunc decorators.


pkgId: 32a7217618d49e10023c43132d7e48ad2a3f276e576a3e51ee0692dac348f9da
name: python-cs-naysync-help
arch: noarch
version: 20241220
epoch: 0
release: 1
summary: Development documents and examples for cs-naysync
url: https://pypi.org/project/cs-naysync/
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cs-naysync-20241220-1.src.rpm
location_href: Packages/python-cs-naysync-help-20241220-1.noarch.rpm
checksum_type: sha256
description:
  An attempt at comingling async-code and nonasync-code-in-a-thread in an argonomic way.

  *Latest release 20241220*:
  * New async_iter(Iterable) returning an asynchronous iterator of a synchronous iterable.
  * New amap(func,iterable) asynchronously mapping a function over an iterable.

  One of the difficulties in adapting non-async code for use in
  an async world is that anything asynchronous needs to be turtles
  all the way down: a single blocking synchronous call anywhere
  in the call stack blocks the async event loop.

  This module presently provides a pair of decorators for
  asynchronous generators and functions which dispatches them in
  a `Thread` and presents an async wrapper.



  A decorator for a synchronous function which turns it into
  an asynchronous function.

  Example:

      @afunc
      def func(count):
          time.sleep(count)
          return count

      slept = await func(5)



  A decorator for a synchronous generator which turns it into
  an asynchronous generator.
  Exceptions in the synchronous generator are reraised in the asynchronous
  generator.

  Example:

      @agen
      def gen(count):
          for i in range(count):
              yield i
              time.sleep(1.0)

      async for item in gen(5):
          print(item)



  An asynchronous generator yielding the results of `func(item)`
  for each `item` in the asynchronous iterable `it`.

  If `concurrent` is `False` (the default), run each `func(item)`
  call in series.

  If `concurrent` is true run the function calls as `asyncio`
  tasks concurrently.
  If `unordered` is true (default `False`) yield results as
  they arrive, otherwise yield results in the order of the items
  in `it`, but as they arrive - tasks still evaluate concurrently
  if `concurrent` is true.

  If `indexed` is true (default `False`) yield 2-tuples of
  `(i,result)` instead of just `result`, where `i` is the index
  if each item from `it` counting from `0`.

  Example of an async function to fetch URLs in parallel.

      async def get_urls(urls : List[str]):
          """ Fetch `urls` in parallel.
              Yield `(url,response)` 2-tuples.
          """
          async for i, response in amap(
              requests.get, urls,
              concurrent=True, unordered=True, indexed=True,
          ):
              yield urls[i], response



  Return an asynchronous iterator yielding items from the iterable `it`.





  *Release 20241220*:
  * New async_iter(Iterable) returning an asynchronous iterator of a synchronous iterable.
  * New amap(func,iterable) asynchronously mapping a function over an iterable.

  *Release 20241215*:
  * @afunc: now uses asyncio.to_thread() instead of wrapping @agen, drop the decorator parameters since no queue or polling are now used.
  * @agen: nonpolling implementation - now uses asyncio.to_thread() for the next(genfunc) step, drop the decorator parameters since no queue or polling are now used.

  *Release 20241214.1*:
  Doc update.

  *Release 20241214*:
  Initial release with @agen and @afunc decorators.


pkgId: 78d9f9cd3ad03c0617087e3e3b8ef83231d6afdd411458c71ad0af4b313a1306
name: python-cschwabpy-help
arch: noarch
version: 0.1.4.4
epoch: 0
release: 1
summary: Development documents and examples for cschwabpy
url: https://pypi.org/project/cschwabpy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cschwabpy-0.1.4.4-1.src.rpm
location_href: Packages/python-cschwabpy-help-0.1.4.4-1.noarch.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)



  This is a Python client library for accessing the Charles Schwab stock and option trade API. It provides a convenient way to interact with the Charles Schwab trading platform programmatically.



  - [x] Authenticate with your Charles Schwab account
  - [X] Automated refreshing of access token
  - [x] Download option chain data
  - [x] Get account information
  - [x] Place stock and option trades
  - Retrieve trade history [Work in Progress]
  - Monitor real-time market data [TODO]



  To install the Charles Schwab API client, you can use pip:
  ```
  pip install CSchwabPy
  ```



  * Authentication & Get Access Token & Refresh Token

  ```python



  from cschwabpy.SchwabClient import SchwabClient

  app_client_key = "---your-app-client-key-here-"
  app_secret = "app-secret"

  schwab_client = SchwabClient(app_client_id=app_client_key, app_secret=app_secret)
  schwab_client.get_tokens_manually()


  > python cschwab.py





  ticker = '$SPX'

  expiration_list = schwab_client.get_option_expirations(underlying_symbol = ticker)


  from_date = 2024-07-01
  to_date = 2024-07-01

  opt_chain_result = schwab_client.download_option_chain(ticker, from_date, to_date)


  opt_df_pairs = opt_chain_result.to_dataframe_pairs_by_expiration()

  for df in opt_df_pairs:
      print(df.expiration)
      print(f"call dataframe size: {df.call_df.shape}. expiration: {df.expiration}")
      print(f"put dataframe size: {df.put_df.shape}. expiration: {df.expiration}")
      print(df.call_df.head(5))
      print(df.put_df.head(5))

  ```


  git tag v0.1.3.9
  git push origin tag v0.1.3.9


pkgId: 810984de3220d2c948177ec3e327aecd593acca90b566c0d33a2efe5bff2b164
name: python-csdt-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for csdt
url: https://github.com/sibirbil/CSDT.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-csdt-1.0.1-1.src.rpm
location_href: Packages/python-csdt-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  - **Custom Split Logic**: Easily define custom split criteria for decision tree nodes.
  - **Tree Visualization**: Generate high-quality tree visualizations using `graphviz`.
  - **Flexible Splitting Criteria**: Works with user-defined splitting functions and evaluation metrics.


pkgId: f2a1907d895e6f7212abf346577690cb5b8a386bdc2a920f00a29e6391e646ae
name: python-csexamgenerator-help
arch: noarch
version: 2.0.1
epoch: 0
release: 1
summary: Development documents and examples for csexamgenerator
url: https://pypi.org/project/csexamgenerator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-csexamgenerator-2.0.1-1.src.rpm
location_href: Packages/python-csexamgenerator-help-2.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![Version](https://img.shields.io/badge/Latest%20Version-v0.0.3-%2300b4d8.svg?&style=for-the-badge&logo=git&logoColor=white)
  ![Python](https://img.shields.io/badge/Python-%230096c7.svg?&style=for-the-badge&logo=python&logoColor=white)
  ![Google Colab](https://img.shields.io/badge/Google%20Colab-4285F4?style=for-the-badge&logo=googledrive&logoColor=white)

  Update (29 Sep 2024): Publish package to PyPi


  **cspyexamclient** is a Python client for interacting with online exam system. It allows students to register, answer questions, and submit their answers. The client uses `ipywidgets` for creating interactive widgets in ipython notebooks before uploading students answers to the exam server.



  - **Register Student**: Allows students to register using their email.
  - **Generate Questions**: Dynamically displays questions and answer options.
  - **Display Submission Summary**: Displays a summary of all questions and corresponding answers.
  - **Submit Answers**: Submits student answers to the server.



  <img width="500" src="assets/test_submission.gif">



  <img width="500" src="assets/exam_summary.png">


  | Module       | Description       | Link                                                                                  |
  |--------------|-------------------|---------------------------------------------------------------------------------------|
  | M1.1         | Basic SQL         | https://colab.research.google.com/drive/1E3sppN-vjschXS46WTeqZnQSmRBcuggN?usp=sharing |
  | M1.2         | Advanced SQL      | https://colab.research.google.com/drive/1i-aGTjpXL-En8kVFB0Cl8elHn9Z866yv?usp=sharing |
  | M2.1         | Python 101        | https://colab.research.google.com/drive/1zX-ZgjEot_uGHh8x2nCl7hGWUklLuYeL?usp=sharing |
  | M3.1         | Pandas 101        | https://colab.research.google.com/drive/143rJnko61nMUGGwMccgxaBJRA-CmJEqT?usp=sharing |
  | M4.1         | Data Visualization| Exam is coding and feedback thus no questions generation needed                       |


pkgId: 7b70e280aa79f5ac04eace1c5869a4002c6c390a4c020879a27fb82dfd71cdac
name: python-cshelve-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for cshelve
url: https://pypi.org/project/cshelve/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cshelve-0.8.0-1.src.rpm
location_href: Packages/python-cshelve-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  `Cloud Shelve (cshelve)` is a Python package that provides a seamless way to store and manage data in the cloud using the familiar [Python Shelve interface](https://docs.python.org/3/library/shelve.html). It is designed for efficient and scalable storage solutions, allowing you to leverage cloud providers for persistent storage while keeping the simplicity of the `shelve` API.



  - Supports large file storage in the cloud
  - Secure data in-transit encryption when using cloud storage
  - Fully compatible with Python's `shelve` API
  - Cross-platform compatibility for local and remote storage



  Install `cshelve` via pip:

  ```bash
  pip install cshelve
  ```



  The `cshelve` module strictly follows the official `shelve` API. Consequently, you can refer to the [Python official documentation](https://docs.python.org/3/library/shelve.html) for general usage examples. Simply replace the `shelve` import with `cshelve`, and you're good to go.



  Here is an example, adapted from the [official shelve documentation](https://docs.python.org/3/library/shelve.html#example), demonstrating local storage usage. Just replace `shelve` with `cshelve`:

  ```python
  import cshelve

  d = cshelve.open('local.db')  # Open the local database file

  key = 'key'
  data = 'data'

  d[key] = data                 # Store data at the key (overwrites existing data)
  data = d[key]                 # Retrieve a copy of data (raises KeyError if not found)
  del d[key]                    # Delete data at the key (raises KeyError if not found)

  flag = key in d               # Check if the key exists in the database
  klist = list(d.keys())        # List all existing keys (could be slow for large datasets)


  d['xx'] = [0, 1, 2]           # Store a list
  d['xx'].append(3)             # This won't persist since writeback=True is not used


  temp = d['xx']                # Extract the stored list
  temp.append(5)                # Modify the list
  d['xx'] = temp                # Store it back to persist changes

  d.close()                     # Close the database
  ```



  For testing purposes, it is possible to use an in-memory provider that can:
  - Persist the data during all the program execution.
  - Remove the data object is deleted.

  Here is a configuration example:
  ```bash
  $ cat in-memory.ini
  [default]
  provider    = in-memory

  persist-key = standard
  ```

  A common use case for this provider is to simplify mocking.

  Example:
  ```bash
  $ cat persist.ini
  [default]
  provider    = in-memory

  persist-key = my-db

  $ cat do-not-persist.ini
  [default]
  provider = in-memory
  ```

  ```python
  import cshelve

  with cshelve.open('persist.ini') as db:
      db["Asterix"] = "Gaulois"

  with cshelve.open('persist.ini') as db:
      assert db["Asterix"] == "Gaulois"

  with cshelve.open('do-not-persist.ini') as db:
      db["Obelix"] = "Gaulois"

  with cshelve.open('do-not-persist.ini') as db:
      assert "Obelix" not in db
  ```



  To configure remote cloud storage, you need to provide an INI file containing your cloud provider's configuration. The file should have a `.ini` extension. Remote storage also requires the installation of optional dependencies for the cloud provider you want to use.



  First, install the Azure Blob Storage provider:
  ```bash
  pip install cshelve[azure-blob]
  ```

  Then, create an INI file with the following configuration:
  ```bash
  $ cat azure-blob.ini
  [default]
  provider        = azure-blob
  account_url     = https://myaccount.blob.core.windows.net


  auth_type       = passwordless
  container_name  = mycontainer
  ```

  Once the INI file is ready, you can interact with remote storage the same way as with local storage. Here's an example using Azure:

  ```python
  import cshelve

  d = cshelve.open('azure-blob.ini')  # Open using the remote storage configuration

  key = 'key'
  data = 'data'

  d[key] = data                  # Store data at the key on the remote storage
  data = d[key]                  # Retrieve the data from the remote storage
  del d[key]                     # Delete the data from the remote storage

  flag = key in d                # Check if the key exists in the cloud storage
  klist = list(d.keys())         # List all keys present in the remote storage


  d['xx'] = [0, 1, 2]            # Store a list on the remote storage
  d['xx'].append(3)              # This won't persist since writeback=True is not used


  temp = d['xx']                 # Extract the stored list from the remote storage
  temp.append(5)                 # Modify the list locally
  d['xx'] = temp                 # Store it back on the remote storage to persist changes

  d.close()                      # Close the connection to the remote storage
  ```

  More configuration examples for other cloud providers can be found [here](./tests/configurations/).





  Provider: `in-memory`
  Installation: No additional installation required.

  The In Memory provider uses an in-memory data structure to simulate storage. This is useful for testing and development purposes.

  | Option         | Description                                                                  | Required | Default Value |
  |----------------|------------------------------------------------------------------------------|----------|---------------|
  | `persist-key`  | If set, its value will be conserved and reused during the program execution. | :x:      | None          |
  | `exists`       | If True, the database exists; otherwise, it will be created.                 | :x:      | False         |




  Provider: `azure-blob`
  Installation: `pip install cshelve[azure-blob]`

  The Azure provider uses [Azure Blob Storage](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-blobs-introduction) as remote storage.
  The module considers the provided container as dedicated to the application. The impact might be significant. For example, if the flag `n` is provided to the `open` function, the entire container will be purged, aligning with the [official interface](https://docs.python.org/3/library/shelve.html#shelve.open).

  | Option                           | Description                                                                                                                                                  | Required           | Default Value |
  |----------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------|---------------|
  | `account_url`                    | The URL of your Azure storage account.                                                                                                                       | :x:                |               |
  | `auth_type`                      | The authentication method to use: `access_key`, `passwordless`, `connection_string` or `anonymous`.                                                                               | :white_check_mark:                |               |
  | `container_name`                 | The name of the container in your Azure storage account.                                                                                                     | :white_check_mark:                |               |

  Depending on the `open` flag, the permissions required by `cshelve` for blob storage vary.

  | Flag | Description | Permissions Needed |
  |------|-------------|--------------------|
  | `r`  | Open an existing blob storage container for reading only. | [Storage Blob Data Reader](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-reader) |
  | `w`  | Open an existing blob storage container for reading and writing. | [Storage Blob Data Contributor](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-contributor) |
  | `c`  | Open a blob storage container for reading and writing, creating it if it doesn't exist. | [Storage Blob Data Contributor](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-contributor) |
  | `n`  | Purge the blob storage container before using it. | [Storage Blob Data Contributor](https://learn.microsoft.com/en-us/azure/role-based-access-control/built-in-roles#storage-blob-data-contributor) |


  Authentication type supported:

  | Auth Type         | Description                                                                                     | Advantage                                                                 | Disadvantage                          | Example Configuration |
  |-------------------|-------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|---------------------------------------|-----------------------|
  | Access Key       | Uses an Access Key or a Shared Access Signature for authentication. | Fast startup as no additional credential retrieval is needed. | Credentials need to be securely managed and provided. | [Example](./tests/configurations/azure-integration/access-key.ini) |
  | Anonymous         | No authentication for anonymous access on public blob storage. | No configuration or credentials needed. | Read-only access. | [Example](./tests/configurations/azure-integration/anonymous.ini) |
  | Connection String | Uses a connection string for authentication. Credentials are provided directly in the string. | Fast startup as no additional credential retrieval is needed. | Credentials need to be securely managed and provided. | [Example](./tests/configurations/azure-integration/connection-string.ini) |
  | Passwordless      | Uses passwordless authentication methods such as Managed Identity. | Recommended for better security and easier credential management. | May impact startup time due to the need to retrieve authentication credentials. | [Example](./tests/configurations/azure-integration/standard.ini) |




  We welcome contributions from the community! Have a look at our [issues](https://github.com/Standard-Cloud/cshelve/issues).



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



  If you have any questions, issues, or feedback, feel free to [open an issue]https://github.com/Standard-Cloud/cshelve/issues).


pkgId: bfebabc4a6803e629279395b5cd308db382cc36bdd15fd67ac973f3fce9538dc
name: python-csi-images-help
arch: noarch
version: 1.6.0
epoch: 0
release: 1
summary: Development documents and examples for csi-images
url: https://github.com/CSI-Cancer/csi_images
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-csi-images-1.6.0-1.src.rpm
location_href: Packages/python-csi-images-help-1.6.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/csi-images)](https://pypi.org/project/csi-images/)
  ![Coverage Badge](docs/coverage.svg)
  ![Tests Badge](docs/tests.svg)

  This package is a library for interacting with data, mainly from immunoflourescent
  microscopy, such as cells and the images thereof.
  While much of the functionality is specific to the CSI-Cancer organization, some of the
  functionality and structure may be beneficial for the broader community.
  Other packages in the CSI-Cancer organization may depend on this package.

  Install with:

  ```commandline
  pip install csi_images
  ```

  or

  ```commandline
  pip install csi_images[imageio,rds,dev,all]
  ```

  The base version of the package includes only core data structures and manipulations.

  Optional dependencies include:

  * `imageio`: for reading and writing images, include .czi files.
  * `rds`: for reading and writing RDS files, such as OCULAR outputs.
  * `dev`: for development dependencies, including documentation, tests, building, etc.
  * `all`: for all optional dependencies.



  This package contains these modules:

  1. `csi_scans.py`: a module for interacting with scan-level files, such as .czi files.
      * `Scan`: a class that contains all of the scan metadata. for interacting with scan
        metadata, such as the slide ID, the path to the scan, and scan parameters.
        Recommend importing via `from csi_images.csi_scans import Scan`
  2. `csi_tiles.py`: a module for interacting with tiles, which have a particular (x, y)
     position in the scan. Tiles have several frames taken at the same position.
      * `Tile`: a class for containing a tile's positional data. Imports `csi_scans.py`.
        This class unifies multiple scanners' tile positioning to convert between index
        and (x, y). Recommend importing via `from csi_images.csi_tiles import Tile`
  3. `csi_frames.py`: a module for interacting with frames, which are individual images.
     Imports `csi_scans.py` and `csi_tiles.py`. Recommend importing via
     `from csi_images.csi_frames import Frame`
      * `Frame`: a class for containing a frame's metadata. Each frame in a tile has a
        different channel, or light spectrum. The frame **only contains metadata**, but
        enables gathering of the image data through the `get_image()` method. For a list
        of frames, use `get_frames()`. For all frames in a scan, use `get_all_frames()`.
        For many frames, use `[frame.get_image() for frame in frames]`. Recommend
        importing via `from csi_images.csi_frames import Frame`
  4. `csi_events.py`: a module for interacting with individual events. Imports
     `csi_scans.py`, `csi_tiles.py`, and `csi_frames.py`.
      * `Event`: a class for containing a single event's metadata and feature data. Key
        metadata (scan, tile, x, y) is required; the others are optional and flexible.
        Contains a convenience function for getting crops of an event, as well as
        functions for determining the position of the event in the slide coordinate frame.
        Recommend importing via `from csi_images.csi_events import Event`
      * `EventArray`: a class for containing a list of events, holding their data in
        pandas dataframes. Contains functions converting back and forth from `Event`s and
        files. Recommend importing via `from csi_images.csi_events import EventArray`



  * `Event.montage()`: Combines crops for an event into side-by-side montages.



  For more detailed documentation, check
  [the API docs](https://csi-cancer.github.io/csi_images/).

  Alternatively, once you have cloned the repository, you
  can open up `docs/index.html` in your browser.

  To regenerate the documentation, ensure that you
  have [installed the package](#installation) and then run:

  ```commandline
  make_docs_for_csi_images
  ```



  1. Activate your `conda` (`conda activate yourenv`) or
     `venv` (`source path/to/your/venv/bin/activate`) environment first.
  2. Clone `csi_images` and install:

  ```commandline
  cd ~/path/to/your/repositories
  git clone git@github.com:CSI-Cancer/csi_images.git
  pip install ./csi_images
  ```

  Alternatively, you can "editable" install the package, which will allow you to make
  changes to the package and have them reflected in your environment without reinstalling:

  ```commandline
  pip install -e ./csi_images
  ```

  This will add symbolic links to your `site-packages` directory instead of copying the
  package files over.


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


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


pkgId: d81a0d4e89604ac4238e607ec6412f890daeda629a4100947582d54c16967e36
name: python-cspot-help
arch: noarch
version: 1.0.14
epoch: 0
release: 1
summary: Development documents and examples for cspot
url: https://pypi.org/project/cspot/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-cspot-1.0.14-1.src.rpm
location_href: Packages/python-cspot-help-1.0.14-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/cspot)](https://pepy.tech/project/cspot)
  [![docs](https://github.com/nirmallab/cspot/actions/workflows/docs.yml/badge.svg)](https://github.com/nirmallab/cspot/actions/workflows/docs.yml)
  [![build-unix-mac-win](https://github.com/nirmallab/cspot/actions/workflows/build-unix-mac-win.yml/badge.svg)](https://github.com/nirmallab/cspot/actions/workflows/build-unix-mac-win.yml)


  Kindly note that **CSPOT is not a plug-and-play solution**. It's a framework that requires significant upfront investment of time from potential users for training and validating deep learning models, which can then be utilized in a plug-and-play manner for processing large volumes of similar multiplexed imaging data.



  **Hardware :**
  `CSPOT` comprises two modules: training and prediction. Training can be efficiently executed on a standard laptop without the need for a GPU. However, for predictions, leveraging a GPU significantly enhances processing speed (particularly for large images).

  **Software :**
  This package is supported for Windows (10, 11), macOS (Sonoma, Ventura) and Linux (Ubuntu 16.04).

  **Dependencies :**
  The `pyproject.toml` file contains a comprehensive list of dependencies.



  **There are two ways to set it up based on how you would like to run the program**
  - Using an interactive environment like Jupyter Notebooks
  - Using Command Line Interface

  Before we set up CSPOT, we highly recommend using a environment manager like Conda. Using an environment manager like Conda allows you to create and manage isolated environments with specific package versions and dependencies.

  **Download and Install the right [conda](https://docs.conda.io/en/latest/miniconda.html) based on the opertating system that you are using**



  ```

  conda create --name cspot -y python=3.9
  conda activate cspot
  ```

  **Install `cspot` within the conda environment.**

  ```
  pip install cspot
  ```
  The installation time for `cspot` generally falls under 5 minutes, based on internet speed and connectivity.


  Using IDE or Jupyter notebooks

  ```python
  pip install notebook


  import cspot as cs

  ```


  ```
  wget https://github.com/nirmalLab/cspot/archive/main.zip
  unzip main.zip
  cd cspot-main/cspot


  ```


  ```
  docker pull nirmallab/cspot:cspot

  ```


pkgId: 2ac0b66673f5fc9fd5b3922d5a5c3eb593173528bdca33a0805e5627df864c75
name: python-csvpath-help
arch: noarch
version: 0.0.501
epoch: 0
release: 1
summary: Development documents and examples for csvpath
url: https://pypi.org/project/csvpath/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-csvpath-0.0.501-1.src.rpm
location_href: Packages/python-csvpath-help-0.0.501-1.noarch.rpm
checksum_type: sha256
description:
  The CsvPath language defines a declarative syntax for inspecting and validating CSV and Excel files, and other tabular data.

  The CsvPath library's goal is to make it easy to setup a <a href='https://www.atestaanalytics.com/s/The-Collect-Store-Validate-Pattern-Atesta-Analytics.pdf'>Collect, Store, Validate Pattern</a> flat-file landing zone that:
  - Registers files
  - Validates that the data matches expectations
  - Reports on content validity and other metadata
  - Shapes files for consistency using copy-on-write
  - And stages the results for loading into a data lake

  And does it all in an automation-friendly way.

  CsvPath's validation is inspired by:
  - XPath for XML files
  - The ISO standard <a href='https://schematron.com/'>Schematron validation</a>

  CsvPath is intended to fit with other DataOps and data quality tools. Files are streamed. The interface is simple. Metadata is plentiful. New functions are easy to create. CsvPath can stream events to an OpenLineage server, such as the open source Marquez server.

  <a href='https://openlineage.io' >
  <img target='_blank' src="https://github.com/csvpath/csvpath/blob/main/docs/images/openlineage-logo-sm.png" alt="OpenLineage"/></a>
  <a href='https://peppy-sprite-186812.netlify.app/' >
  <img target='_blank' src="https://github.com/csvpath/csvpath/blob/main/docs/images/marquez-logo-sm.png" alt="Marquez Server"/></a>


  Read more about CsvPath and see CSV, Excel, and Data Frames validation examples at <a href='https://www.csvpath.org'>https://www.csvpath.org</a>.

  If you need help, use the <a href='https://www.csvpath.org/getting-started/get-help'>contact form</a> or the <a href='https://github.com/csvpath/csvpath/issues'>issue tracker</a> or talk to one of our [sponsors, below](#sponsors).

  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/csvpath?logoColor=green&color=green) ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/dk107dk/csvpath) ![PyPI - Version](https://img.shields.io/pypi/v/csvpath)




  - [Motivation](#motivation)
  - [Install](#install)
  - [High-level Description](#description)
  - [Running CsvPath](#running)
     - [Validation](#validating)
     - [Creating new files](#newfiles)
  - [Comments](#top-comments)
  - [Scanning](#scanning)
  - [Matching](#matching)
     - [Match Components](#components)
        - [Terms](#terms)
        - [Functions](#functions)
        - [Headers](#headers)
        - [Variables](#variables)
        - [Equalities](#equalities)
        - [References](#references)
     - [Comments Within Match](#comments)
     - [The When Operator](#when)
     - [Qualifiers](#qualifiers)
     - [Error Handling](#errors)
  - [More Examples](#examples)
  - [Grammar](#grammar)
  - [Sponsors](#sponsors)

  <a name="motivation"></a>


  CSV files are everywhere!

  The majority of companies depend on file processing for significant revenue operations. Research organizations and archives are awash in CSVs. And everyone's favorite issue tracker, database GUI, spreadsheet, APM platform, and most any other type of tool we use spits out CSV or Excel files for sharing. Delimited and tabular files are the lowest of common dominators. Many are invalid or broken in some way. Often times a lot of manual effort goes into finding problems and fixing them.

  CsvPath is first and foremost a validation language. It describes tabular data in simple declarative rules that define what valid means for that data. CsvPath can also extract and shape data and create reports.

  The CsvPath library implements the CsvPath language, but goes far beyond it to provide a full <a href='https://www.atestaanalytics.com/s/The-Collect-Store-Validate-Pattern-Atesta-Analytics.pdf'>Collect, Store, Validate Pattern</a> framework for landing flat files, registering them, validating them, shaping them to a consistent and comparable form, and staging them for a data lake. In that way, CsvPath fills the gap commonly found between an organization's MFT (managed file transfer) and a typical data lake architecture.

  CsvPath's goal is to make simple validations almost trivial and more complex situations more manageable. It is a library and framework, not a system, so it relies on being easy to integrate with other DataOps tools.


  <a name="install"></a>


  <a href='https://pypi.org/project/csvpath/'>CsvPath is available on PyPi</a>. Install with
  ```
      pip install csvpath
  ```

  CsvPath has two optional dependencies:

  - <a target='_blank' href='https://pypi.org/project/pandas/'>Pandas</a>
  - <a target='_blank' href='https://pypi.org/project/smart-open/'>Smart-open</a>

  Pandas data frames can be used as a data source, much like Excel or CSV files. Install CsvPath with the Pandas option:
  ```
      pip install csvpath[pandas]
  ```

  Smart-open is an option for loading data files directly from S3. Install the Smart Open extra with:
  ```
      pip install csvpath[smart-open]
  ```

  Both of these optional dependencies can make it harder to use CsvPath in certain specific use cases. For e.g., using Pandas in an AWS Lambda layer may be less straightforward. If you need the capabilities, they are easy to install, but if you don't CsvPath is lighter weight without.



  <a name="description"></a>

  CsvPath paths have three parts:
  - a "root" file name
  - a scanning part
  - a matching part

  The root of a csvpath starts with `$`. The match and scan parts are enclosed by brackets. Newlines are ignored.

  A very simple csvpath might look like this:

  ```bash
      $filename[*][yes()]
  ```

  This csvpath says open the file named `filename`, scan all the lines, and match every line scanned.

  A slightly more functional csvpath could look like this:

  ```bash
      $people.csv[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This csvpath reads `people.csv`, counting the people without a middle name and printing the result after the last row is read.

  A csvpath doesn't have to point to a specific file. As shown above, it can point to a specific file or it can instead use a logical name associated with a physical file or have no specific file indicator.

  ```bash
      $[*][
          @two_names = count(not(#middle_name))
          last() -> print("There are $.variables.two_names people with only two names")]
  ```

  This version of the example has its file chosen at runtime.

  See [more examples in this documentation](#examples). There are also <a href='https://www.csvpath.org'>lots more examples on csvpath.org</a>.

  There is no limit to the amount of functionality you can include in a single csvpath. However, different functions run with their own performance characteristics. You should plan to test both the performance and functionality of your paths.

  CsvPath was conceived as a data testing and extraction tool. Running it in production typically involves testing the paths in advance and automating the runs. There is a simple <a href='https://github.com/csvpath/csvpath/cli'>command line interface</a> that you can use to create and test csvpaths. You can <a href='https://www.csvpath.org/getting-started/your-first-validation-the-lazy-way'>read more about the CLI here</a>.

  <a name="running"></a>


  CsvPath is <a href='https://pypi.org/project/csvpath/'>available on Pypi here</a>. The <a href='https://github.com/csvpath/csvpath'>git repo is here</a>.

  Two classes provide the functionality: CsvPath and CsvPaths. Each has only a few external methods.


  (<a href='https://github.com/csvpath/csvpath/blob/main/csvpath/csvpath.py'>code</a>)
  The CsvPath class is the basic entry point for running csvpaths.
  |method                      |function                                                         |
  |----------------------------|-----------------------------------------------------------------|
  | next()                     | iterates over matched rows returning each matched row as a list |
  | fast_forward()             | iterates over the file collecting variables and side effects    |
  | advance()                  | skips forward n rows from within a `for row in path.next()` loop|
  | collect()                  | processes n rows and collects the lines that matched as lists   |


  (<a href='https://github.com/dk107dk/csvpath/blob/main/csvpath/csvpaths.py'>code</a>)
  The CsvPaths class helps you manage validations of multiple files and/or multiple csvpaths. It coordinates the work of multiple CsvPath instances.
  |method                  |function                                                         |
  |------------------------|-----------------------------------------------------------------|
  | csvpath()              | gets a CsvPath object that knows all the file names available   |
  | collect_paths()        | Same as CsvPath.collect() but for all paths sequentially        |
  | fast_forward_paths()   | Same as CsvPath.fast_forward() but for all paths sequentially   |
  | next_paths()           | Same as CsvPath.next() but for all paths sequentially           |
  | collect_by_line()      | Same as CsvPath.collect() but for all paths breadth first       |
  | fast_forward_by_line() | Same as CsvPath.fast_forward() but for all paths breadth first  |
  | next_by_line()         | Same as CsvPath.next() but for all paths breadth first          |

  To be clear, the purpose of `CsvPaths` is to apply multiple csvpaths per CSV file. Its breadth-first versions of the `collect()`, `fast_forward()`, and `next()` methods attempt to match each csvpath to each row of a CSV file before continuing to the next row. As you can imagine, for very large files this approach can be a big win.

  There are several ways to set up CSV file references. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/files.md'>more about managing CSV files</a>.

  You also have important options for managing csvpaths. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about named csvpaths here</a>.

  The simplest way to get started is using the CLI. <a href='https://www.csvpath.org/getting-started/your-first-validation-the-lazy-way'>Read about getting started with the CLI here</a>.

  When you're ready to think about automation, you'll want to start with a simple driver. This is a very basic programmatic use of CsvPath.

  ```python
      path = CsvPath().parse("""
              $test.csv[5-25][
                  
                  @lastname.onmatch = "Bat"
                  count() == 2
              ]
      """)

      for i, line in enumerate( path.next() ):
          print(f"{i}: {line}")
      print(f"The varibles collected are: {path.variables}")
  ```

  The csvpath says:
  - Open test.csv
  - Scan lines 5 through 25
  - Match the second time we see a line where the first header equals `Frog` and set the variable called  `lastname` to "Bat"

  Another path that does the same thing a bit more simply might look like:

  ```bash
      $test[5-25][
          
          @lastname.onmatch = "Bat"
          count()==2 -> print( "$.csvpath.match_count: $.csvpath.line")
      ]
  ```

  In this case, we're using the "when" operator, `->`, to determine when to print.

  For lots more ideas see the unit tests and [more examples here](#examples).

  There are a small number of configuration options. Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/config.md'>more about those here</a>.



  Before we get into the details of scanning and matching, let's look at what CsvPath can print. The `print` function has several important uses, including:

  - Validating CSV files
  - Debugging csvpaths
  - Creating new CSV files based on an existing file

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/printing.md'>read more about the mechanics of printing here</a>.

  <a name="validating"></a>


  CsvPath paths can be used for rules based validation. Rules based validation checks a file against content and structure rules but does not validate the file's structure against a schema. This validation approach is similar to XML's Schematron validation, where XPath rules are applied to XML.

  There is no "standard" way to do CsvPath validation. The simplest way is to create csvpaths that print a validation message when a rule fails. For example:

  ```bash
      $test.csv[*][@failed = equals(#firstname, "Frog")
                   @failed.asbool -> print("Error: Check line $.csvpath.line_count for a row with the name Frog")]
  ```

  Several rules can exist in the same csvpath for convenience and/or performance. Alternatively, you can run separate csvpaths for each rule. You can read more <a href='https://github.com/dk107dk/csvpath/blob/main/docs/paths.md'>about managing csvpaths here</a>.

  <a name="newfiles"></a>


  Csvpaths can also use the `print` function to generate new file content on system out. Redirecting the output to a file is an easy way to create a new CSV file based on an existing file. For e.g.

  ```bash
      $test.csv[*][ line_count()==0 -> print("lastname, firstname, say")
                    above(line_count(), 0) -> print("$.headers.lastname, $.headers.firstname, $.headers.say")]
  ```

  This csvpath reorders the headers of the test file at `tests/test_resources/test.csv`. The output file will have a header row.

  <a name="top-comments"></a>

  CsvPaths have file scanning instructions, match components, and comments. Comments exist at the top level, outside the CsvPath's brackets, as well as in the matching part of the path. Comments within the match part are covered below.

  As well as documentation, comments outside the csvpath can:
  - Contribute to a collection of metadata fields associated with a csvpath
  - Switch on/off certain validation settings
  - Set the identity of a csvpath within a group of csvpaths

  A comment starts and ends with a `~` character. Within the comment, any word that has a colon after it is considered a metadata key. The metadata value is anything following the key up till a new metadata key word is seen or the comment ends.

  For example, this comment says that the csvpath has the name `Order Validation`:

  ```bash
      ~ name: Order Validation
        developer: Abe Sheng
      ~
      $[*][ count(#order) == 10 ]
  ```

  The name `Order Validation` is available in CsvPath's `metadata` property along with the developer's name. You can use any metadata keys you like. All the metadata is available during and after a run, giving you an easy way to name, describe, attribute, etc. your csvpaths.

  You can <a href='https://github.com/dk107dk/csvpath/blob/main/docs/comments.md'>read more about comments and metadata here</a>.

  <a name="scanning"></a>


  The scanning part of a csvpath enumerates selected lines. For each line returned, the line number, the scanned line count, and the match count are available. The set of line numbers scanned is also available.

  The scan part of the path starts with a dollar sign to indicate the root, meaning the file from the top. After the dollar sign comes the file path. The scanning instructions are in a bracket. The rules are:
  - `[*]` means all
  - `[3*]` means starting from line 3 and going to the end of the file
  - `[3]` by itself means just line 3
  - `[1-3]` means lines 1 through 3
  - `[1+3]` means lines 1 and line 3
  - `[1+3-8]` means line 1 and lines 3 through eight

  <a name="matching"></a>


  The match part is also bracketed. Matches have space separated components or "values" that are ANDed together. The components' order is important. A match component is one of several types:

  - Term
  - Function
  - Variable
  - Header
  - Equality
  - Reference

  <a name="Components"></a>
  <a name="terms"></a>

  A string, number, or regular expression value.

  |Returns | Matches     | Examples        |
  |--------|-------------|-----------------|
  |A value | Always true | `"a value"`     |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/terms.md'>Read about terms here</a>.

  <a name="functions"></a>

  A composable unit of functionality called once for every row scanned.

  |Returns    | Matches    | Examples      |
  |-----------|------------|---------------|
  |Calculated | Calculated | `count()`     |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>Read about functions here</a>.

  <a name="variables"></a>

  A stored value that is set or retrieved once per row scanned.

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | True when set. (Unless the `onchange` qualifier is used). Alone it is an existence test. | `@firstname` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/variables.md'>Read about variables here</a>.

  <a name="headers"></a>

  A named header or a header identified by 0-based index.
  _(CsvPath avoids the word "column" for reasons we'll go into later in the docs)._

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |A value | Calculated. Used alone it is an existence test. | `#area_code` |

  <a href='https://github.com/dk107dk/csvpath/blob/main/docs/headers.md'>Read about headers here</a>.

  <a name="equalities"></a>

  Two of the other types joined with an "=" or "==".

  |Returns | Matches | Examples      |
  |--------|---------|---------------|
  |Calculated | True at assignment, otherwise calculated. | `#area_code == 617` |

  <a name="references"></a>

  References are a way of pointing to data generated by other csvpaths. Referenced data is held by a CvsPaths instance. It is stored in its named-results. The name is the one that identified the paths that generated it.

  References can point to:
  - Variables
  - Headers

  The form of a reference is:

  ```bash
      $named_path.variables.firstname
  ```

  This reference looks in the results named for its CSV file. The qualifier `variables` indicates the value is a variable named `firstname`.

  |Returns    | Matches                                   | Examples               |
  |-----------|-------------------------------------------|------------------------|
  |Calculated | True at assignment, otherwise calculated. | `@q = $orders.variables.quarter` |


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/references.md'>more about references here</a>.


  <a name="comments"></a>


  You can comment out match components by wrapping them in `~`. Comments can be multi-line. At the moment the only limitations are:

  - Comments cannot include the `~` (tilde) and `]` (right bracket) characters
  - Comments cannot go within match components, only between them

  Examples:

  ```bash
      [ count() ~this is a comment~ ]
  ```

  ```bash
      [    ~this csvpath is
            just for testing.
            use at own risk~
         any()
      ]
  ```

  <a name="when"></a>


  `->`, the "when" operator, is used to act on a condition. `->` can take an equality, header, variable, or function on the left and trigger an assignment or function on the right. For e.g.

  ```bash
      [ last() -> print("this is the last line") ]
  ```

  Prints `this is the last line` just before the scan ends.

  ```bash
      [ exists(#0) -> @firstname = #0 ]
  ```

  Says to set the `firstname` variable to the value of the first column when the first column has a value. (Note that this could be achieved other simpler ways, including using the `notnone` qualifier on the variable.)

  <a name="qualifiers"></a>


  Qualifiers are tokens added to variable, header, and function names. They are separated from the names and each other with `.` characters. Each qualifier causes the qualified match component to behave in a different way than it otherwise would.

  Qualifiers are quite powerful and deserve a close look. <a href='https://github.com/dk107dk/csvpath/blob/main/docs/qualifiers.md'>Read about qualifiers here.</a>

  <a name="errors"></a>


  The CsvPath library handles errors according to policies set for the CsvPath and CsvPaths classes. Each class can have multiple approaches to errors configured together. The options are:
  - Collect - an error collector collects errors for later inspection
  - Raise - an exception is (re)raised that may halt the CsvPath process
  - Stop - the CsvPath instance containing the offending problem is stopped; any others continue
  - Fail - the CsvPath instance containing the offending problem is failed; processing continues
  - Quiet - minimal error information is logged but otherwise handling is quiet

  Raise and quiet are not useful together, but the others combine well. You can set the error policy in the config.ini that lives by default in the ./config directory.

  Because of this nuanced approach to errors, the library will tend to raise data exceptions rather than handle them internally at the point of error. This is particularly true of matching, and especially the functions. When a function sees a problem, or fails to anticipate a problem, the exception is bubbled up to the top Expression within the list of Expressions held by the Matcher. From there it is routed to an error handler to be kept with other results of the run, or an exception is re-raised, or other actions are taken.


  <a name="examples"></a>


  There are more examples scattered throughout the documentation. Good places to look include:

  - Here are a few <a href='https://github.com/dk107dk/csvpath/blob/main/docs/examples.md'>more real-looking examples</a>
  - Try the Getting Started examples on <a href="https://www.csvpath.org">https://www.csvpath.org</a>
  - The individual <a href='https://github.com/dk107dk/csvpath/blob/main/docs/functions.md'>function descriptions</a>
  - The <a href='https://github.com/dk107dk/csvpath/tree/main/tests'>unit tests</a> and <a href='https://github.com/dk107dk/csvpath/tree/main/tests/grammar/match'>their match parts</a> are not realistic, but a good source of ideas.

  To create example CsvPaths from your own data, try <a href='https://autogen.csvpath.org'>CsvPath AutoGen</a>. The huge caveat is that AutoGen uses AI so your results will not be perfect. You will need to adjust, polish, and test them.

  <a name="grammar"></a>


  Read <a href='https://github.com/dk107dk/csvpath/blob/main/docs/grammar.md'>more about the CsvPath grammar definition here</a>.


  <a name="more-info"></a>


  Visit <a href="https://www.csvpath.org">https://www.csvpath.org</a>

  <a name="sponsors"></a>


  <a href='https://www.atestaanalytics.com/' >
  <img width="25%" src="https://raw.githubusercontent.com/dk107dk/csvpath/main/docs/images/logo-wordmark-white-on-black-trimmed-padded.png" alt="Atesta Analytics"/></a>
      <a href='https://www.datakitchen.io/'>
  <img src="https://datakitchen.io/wp-content/uploads/2020/10/logo.svg"
  style='width:160px; position:relative;bottom:-5px;left:15px' alt="DataKitchen" id="logo" data-height-percentage="45"></a>


