# packages

pkgId: ae244cd0201ead5168ead6cefa5f87df3efe7a99eac30a35ff0d6d70f63ea6cc
name: python-criteo-marketing
arch: src
version: 1.0.171
epoch: 0
release: 1
summary: Marketing API v.1.0
url: https://github.com/criteo/criteo-python-marketing-sdk
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-criteo-marketing-1.0.171-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/pyversions/criteo-marketing.svg)](https://pypi.org/project/criteo-marketing/)

  IMPORTANT: This Python package links to Criteo production environment. Any test applied here will thus impact real campaigns.



  Python 2.7 and 3.5+





  ```sh
  pip install criteo_marketing
  ```
  (you may need to run `pip` with root permission: `sudo pip install criteo_marketing`)

  Then import the package:
  ```python
  import criteo_marketing
  ```

  Full documentation on [Github](https://github.com/criteo/criteo-python-marketing-sdk).



  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: a4694244398dd006561d29d1e6638b7a7a604159e4632cda9c605484b5102e2f
name: python-criteo-marketing-transition
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Criteo Marketing Transition SDK
url: https://github.com/criteo/criteo-python-marketing-transition-sdk
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-criteo-marketing-transition-1.0.3-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/pyversions/criteo-marketing.svg)](https://pypi.org/project/criteo-marketing-transition/)

  IMPORTANT: This Python package links to Criteo production environment. Any test applied here will thus impact real data.



  Python 2.7 and 3.5+





  ```sh
  pip install criteo_marketing_transition
  ```
  (you may need to run `pip` with root permission: `sudo pip install criteo_marketing_transition`)

  Then import the package:
  ```python
  import criteo_marketing_transition
  ```

  Full documentation on [Github](https://github.com/criteo/criteo-python-marketing-transition-sdk).



  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: 5772177744979ff485183a8dff7d689270d8363d4a2de7e1d50e0ad690c21455
name: python-criteria
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: Deep learning loss functions and models for image similarity
url: https://github.com/minha12/criteria
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-criteria-0.1.2-1.src.rpm
checksum_type: sha256
description:
  A Python package that provides various perceptual similarity metrics for comparing images using state-of-the-art models including Face Recognition Systems (FRS), CLIP, and LPIPS.



  - Face Recognition System (FRS) based identity loss with multiple model options:
    - IR-152
    - IR-SE-50
    - MobileFaceNet
    - FaceNet
    - CurricularFace
  - CLIP-based similarity metrics
  - LPIPS (Learned Perceptual Image Patch Similarity)
  - Ensemble ID loss for combining multiple FRS models



  ```bash
  pip install criteria
  ```





  ```python
  from criteria import id_loss
  from PIL import Image


  id_loss_fn = id_loss.IDLoss(model_name='ir_se50')


  img1 = Image.open('image1.jpg')
  img2 = Image.open('image2.jpg')


  loss = id_loss_fn(img1, img2)
  ```



  ```python
  from criteria import clip_loss


  clip_loss_fn = clip_loss.CLIPLoss()


  similarity = clip_loss_fn(img1, img2)
  ```



  ```python
  from criteria import lpips_loss


  lpips_fn = lpips_loss.LPIPSLoss()


  distance = lpips_fn(img1, img2)
  ```



  Pre-trained model weights will be automatically downloaded when initializing the respective loss functions.



  MIT License



  If you use this package in your research, please cite:

  ```bibtex
  @misc{criteria2023,
    author = {Le, Minh-Ha},
    title = {Criteria: Image Similarity Metrics},
    year = {2023},
    publisher = {GitHub},
    url = {https://github.com/username/criteria}
  }
  ```


pkgId: dabd8abc45f8345ee5a426cc68cc255fe5db0a2a1910522f86605bf4b9bd3e54
name: python-criticalpath
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Calculates the critical path in a task network.
url: https://github.com/chrisspen/criticalpath
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-criticalpath-0.1.5-1.src.rpm
checksum_type: sha256
description:
  [![](https://img.shields.io/pypi/v/criticalpath.svg)](https://pypi.python.org/pypi/criticalpath) [![Build Status](https://img.shields.io/travis/chrisspen/criticalpath.svg?branch=master)](https://travis-ci.org/chrisspen/criticalpath)
  Calculates the
  [critical path](http://en.wikipedia.org/wiki/Critical_path_method)
  through a network of tasks.
  Assumes the given graph is acyclic (has no loops).
  A task network is composed of nodes, but it's also organized within
  a parent node. This allows my node/task model to support recursive nesting
  of tasks. e.g. An overall "project" node containing multiple tasks can be
  treated as a single task in itself, and therefore included in more abstract
  task groupings.


pkgId: 18025b8acb790fabd06bba2c29b020a718b0bf08f0ae281203ee6698f815c2d1
name: python-crl-datacube
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: Utilities for scaling geospatial analyses
url: https://pypi.org/project/crl-datacube/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crl-datacube-0.1.17-1.src.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: c403014708e0ddeae8eec393a19c05ed3756548ea50b51788df914b21e73b8e2
name: python-crlibm
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: Python bindings for CRlibm, an efficient and proven correctly-rounded mathematical library
url: https://github.com/taschini/pycrlibm
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crlibm-1.0.3-1.src.rpm
checksum_type: sha256
description:
  Python bindings for `CRlibm
  <http://lipforge.ens-lyon.fr/www/crlibm>`_, an efficient and proven
  correctly-rounded mathematical library.
  CRlibm is a free mathematical library (libm) which provides:
  * implementations of the double-precision C99 standard elementary
    functions,
  * correctly rounded in the four IEEE-754 rounding modes,
  * with a comprehensive proof of both the algorithms used and their
    implementation,
  * sufficiently efficient in average time, worst-case time, and
    memory consumption to replace existing libms transparently.


pkgId: 37bea0914165c589324fba12c464d81e03ba32c015943c8b71bbbc926886d96e
name: python-crllm
arch: src
version: 0.5.0
epoch: 0
release: 1
url: https://lukasrump.github.io/crllm/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crllm-0.5.0-1.src.rpm
checksum_type: sha256
summary:
  Provides AI-powered code reviews using local or cloud-based Large Language Models (LLMs) to help developers improve code quality and catch bugs efficiently.

description:
  **Effortlessly Get Code Reviews from Large Language Models!**

  CRLLM is a powerful command-line tool that enables developers to get code reviews from state-of-the-art Large Language Models (LLMs). Whether you want to use Ollama for locally running LLMs or connect to cloud services like ChatGPT, Hugging Face, and Azure, CRLLM has you covered. Improve your code quality, catch potential bugs, and receive AI-driven suggestions to enhance your development workflow. Get recommendations on best practices, bug-prone areas, and potential refactoring.
  Learn from the suggestions how to improve your code, gaining new insights and techniques. Reduce the need for back-and-forth during human code reviews by catching more issues upfront.



  - **Flexible LLM Options**: Use Ollama to run models locally or leverage APIs from cloud providers like OpenAI, Hugging Face, and Azure.
  - **Comprehensive Code Review**: Get quality feedback on code, including recommendations for readability, efficiency, and best practices.
  - **Developer Productivity**: Integrate seamlessly into your existing development environment to speed up code review processes.
  - **Privacy Control**: Choose between local or cloud-based solutions depending on your privacy needs and computational power.
  - **Multi-Language Support**: Review code written in various programming languages (e.g., Python, JavaScript, Java, etc.).
  - **Git Support**: Get Reviews for your Git changes or differences between branches.



  To get started with crllm, follow these simple installation steps:



  - **Python 3.8+**: Make sure you have Python installed.
  - **pipx**: https://pipx.pypa.io/stable/installation/
  - **ollama**: https://ollama.com/download
  If you want to run the modells locally otherwise you will need the corresponding API keys for your provider




  ```sh
  pipx install git+https://github.com/lukasrump/crllm.git
  ```


  ```sh
  pipx install crllm
  ```


  CRLLM supports multiple backends for LLM code reviews. You can configure it by adding an configuration file `crllm_config.toml` in the root of your project. To initialize your project you can use

  ```bash
  crllm -i .
  ```

  This command guides you through the most important settings.
  This TOML configuration file is splitted in four main sections:


  - **`description`**: Short project summary.


  - **`loader`**: Mechanism to load the source code, `"git"` by default.
  - **`provider`**: LLM provider, `"ollama"`by default.
  - **`git_main_branch`**: Specifies the main git branch, default is `"main"`.
  - **`git_changed_lines`**: If `true`, only reviews changed lines.


  - **file**: Code review for a single source code file
  - **git**: Reviews all changed files in the git repository
  - **git_compare**: Reviews the difference between the current git branch and the `git_main_branch`


  The model settings depend on the provider. The model settings are the same as those of the [LangChain](https://python.langchain.com/docs/integrations/chat/) ChatModels. Per default crllm tries to use a locally installed ollama instance with llama3.1.


  - **`model`**: Specifies the model to use, e.g `"llama3.1"`. Make sure that you pulled that model before you use it.


  - **`model`**: Specifies the model to use, e.g `"gpt-4o"`.

  In addition you have to define the api key in your environment (`.env`)
  ```
  OPENAI_API_KEY=your_openai_api_key
  ```

  - **`repo_id`**: Specifies the repository to use, e.g `"HuggingFaceH4/zephyr-7b-beta"`.
  - **`task`**: Specifies the task, e.g `"text-generation"`.

  ```
  HUGGINGFACEHUB_API_TOKEN=your_huggingface_api_key
  ```


  - **`azure_deployment`**: Specifies the deployment to use, e.g `"gpt-35-turbo"`.
  - **`api_version`**: Specifies the api version to use, e.g `"2023-06-01-preview"`.

  In addition you have to define some variables in your environment (`.env`)

  ```
  AZURE_OPENAI_API_KEY=your_azure_api_key
  AZURE_OPENAI_ENDPOINT=https://your-endpoint.openai.azure.com
  ```


  - **`template`**: Override the prompt template that is used (optional).


  CRLLM is designed to be easy to use right from your terminal. Below are some examples of how you can leverage the tool.

  To perform a code review for a file or GIT repository run:
  ```sh
  crllm path/to/your/codefile.py
  ```



  To enhance code reviews with source context, enable RAG (Retrieval-Augmented Generation) in `crllm_config.toml`:

  ```toml
  [rag]
  enabled = true
  embedding_model = "all-minilm"      # Specify the embedding model
  src_path = "./"                     # Define the root path of your source code
  src_glob = "**/*.py"                # Use glob patterns to match source files (e.g., Python files)
  ```


  CRLLM supports a `.crllm_ignore` file to exclude specific files and directories from code reviews. This is similar to `.gitignore` but specific to CRLLM's code review process.


pkgId: 98c2324fd694ba5e072fe6776f90d6db3360d7006ae838e6f91455143e39944f
name: python-crm1
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A CRM-1 repository exploration package
url: https://github.com/J0J0HA/py-crm1
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crm1-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This package is a Python implementation of the CRM-1 specification.

  You can find the specification [here](https://github.com/CRModders/CRM-1/).



  You can install the package using pip:

  ```bash
  pip install crm1
  ```



  ```python
  """Usage example for the crm1 module."""

  from crm1 import Repository, RepositoryPool, autorepo, make_pool


  repo1 = Repository("https://crm-repo.jojojux.de/repo.json")
  repo2 = "https://repo.crmodders.dev/repository.hjson"


  pool = RepositoryPool()
  pool.add_repository(repo1)


  pool.add_repository(repo2)


  repos = autorepo.get_all_repos()

  pool2 = make_pool(repos)


  mod = pool.get_mod("dev.crmodders.flux")
  print(mod.meta.name)  # This will print "Flux API", the mods name

  print(mod.meta.ext.changelog) # The mod.meta.ext attribute holds the CommonModExt object, which add typing and docs to commonly used fileds the mod.ext dict.




  mod2 = pool.get_mod("com.nikrasoff.seamlessportals")


  for dep in mod2.depends:
      dep.id = "dev.crmodders.flux"  # Ignore this line, this is required because the de.jojojux.crm-repo repository has a bug, see https://github.com/J0J0HA/CRM-1-Autorepo/issues/6
      print(dep.mod)  # This will print None, because the dependency was not yet resolved
      
      print(
          dep.resolve(pool)
      )  # This will print the mod object, as it is returned by the resolve method, but is also stored in the dependency object at dep.mod
      
      print(
          dep.mod.meta.name
      )  # This will print the name of the mod, in this case "Flux API". If the dependency could not be resolved, the dep.mod attribute will still be None

  ```

  Everything is typed and documented, so you can use your IDE's autocomplete and documentation features to explore the functionality of the package.





  The ```helpers.versions``` module provides classes to work with versions and version ranges.

  ```python
  from crm1.helpers.versions import Version, VersionRange, range_from_maven_string


  range1 = VersionRange.from_string("[1.0,2.0.1)")
  print(range1.lower, range1.lower_mode)

  print(range1.upper, range1.upper_mode)


  range2 = VersionRange.from_string("(1.0,]")
  print(range2.lower, range2.lower_mode)

  print(range2.upper, range2.upper_mode)


  vers1 = Version.from_string("1.0")
  vers2 = Version.from_string("2.0.1")
  vers3 = Version.from_string("20.1")

  print(vers1 in range1)

  print(vers2 in range1)

  print(vers3 in range1)

  print(vers1 in range2)

  print(vers2 in range2)

  print(vers3 in range2)



  print(str(range_from_maven_string(">=1.0")))

  print(str(range_from_maven_string(">1.0")))

  print(str(range_from_maven_string("<1.0")))

  print(str(range_from_maven_string("<=1.0")))

  print(str(range_from_maven_string("1.0")))

  print(str(range_from_maven_string("*")))

  ```



  This package is licensed under the MIT license. You can find the full license text in the [LICENSE](LICENSE) file.


pkgId: 6e1070f2c4fa31903985471df20d4359eedc69da3b470d83d363dffde5a7cd06
name: python-crms
arch: src
version: 2023.5.3.1340
epoch: 0
release: 1
summary: Cloud Robot Model Sharing Middleware
url: https://github.com/jangcs/crms
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crms-2023.5.3.1340-1.src.rpm
checksum_type: sha256
description:
  * (0.1) PIP3 must be prepared.
  ```sh
  sudo apt-get update -y
  sudo apt-get install python3-pip
  ```
  * (0.2) Git must be prepared and configured
  ```sh
  sudo apt-get install git
  git config --global user.name “Your Name”
  git config --global user.email your-email@xxx.com
  ```

  * (1.1) Download https://cloud.google.com/sdk/docs/install (Linux 64-bit package)
  * (1.2) Extract the downloaded package to ~/google-cloud-sdk
  ```sh
  tar -xf google-cloud-cli-395.0.0-linux-x86_64.tar.gz
  ```
  * (1.3) Add path to .bashrc
  ```sh
  ./google-cloud-sdk/install.sh
  ```
  * (1.4) Setup Google Credential
      * Download Google Credential file (contact administrator of your Google Cloud Project)
          * Access permission of credential may be one of reading or writing (writing permission is necessary for a full test)
          * In case of reading permission, crms push command is not allowed (crms list/desc/pull commands are allowed)
      * Default credential for the reader of google cloud robot project is cloudrobotai-reader-cred.zip
          * unzip cloudrobotai-reader-cred.zip
      * Set GOOGLE_APPLICATION_CREDENTIALS into ~/.bashrc
  ```sh
  export GOOGLE_APPLICATION_CREDENTIALS=”/path/to/<google-cloud-project-credential>.json”
  ```
  <!--
  * (1.5) bug fix of protobuf
  ```sh
  pip3 install protobuf==3.20.1
  ```
  * (1.6) dependency fix for fsspec
  ```sh
  pip3 install fsspec==2022.2.0
  ```
  -->
  * (1.5) (optional) Set an environment variable (CRMS_META_REPOSITORY) for Google Firestore (Default='croudrobotai')
  ```sh
  export CRMS_META_REPOSITORY=your-google-cloud-project
  ```

  * (2.0) pip upgrade is required before install crms
  ```sh
  pip3 install --upgrade pip
  [reboot if necessary, and try to install again]
  ```
  * (2.1) For full test : Download crms from Github and install with pip3
  ```sh
  git clone https://github.com/jangcs/crms.git
  cd crms
  pip3 install .
  ```
  * (2.2) For just install (not for test): Install from PyPi
  ```sh
  pip3 install crms
  ```

  ```sh
  pip3 install dvc[gs]
  [reboot if necessary]
  ```
  <!--

  ```sh
  pip3 install GitPython
  pip3 install firebase_admin
  ```
  -->

  * (4.1) SSH key has to be generated for secure connection with github.com
  ```
  ssh-keygen
  ssh-keyscan github.com > ~/.ssh/known_hosts
  ```
  * (4.2) And, the generated SSH key has to be registered to github.com in order to push a model
      * Login github.com -> Settings/SSH and GPG keys -> [New SSH Key] Button -> Copy the contents of ~/.ssh/id_rsa.pub to Key box -> [Add SSH Key] Button

  * (5.1) Modify the line in test.sh, 'crms conf git@github.com:IdToBeReplaced/...' to your github account
  ```sh
  sed -i 's/IdToBeReplaced/<your_github_account>/g' test.sh
  ```
  * (5.2) Add a repository to github (ex. model_test)
      * Login github.com -> [New] Button -> Create a New Repository -> Enter a repository name(ex. model_test) -> [Create repository] Button
  * (5.3) Execute test.sh with the name of the added github repository
  ```sh
  /test.sh model_test
  ```


pkgId: d58086e1523cd1748fd98aea894ab783c16457593efc83d1f877c791794c5501
name: python-crochet
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Use Twisted anywhere!
url: https://github.com/itamarst/crochet
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crochet-2.1.1-1.src.rpm
checksum_type: sha256
description:
  Crochet is an MIT-licensed library that makes it easier to use Twisted from
  regular blocking code. Some use cases include:
  * Easily use Twisted from a blocking framework like Django or Flask.
  * Write a library that provides a blocking API, but uses Twisted for its
    implementation.
  * Port blocking code to Twisted more easily, by keeping a backwards
    compatibility layer.
  * Allow normal Twisted programs that use threads to interact with Twisted more
    cleanly from their threaded parts. For example, this can be useful when using
    Twisted as a `WSGI container`_.
  Crochet is maintained by Itamar Turner-Trauring.
    **Note:** Crochet development is pretty slow these days because mostly it **Just Works**. PyPI shows about 30,000 downloads a month, so existing users seem happy: https://pypistats.org/packages/crochet
  You can install Crochet by running::
    $ pip install crochet
  Downloads are available on `PyPI`_.
  Documentation can be found on `Read The Docs`_.
  Bugs and feature requests should be filed at the project `Github page`_.


pkgId: f3ab58a03ba97ff17c7b45f7bd52ef1699ec4e47acd01767c72e7b43a8f348b6
name: python-croco_selenium
arch: src
version: 0.1.6.post2
epoch: 0
release: 1
url: https://github.com/CrocoFactory/croco-selenium
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-croco_selenium-0.1.6.post2-1.src.rpm
checksum_type: sha256
summary:
  The package providing ways to interact with Selenium Web Driver actions, such as clicking, sending keys etc.

description:
  <a href="https://github.com/CrocoFactory"><img alt="Croco Logo" src="https://raw.githubusercontent.com/CrocoFactory/.github/main/branding/logo/bookmark_rounded.png" width="100"></a>

  [![PyPi Version](https://img.shields.io/pypi/v/croco-selenium)](https://pypi.org/project/croco-selenium/)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/croco-selenium?label=downloads)](https://pypi.org/project/croco-selenium/)
  [![License](https://img.shields.io/github/license/CrocoFactory/croco-selenium.svg)](https://pypi.org/project/croco-selenium/)
  [![Last Commit](https://img.shields.io/github/last-commit/CrocoFactory/croco-selenium.svg)](https://pypi.org/project/croco-selenium/)
  [![Development Status](https://img.shields.io/pypi/status/croco-selenium)](https://pypi.org/project/croco-selenium/)

  The package providing ways to interact with Selenium Web Driver actions, such as clicking, sending keys etc.

  - **[Bug reports](https://github.com/CrocoFactory/croco-selenium/issues)**
  - **[Actions Overview](#actions-overview)**

  When we use Selenium, it's not convenient to use WebDriverWait with its cluttered chain actions. Instead of many imports
  and instances (By, WebDriverWait, expected_conditions) you can use fast and robust actions.

  Package's source code is made available under the [MIT License](LICENSE)

  The project is made by the **[Croco Factory](https://github.com/CrocoFactory)** team



  You can use actions, by the following way.

  ```python
  from selenium.webdriver.chrome.webdriver import WebDriver
  from croco_selenium import click
  driver = WebDriver()
  click(driver, 10, '//input[@type="submit"]')
  ```

  If you don't want to pass driver every using of actions, you can create an instance of ActionPerformer

  ```python
  from selenium.webdriver.chrome.webdriver import WebDriver
  from croco_selenium import ActionPerformer
  driver = WebDriver()
  action_performer = ActionPerformer(driver)
  timeout = 10

  action_performer.send_keys(timeout, '//input[@type="password"]', 'password')
  action_performer.click(timeout, '//input[@type="submit"]')
  ```

  One of the best ways to use actions is create an instance of ChromeDriver and perform
  actions by calling methods on it. That class derived from ActionPerformer and ChromiumDriver

  ```python
  import os
  from croco_selenium import ChromeDriver, Proxy
  proxy = Proxy(host='123.89.46.72', port=8000, username='croco', password='webDriver')
  project_dir = os.path.dirname(os.path.abspath(__file__))
  extension_paths = [os.path.join(project_dir, 'extensions/metamask.crx')]

  driver = ChromeDriver(proxy=proxy, extension_paths=extension_paths)
  driver.get('https://facebook.com')
  driver.send_keys(15, '//input[@id="email"]', 'hello@world.com')
  ```


  You can perform the following [actions](#actions), using croco-selenium:

  - **[add_cookies](#add_cookies)**
  - **[click](#click)**
  - **[close_tabs](#close_tabs)**
  - **[get_element](#get_element)**
  - **[get_elements](#get_elements)**
  - **[get_element_attribute](#get_element_attribute)**
  - **[get_element_text](#get_element_text)**
  - **[send_keys](#send_keys)**
  - **[silent_send_keys](#silent_send_keys)**
  - **[switch_to_another_window](#switch_to_another_window)**
  - **[switch_to_frame](#switch_to_frame)**
  - **[switch_to_parent_frame](#switch_to_parent_frame)**
  - **[wait_for_invisibility](#wait_for_invisibility)**
  - **[wait_for_windows](#wait_for_windows)**

  And there are 3 useful [decorators](#decorators):

  - **[handle_pop_up](#handle_pop_up)**
  - **[handle_in_new_tab](#handle_in_new_tab)**
  - **[handle_new_tab](#handle_new_tab)**



  <h3 id="add_cookies">add_cookies</h3>
  Adds cookies to a current page. It takes valid string containing json, list of cookies or one cookie as dictionary.

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  cookies = '{"domain":".facebook.com","expirationDate":1689249734,"httpOnly":true,"name":"c_user","path":"/","secure":true,"value":"100083466604886"}'
  driver.get('facebook.com')
  driver.add_cookies(cookies)
  ```

  <h3 id="click">click</h3>
  Clicks on element in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()
  driver.click(timeout, '//input[@type="submit"]')
  ```

  <h3 id="close_tabs">close_tabs</h3>
  Closes all tabs in browser. It's convenient to use, when you add extensions to your browser and their windows occur with
  starting a driver.

  ```python
  import os
  from croco_selenium import ChromeDriver

  project_dir = os.path.dirname(os.path.abspath(__file__))
  extension_paths = [os.path.join(project_dir, 'extensions/metamask.crx')]

  driver = ChromeDriver(extension_paths=extension_paths)
  driver.close_tabs()
  driver.get('https://facebook.com')
  driver.send_keys(15, '//input[@id="email"]', 'hello@world.com')
  ```

  <h3 id="get_element">get_element</h3>
  Returns an element in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  element = driver.get_element(timeout, '//input[@type="submit"]')
  element.click()
  ```

  <h3 id="get_elements">get_elements</h3>
  Returns an elements in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  elements = driver.get_elements(timeout, '//input')

  for element in elements:
      element.click()
  ```

  <h3 id="get_element_attribute">get_element_attribute</h3>
  Returns an element's attribute in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  assert driver.get_element_attribute(timeout, '//input[@type="checkbox"]', 'checked')
  ```

  <h3 id="get_element_text">get_element_text</h3>
  Returns element's text in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  print(driver.get_element_text(timeout, '//h1'))
  ```

  <h3 id="send_keys">send_keys</h3>
  Sends keys in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.send_keys(timeout, '//input[@type="password"]', 'password')
  driver.click(timeout, '//input[@type="submit"]')
  ```

  <h3 id="silent_send_keys">silent_send_keys</h3>
  Sends keys with delay between characters in browser. It's convenient to use when you would like to hide your bot activity

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.silent_send_keys(timeout, '//input[@type="password"]', 'password')
  driver.click(timeout, '//input[@type="submit"]')
  ```

  <h3 id="switch_to_another_window">switch_to_another_window</h3>
  Switches to a different window from current window in browser. It's convenient to use, when you have two windows to be handled

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.silent_send_keys(timeout, '//input[@type="password"]', 'password')
  driver.click(timeout, '//input[@type="submit"]')
  driver.switch_to_another_window(timeout)

  driver.click(timeout, '//input[@type="submit"]')
  driver.switch_to_another_window(timeout)
  ```

  <h3 id="switch_to_frame">switch_to_frame</h3>
  Switches to the frame

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.switch_to_frame(timeout, '//iframe[@data-hcaptcha-widget-id]')
  driver.click(timeout, '//input[@type="submit"]')
  ```

  <h3 id="switch_to_parent_frame">switch_to_parent_frame</h3>
  Switches to the parent frame

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.switch_to_frame(timeout, '//iframe[@data-hcaptcha-widget-id]')
  driver.click(timeout, '//input[@type="submit"]')
  driver.switch_to_parent_frame()
  ```

  <h3 id="wait_for_invisibility">wait_for_invisibility</h3>
  Wait for element's invisibility in browser

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.click(timeout, '//button')
  driver.wait_for_invisibility(timeout, '//*[@id="popup"]')
  ```

  <h3 id="wait_for_windows">wait_for_windows</h3>
  Wait for occurring of number of windows

  ```python
  from croco_selenium import ChromeDriver

  timeout = 10
  driver = ChromeDriver()

  driver.wait_for_windows(timeout, 2)
  ```


  <h3 id="handle_pop_up">handle_pop_up</h3>
  Switches to another window, performs decorated function and switches back. Pop up has to be closed after performing
  decorated function.

  This decorator is usually used for browser extensions' pop-ups. Example of function performing
  a third-party Metamask connection:

  ```python
  from croco_selenium import ChromeDriver, handle_pop_up
  from selenium.common import TimeoutException

  @handle_pop_up()
  def connect(driver: ChromeDriver, password: str) -> None:
      try:
          password_xpath = '//*[@id="password"]'
          driver.send_keys(7, password_xpath, password)

          unlock_xpath = '//button[@data-testid="unlock-submit"]'
          driver.click(5, unlock_xpath)
      except TimeoutException:
          pass

      for _ in range(3):
          next_xpath = '//button[@data-testid="page-container-footer-next"]'
          driver.click(10, next_xpath, ignored_exceptions=TimeoutException)
  ```

  <h3 id="handle_in_new_tab">handle_in_new_tab</h3>
  Opens new tab, performs decorated function, closes new tab and switches back. Here is example of function performing
  getting of 2FA code from browser extension.

  ```python
  from croco_selenium import ChromeDriver, handle_in_new_tab

  @handle_in_new_tab()
  def get_code(driver: ChromeDriver, account) -> str:
      timeout = 15

      driver.get('<EXTENSION_URL>')

      code_field_xpath = '//*[contains(@class, "code")]'
      code_fields = driver.get_elements(timeout, code_field_xpath)

      code_field = code_fields[account.id]

      code = code_field.text
      return code
  ```

  <h3 id="handle_new_tab">handle_new_tab</h3>
  Performs decorated function in new tab and switches back. New tab has to be opened during performing decorated function.




  To install the package from PyPi you can use:

  ```sh
  pip install croco-selenium
  ```

  To install the package from GitHub you can use:

  ```sh
  pip install git+https://github.com/CrocoFactory/croco-selenium.git
  ```


pkgId: f38a39b9e8a5b59437acfe7e790b00bcd348f3d73ff7c88cbf40abb46cee8107
name: python-crocodile
arch: src
version: 14.0
epoch: 0
release: 1
summary: Deep Learning Framework & Workload Management For On-premise Personal Machines.
url: https://github.com/thisismygitrepo/crocodile
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crocodile-14.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">

  <a href="https://github.com/thisismygitrepo/crocodile/commits">
  <img src="https://img.shields.io/github/commit-activity/m/thisismygitrepo/crocodile" />
  </a>

  </p>



  Pythonically facilitate laborious `file management`, `distributed computing`, `scripting` and  `deep learning` workflows.



  https://user-images.githubusercontent.com/46288868/213916407-bf6300bd-3409-4a20-b71c-00374f875c7a.mp4

  With this cluster management tool, old laptops and desktops are endowed second lives as cluster workhorses to which you offset heavy computations from your little personal laptop.



  * 🧑‍💻 Repository containing the executed function is automatically zipped and copied to each remote.
  * 📁 Binary data is `sftp`'d automatically to each remote.
  * 💽💻💿 Specs of each resource is inspected and workload is distributed accordingly on the cluster.
  * 📨📩 Email Notifications. Get **optionally** notified about start and finish of your submitted jobs.
  * 🔒🔑 Resources locking. A Job can *optionally* hold the resources to itself and other submitted jobs will have to wait.
    * 🙋‍♂️🙋‍♀ ️This feature enable sending aribtrary number of jobs in one go and never worry about overwhelming the remote. Then you come later and get all results.
  * Zellij session with reasonable layout is fired automatically on each remote.



  Croshell aims at facilitating the use of Python in scripting, thus, offering an alternative to `PowerShell` & `Bash` which have absurdly complex commands that are nothing but jumble of ad-hoc developments piled over decades to save some programmers a key stroke or two. This heritage poses huge burden on the people coming into the computer science field. A full rant bashing those shells by `Brian Will` [is here](<https://www.youtube.com/watch?v=L9v4Mg8wi4U`>).

  The core rationale is:
  * No one has the time to listen to hours long tutorials on how powerful and versatile `ls` or `grep` are, let alone keeping the random syntax in mind (unless used on daily basis).
  * Python shell on the other hand, offers benign syntax and eminent readibility but it comes at the rather hefty cost of terseness, or the lack of it. For example, to make up for just `ls`, you need to import some libraries and it will eventually set you back a couple of lines of code. That's not acceptable for the simple task of listing directory contents, let alone a task of compressing a directory.
  * Crocodile comes here to make Python terser and friendlier by offering functionality for everyday use, like **file management, SSH, environment variables management, etc**. In essence, croshell to IPython is what IPython to Python shell is; that is, the basic Python shell that can only do arithmetic is turbo-boosted making it perfect for everyday errands.
  * The library, if used in coding, will fill your life with one-liners, take your code to artistic level of brevity and readability while simultaneously being more productive by typing less boilerplate lines of code that are needless to say.

  The name `crocodile` signifies the use of brute force in its implementation. The focus is on ease of use, as oppoesd to beating the existing shells in speed.
  Mind you, speed is not an issue in 99% of everyday chores.
  `Crocodile` designed carefully to be loved, learning curve cound't be flattened further.

  This package extends many native Python classes to equip you with an uneasy-to-tame power. The major classes extended are:

   * `pathlib.Path` is  extended to `P`
        * Forget about importing all the **archaic** Python libraries `os`, `glob`, `shutil`, `sys`, `zipfile` etc. `P` makes the path an object, not a lame string. `P` objects are incredibly powerful for parsing paths, *no* more than one line of code is required to do **any** operation. Take a squint at this one line file wrangler:
          * get a temporary file name
          * writes `lol` text to it
          * copy it to same location (with a suffix like `_copy1`)
          * moves it to parent directory
          * converts user home to `~`
          * zip it
          * delete it
          * touch it
          * go to its parent
          * search for all files in it and select the first one.
          * upload it to the cloud (transfer.sh)
          * open the browser with the url
          * download it (by default it goes to `~/Downloads`)
          * encrypt it with a password.
          * create a symlink to it from `~/toy`
          * resolve the symbolic link
          * calculate the checksum of the file

  ```python
  P.tmpfile().write_text("lol").copy().move("..", rel2it=True).collapseuser().zip().delete(sure=True).touch().parent.search("*", folders=False)[0].share_on_cloud()().download().encrypt(pwd="haha").symlink_from("~/toy").resolve().checksum()
  ```

  ```python
  path = P("dataset/type1/meta/images/file3.ext")
  >> path[0]  # allows indexing! makes sense, hah?
   P("dataset")
  >> path[-1]  # nifty!
   P("file3.ext")
  >> path[2:-1]  # even slicing!
   P("meta/images/file3.ext")
  ```
   * `list` is  extended to `List`
     * Forget that `for` loops exist, because with this class, `for` loops are implicitly used to apply a function to all items.
       Inevitably while programming, one will encounter objects of the same type and you will be struggling to get a tough grab on them.  `List` is a powerful structure that put at your disposal a grip, so tough, that the objects you have at hand start behaving like one object. Behaviour is ala-JavaScript implementation of ``forEach`` method of Arrays.

   * `dict` is  extended to `Struct`.
       * Combines the power of dot notation like classes and key access like dictionaries.

   * Additionally, the package provides many other new classes, e.g. `Read` and `Save`. Together with `P`, they provide comprehensive support for file management. Life cannot get easier with those. Every class inherits attributes that allow saving and loading in one line.


  Furthermore, those classes are inextricably connected. For example, globbing a path `P` object returns a `List` object. You can move back and forth between `List` and `Struct` and `DataFrame` with one method, and so on.

  * Deep Learning Modules.
    * A paradigm that facilitates working with deep learning models that is based on a tri-partite scheme:
      * HyperParameters: facilitated through `HParams` class.
      * Data: facilitated though `DataReader` class.
      * `BaseModel` is a frontend for both `TensorFlow` & `Pytorch` backends. The wrapper worked in tandem.
    * The aforementioned classes cooperate together to offer sealmess workflow during creation, training, and saving models.



  In the commandline:
  `pip install crocodile`.

  Being a thin extension on top of almost pure Python, you need to worry **not** about your venv, the package is not aggressive in requirements, it installs itself peacefully, never interfere with your other packages. If you do not have `numpy`, `matplotlib` and `pandas`, it simply throws `ImportError` at runtime, that's it.

  [comment]: # (The package is not fussy about versions either. It can though at runtime, install packages on the fly, e.g. `dill` and `tqdm` which are very lightweight libraries.)


  For `Windows` machines, run the following in elevated `PowerShell`:
  `Warning: This includes dotfiles manager that you might not want.`
  ```ps1
  Invoke-WebRequest https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/croshell.ps1 | Invoke-Expression
  ```


  That's as easy as taking candy from a baby; whenever you start a Python file, preface it with following in order to unleash the library:

  ```

  ```



  EX1: Get a list of `.exe` available in terminal.

  ```python
       P.get_env().PATH.search('*.exe').reduce(lambda x, y: x+y).print()
  ```

  EX2: Suppose you want to know how many lines of code in your repository. The procedure is to glob all `.py` files recursively, read string code, split each one of them by lines, count the lines, add up everything from all strings of code.


  To achieve this, all you need is an eminently readable one-liner.
  ```python
  P.cwd().search("*.py", r=True).read_text().split('\n').apply(len).to_numpy().sum()
  ```

  How does this make perfect sense?
  * `search` returns `List` of `P` path objects
  * `read_text` is a `P` method, but it is being run against `List` object. Behind the scenes, **responsible black magic** fails to find such a method in `List` and realizes it is a method of items inside the list, so it runs it against them and thus read all files and containerize them in another `List` object and returns it.
  * A similar story applies to `split` which is a method of strings in Python.
  * Next, `apply` is a method of `List`. Sure enough, it lives up to its apt name and applies the passed function `len` to all items in the list and returns another `List` object that contains the results.
  * `.to_numpy()` converts `List` to `numpy` array, then `.sum` is a method of `numpy`, which gives the final result.

  Methods naming convention like `apply` and `to_numpy` are inspired from the popular `pandas` library, resulting in almost non-existing learning curve.


  Please refer to [Here](<https://github.com/thisismygitrepo/crocodile/blob/master/tutorial.ipynb>) on the main git repo.


  Click [Here](<https://crocodile.readthedocs.io/en/latest/>)


  Alex Al-Saffar. [email](mailto:programmer@usa.com)


pkgId: 0b3e3b3e30ba9297780c59e6bcf8dd69051a0651c69ede2d1e64fd1082551cb0
name: python-cron-api
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: 定时任务api
url: https://pypi.org/project/cron-api/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cron-api-0.1.1-1.src.rpm
checksum_type: sha256
description:
  自用 fastapi 项目,提供对应接口,通过命令行启动

  -   etcd 配置定时任务
  -   mongodb 查看任务执行日志



  `pipx install cron-api` 或 `uv tool install cron-api`



  `cron-api --help`

  ```shell




  cron-api --dotenv-path .env

  cron-api --host 0.0.0.0 --port 8000
  ```


pkgId: 8856c229e88af0a85ac8093324840ef8c285a419c66ec2d96d86faeb3238c088
name: python-cron-converter
arch: src
version: 1.2.1
epoch: 0
release: 1
summary: Cron string parser and scheduler for Python
url: https://github.com/Sonic0/cron-converter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cron-converter-1.2.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src="https://raw.githubusercontent.com/Sonic0/cron-converter/main/logo.png" title="Cron-converter">
  </p>

  Cron-converter provides a Cron string parser ( from string/lists to string/lists ) and iteration for the datetime object with a cron like format.<br>
  This project would be a transposition in Python of JS [cron-converter](https://github.com/roccivic/cron-converter) by [roccivic](https://github.com/roccivic).

  [![MIT License Badge](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/Sonic0/cron-converter/blob/master/LICENCE)
  ![Unit and Integration tests](https://github.com/Sonic0/cron-converter/workflows/Unit%20and%20Integration%20tests/badge.svg)
  [![codebeat badge](https://codebeat.co/badges/33cfdde8-34ce-4fcc-85b6-2031d919639f)](https://codebeat.co/projects/github-com-sonic0-cron-converter-main)




  ```bash
  pip install cron-converter
  ```


  ```python
  from cron_converter import Cron
  ```


  ```python
  cron_instance = Cron()
  ```
  or
  ```python
  cron_instance = Cron('*/10 9-17 1 * *')
  ```
  or (with constructor options)
  ```python
  cron_instance = Cron('*/10 9-17 1 * *', {
    'output_weekday_names': True,
    'output_month_names': True
  })
  ```


  ```python


  cron_instance.from_string('*/10 9-17 1 * *')


  print(cron_instance.to_string())











  print(cron_instance.to_list())
  ```


  ```python
  cron_instance.from_list([[0], [1], [1], [5], [0,2,4,6]])


  print(cron_instance.to_string())
  ```


  Possible options:
  - output_weekday_names: false (default)
  - output_month_names: false (default)
  - output_hashes: false (default)


  ```python
  cron_instance = Cron(None, {
    'output_weekday_names': True,
    'output_month_names': True
  })
  cron_instance.from_string('*/5 9-17/2 * 1-3 1-5')

  print(cron_instance)
  ```
  or
  ```python
  cron_instance = Cron('*/5 9-17/2 * 1-3 1-5', {
    'output_weekday_names': True,
    'output_month_names': True
  })

  print(cron_instance)
  ```


  ```python
  cron_instance = Cron('*/5 9-17/2 * 1-3 1-5', {
    'output_hashes': True
  })

  print(cron_instance.to_string())
  ```


  ```python

  cron_instance.from_string('*/5 * * * *')


  reference = datetime.now()

  schedule = cron_instance.schedule(reference)






  print(schedule.next().isoformat())

  print(schedule.next().isoformat())


  schedule.reset()


  print(schedule.prev().isoformat())

  print(schedule.prev().isoformat())
  ```


  Be sure to init your cron-converter instance with a TZ aware datetime for this to work!

  A Scheduler has two optional mutually exclusive arguments: `start_date` or `timezone_str`.
  By default (no parameters), a Scheduler start count with a UTC datetime ( _utcnow()_ ) if you not specify any `start_date` datetime object.
  If you provide `timezone_str` the Scheduler will start count from a localized now datetime ( _datetime.now(tz_object)_ ).

  Example starting from localized now datetime
  ```python
  from cron_converter import Cron

  cron = Cron('0 0 * * *')
  schedule = cron.schedule(timezone_str='Europe/Rome')

  print(schedule.next())
  ```

  Example using pytz:
  ```python
  from pytz import timezone
  from datetime import datetime
  from cron_converter import Cron

  tz = timezone('Europe/Rome')
  local_date = tz.localize(datetime(2021, 1, 1))
  cron = Cron('0 0 * * *')
  schedule = cron.schedule(start_date=local_date)
  next_schedule = schedule.next()
  next_next_schedule = schedule.next()

  print(next_schedule.isoformat())

  print(next_next_schedule.isoformat())
  ```
  Example using python_dateutil:
  ```python
  import dateutil.tz
  from datetime import datetime
  from cron_converter import Cron

  tz = dateutil.tz.gettz('Asia/Tokyo')
  local_date = datetime(2021, 1, 1, tzinfo=tz)
  cron = Cron('0 0 * * *')
  schedule = cron.schedule(start_date=local_date)
  next_schedule = schedule.next()
  next_next_schedule = schedule.next()

  print(next_schedule.isoformat())

  print(next_next_schedule.isoformat())
  ```


  It's possible to compare the Cron object schedules frequency. Thanks [@zevaverbach](https://github.com/zevaverbach).
  ```python

  Cron('0 1 * * 1-5') == Cron('0 2 * * 1-5') # True
  Cron('0 1,2,3 * * 1-5') > Cron('0 1,23 * * 1-5') # True

  Cron('* 1 * * 1-5') == Cron('0-59 1 * * 1-5') # True
  Cron('1-30 1 * * 1-5') > Cron('1-29 1 * * 1-5') # True

  Cron('* 1 1 * 1-5') == Cron('0-59 1 2 * 1-5') # True
  Cron('* 1 1,2 * 1-5') > Cron('* 1 6 * 1-5') # True

  Cron('* 1 1 11 1-5') == Cron('* 1 1 1 1-5') # True
  Cron('* 1 6 * 1-5') > Cron('* 1 6 1 1-5') # True

  Cron('* 1 1 11 *') == Cron('* 1 1 11 0-6') # True
  Cron('* 1 6 * 1-5') > Cron('* 1 6 * 1-4') # True
  ```


  Cron-converter is NOT able to do second repetition crontabs form.


  Cron can also validate datetime objects (datetime and date).
  ```python
  Cron("* * 10 * *").validate(datetime(2022, 1, 10, 1, 9)) # True
  Cron("* * 12 * *").validate(datetime(2022, 1, 10, 1, 9)) # False
  ```

  A datetime object can also be validated with the `in` operator
  ```python
  datetime(2024, 3, 19, 15, 55) in Cron('*/5 9-17/2 * 1-3 1-5') # True
  ```


  ```bash
  git clone https://github.com/Sonic0/cron-converter
  cd cron-converter
  ...
  python -m unittest discover -s tests/unit
  python -m unittest discover -s tests/integration
  ```


  This repo is part of a projects group, called _Cron-Converter_.
  Its related repositories:

  - [local-crontab](https://github.com/Sonic0/local-crontab)
  - [local-crontab-ansible-filter](https://github.com/Sonic0/local-crontab-ansible-filter)
  - [local-crontab-serverless-infrastructure](https://github.com/Sonic0/local-crontab-serverless-infrastructure)
  - [local-crontab-web-converter](https://github.com/Sonic0/local-crontab-web-converter)


pkgId: b7bb403c1de8c3bcf29e802230aa69e5d71482cf2a033bccbb1b2d6f00c1ae13
name: python-cron-descriptor
arch: src
version: 1.4.5
epoch: 0
release: 1
summary: A Python library that converts cron expressions into human readable strings.
url: https://github.com/Salamek/cron-descriptor
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cron-descriptor-1.4.5-1.src.rpm
checksum_type: sha256
description:
  [![Python tests](https://github.com/Salamek/cron-descriptor/actions/workflows/python-test.yml/badge.svg)](https://github.com/Salamek/cron-descriptor/actions/workflows/python-test.yml)
  [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/salamek)

  A Python library that converts cron expressions into human readable strings. Ported to Python from https://github.com/bradyholt/cron-expression-descriptor.

  **Author**: Adam Schubert (https://www.salamek.cz)
  **Original Author & Credit**: Brady Holt (http://www.geekytidbits.com)
  **License**: [MIT](http://opensource.org/licenses/MIT)


   * Supports all cron expression special characters including * / , - ? L W, #
   * Supports 5, 6 (w/ seconds or year), or 7 (w/ seconds and year) part cron expressions
   * Provides casing options (Sentence, Title, Lower, etc.)
   * Localization with support for 17 languages
   * Supports Python 3.8 - 3.12


  Using PIP
  ```bash
  pip install cron-descriptor
  ```




  ```python
  from cron_descriptor import get_description, ExpressionDescriptor

  print(get_description("* 2 3 * *"))



  print(str(ExpressionDescriptor("* 2 3 * *")))
  ```


  ```python

  from cron_descriptor import Options, CasingTypeEnum, DescriptionTypeEnum, ExpressionDescriptor

  descriptor = ExpressionDescriptor(
      expression = "*/10 * * * *",
      casing_type = CasingTypeEnum.Sentence,
      use_24hour_time_format = True
  )


  print(descriptor.get_description())
  print("{}".format(descriptor))



  options = Options()
  options.casing_type = CasingTypeEnum.Sentence
  options.use_24hour_time_format = True
  descriptor = ExpressionDescriptor("*/10 * * * *", options)
  print(descriptor.get_description(DescriptionTypeEnum.FULL))
  ```



  |Language| Locale Code | Contributor |
  |--------|-------------|-------------|
  |English |en|[Brady Holt](https://github.com/bradyholt)|
  |Brazilian |pt_PT|[Renato Lima](https://github.com/natenho)|
  |Chinese Simplified | zh_CN |[Star Peng](https://github.com/starpeng)|
  |Spanish |es_ES|[Ivan Santos](https://github.com/ivansg)|
  |Norwegian |nb_NO|[Siarhei Khalipski](https://github.com/KhalipskiSiarhei)|
  |Turkish |tr_TR|[Mustafa SADEDİL](https://github.com/sadedil)|
  |Dutch |nl_NL|[TotalMace](https://github.com/TotalMace)|
  |Russian |ru_RU|[LbISS](https://github.com/LbISS)|
  |French |fr_FR|[Arnaud TAMAILLON](https://github.com/Greybird)|
  |German |de_DE|[Michael Schuler](https://github.com/mschuler)|
  |Ukrainian |uk_UA|[Taras](https://github.com/tbudurovych)|
  |Italian |it_IT|[rinaldihno](https://github.com/rinaldihno)|
  |Czech |cs_CZ|[Adam Schubert](https://github.com/salamek)|
  |Swedish |sv_SE|[Åke Engelbrektson](https://github.com/eson57)|
  |Tamil |ta_IN|[Sankar Hari](https://github.com/sankarhari)|
  |Persian|fa_IR|[M. Yas. Davoodeh](https://github.com/Davoodeh)|
  |Korean|ko_KR|[KyuJoo Han](https://github.com/hanqyu)|
  |Japanese |ja_JP|[Tho Nguyen](https://github.com/tho-asterist)|

  <!-- SOON






  -->


   - .NET - [https://github.com/bradyholt/cron-expression-descriptor](https://github.com/bradyholt/cron-expression-descriptor)


   - Java     - [https://github.com/RedHogs/cron-parser](https://github.com/RedHogs/cron-parser)
   - Ruby     - [https://github.com/alpinweis/cronex](https://github.com/alpinweis/cronex)
   - Golang   - [https://github.com/jsuar/go-cron-descriptor](https://github.com/jsuar/go-cron-descriptor)



  ```bash
  python setup.py test
  ```


  cron-descriptor is using [Gettext](https://www.gnu.org/software/gettext/) for translations.

  > To create new translation or edit existing one, i suggest using [Poedit](https://poedit.net/).

  You can copy/rename and translate any file from `locale` directory:
  ```bash
  cp ./cron_descriptor/locale/de_DE.po ./cron_descriptor/locale/YOUR_LOCALE_CODE.po
  poedit ./cron_descriptor/locale/YOUR_LOCALE_CODE.po
  ```
  or you can generate new untranslated *.po file from sources by running in `cron_descriptor` directory:
  ```bash
  cd cron_descriptor
  xgettext *.py -o locale/YOUR_LOCALE_CODE.po
  ```

  Generating *.mo file from *.po file. In root directory run command:
  ```bash
  msgfmt -o cron_descriptor/locale/YOUR_LOCALE_CODE.mo cron_descriptor/locale/YOUR_LOCALE_CODE.po
  ```



  All suggestions and PR's are welcomed

  Just clone this repository and register pre-commit hook by running:

  ```bash
  ln -s ../../pre-commit.sh .git/hooks/pre-commit
  ```

  Then install dev requirements:

  ```bash
  pip install ruff
  ```


pkgId: 7f5ea5299bf7ff6b1d549d93b9ed48a9e26b34b031f32ccf523a45f6f13382c8
name: python-cron-sentry
arch: src
version: 0.8.0
epoch: 0
release: 1
url: http://github.com/yipit/cron-sentry
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cron-sentry-0.8.0-1.src.rpm
checksum_type: sha256
summary:
  Cron-Sentry is a command-line wrapper that reports unsuccessful runs to Sentry (https://www.getsentry.com)

description:
  Cron-Sentry is a python command-line wrapper that reports errors to `Sentry <http://getsentry.com>`__ (using `raven <https://github.com/getsentry/raven-python>`__)
  if the called script exits with a status other than zero.


pkgId: 945956d7c53b6211b11fb1195e5830eda6af5a8d620baf49d84cc267ae0c075a
name: python-cron-validator
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: Unix cron implementation by Python
url: https://github.com/vcoder4c/cron-validator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cron-validator-1.0.8-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/vcoder4c/cron-validator.svg?branch=master)](https://travis-ci.org/vcoder4c/cron-validator)
  [![Coverage Status](https://coveralls.io/repos/github/vcoder4c/cron-validator/badge.svg?branch=master)](https://coveralls.io/github/vcoder4c/cron-validator?branch=master)



  - Validate unix cron expression
  - Match unit cron expression with specific datetime
  - Generate match datetime between two datetime
  - Schedule tasks



  ```shell script
  pip install cron-validator
  ```



  **1. Install test requirements**

  ```shell script
  pip install -r requirements/test.txt
  ```

  **2. Run tests (with coverage if wished)**

  ```shell script
  pytest --cov=. test/
  ```



  **1. Validate unix cron expression**

  ```python
  from cron_validator import CronValidator

  assert CronValidator.parse('* * * * *') is not None # valid
  assert CronValidator.parse('*/3 * * * *') is not None # valid
  assert CronValidator.parse('*/61 * * * *') is None # invalid
  ```

  **2. Match unit cron expression with specific datetime**

  ```python
  from cron_validator import CronValidator
  from cron_validator.util import str_to_datetime

  dt_str = '2019-04-23 1:00'
  dt = str_to_datetime(dt_str)

  assert CronValidator.match_datetime("* * * * *", dt)
  assert CronValidator.match_datetime("* * * 4 *", dt)
  assert CronValidator.match_datetime("* * * 5 *", dt) is False
  assert CronValidator.match_datetime("* * * 1-5 *", dt)
  assert CronValidator.match_datetime("* * * 1-3 *", dt) is False
  assert CronValidator.match_datetime("* * * 1/5 *", dt) is False
  assert CronValidator.match_datetime("* * * * *", dt)
  assert CronValidator.match_datetime("0 * * * *", dt)
  assert CronValidator.match_datetime("0-30 * * * *", dt)
  assert CronValidator.match_datetime("0/30 * * * *", dt)
  ```

  **3. Generate match datetime between two datetime**

  ```python
  from cron_validator import CronValidator
  from cron_validator.util import str_to_datetime


  from_str = '2019-04-22 00:00'
  to_str = '2019-04-23 23:59'

  for dt in CronValidator.get_execution_time("0 0 * * *",
  from_dt=str_to_datetime(from_str), to_dt=str_to_datetime(to_str)):
      print(dt)




  ```

  **4. Use scheduler for repetitive task**

  ```python
  from cron_validator import CronScheduler

  cron_string = "*/1 * * * *"
  scheduler = CronScheduler(cron_string)

  while True:
      if scheduler.time_for_execution():
          
          print("Now is the next scheduled time.")
  ```

  **5. Use extended cron rules based on AWS EventBridge rules** (from v1.0.6)

  The cron validator supports partially extended rules based on the Amazon EvenBridge rule set. [More info.](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html#eb-cron-expressions)

  Currently we support:
  - 'L' for day of the month and day of the week
  - 'W' for day of the week.

  ```python
  from cron_validator import CronValidator
  from cron_validator.util import str_to_datetime
  from cron_validator.regexes import Version

  dt_str = '2023-04-28 1:00'
  dt = str_to_datetime(dt_str)

  assert CronValidator.match_datetime("* * * * 30W", dt, version=Version.EB)
  assert CronValidator.match_datetime("* * * * 5L", dt, version=Version.EB)

  dt_str = "2022-02-28 1:00"
  dt = str_to_datetime(dt_str)
  assert CronValidator.match_datetime("* * L * *", dt, version=Version.EB)
  ```



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


pkgId: 086bb96b6de381b30f1f203ffb0ad50c3f4e7610b35f3ef47421eeb3e55bed35
name: python-cronex
arch: src
version: 0.1.3.1
epoch: 0
release: 1
summary: This module provides an easy to use interface for cron-like task scheduling.
url: https://github.com/ericpruitt/cronex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cronex-0.1.3.1-1.src.rpm
checksum_type: sha256
description:
  This module provides an easy to use interface for cron-like task
  scheduling. The cron expression evaluation implemented by this library
  is 100% Vixie Cron compatible and also supports `Java
  Quartz's <http://www.quartz-scheduler.org/documentation/quartz-1.x/tutorials/crontrigger>`__
  non-standard "L", "W" and "#" characters.
  One other useful feature this library provides is the ability to set
  triggers at arbitrary intervals such as every 9 hours, every 11 minutes,
  etc., without the issues caused by using asterisk-slash notation; using
  ``*/9`` in the hours field of most cron implementations would result in
  a trigger firing at 9:XX AM at 6:XX PM each day, but with
  CronExpresssions, the trigger would fire at 9:XX AM, 6:XX PM then, on
  the following day 3:XX AM, 12:XX PM, 9:XX PM and so.


pkgId: 4b297db3522eb62d9be08ff4367c9b59ed9f9030acf8044dda3368e32b49119f
name: python-croniter
arch: src
version: 3.0.3
epoch: 0
release: 1
summary: croniter provides iteration for datetime object with cron like format
url: http://github.com/kiorky/croniter
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-croniter-3.0.3-1.src.rpm
checksum_type: sha256
description:
  croniter provides iteration for the datetime object with a cron like format.
                            _ _
        ___ _ __ ___  _ __ (_) |_ ___ _ __
       / __| '__/ _ \| '_ \| | __/ _ \ '__|
      | (__| | | (_) | | | | | ||  __/ |
       \___|_|  \___/|_| |_|_|\__\___|_|
  Website: https://github.com/kiorky/croniter


pkgId: 824f1e1ae24baea7edbbd68945abfd70ce7830ef0a847a70228d376abebc8df3
name: python-cronitor
arch: src
version: 4.7.1
epoch: 0
release: 1
summary: A lightweight Python client for Cronitor.
url: https://github.com/cronitorio/cronitor-python
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cronitor-4.7.1-1.src.rpm
checksum_type: sha256
description:
  ![Test](https://github.com/cronitorio/cronitor-python/workflows/Test/badge.svg)

  [Cronitor](https://cronitor.io/) provides end-to-end monitoring for background jobs, websites, APIs, and anything else that can send or receive an HTTP request. This library provides convenient access to the Cronitor API from applications written in Python. See our [API docs](https://cronitor.io/docs/api) for detailed references on configuring monitors and sending telemetry pings.

  In this guide:

  - [Installation](#Installation)
  - [Monitoring Background Jobs](#monitoring-background-jobs)
  - [Sending Telemetry Events](#sending-telemetry-events)
  - [Configuring Monitors](#configuring-monitors)
  - [Package Configuration & Env Vars](#package-configuration)
  - [Command Line Usage](#command-line-usage)



  ```
  pip install cronitor
  ```




  `cronitor-python` can automatically discover all of your declared Celery tasks, including your Celerybeat scheduled tasks,
  creating monitors for them and sending pings when tasks run, succeed, or fail. Your API keys can be found [here](https://cronitor.io/settings/api).

  Requires Celery 4.0 or higher. Celery auto-discover utilizes the Celery [message protocol version 2](https://docs.celeryproject.org/en/stable/internals/protocol.html#version-2).

  **Some important notes on support**

  * Tasks on [solar schedules](https://docs.celeryproject.org/en/stable/userguide/periodic-tasks.html#solar-schedules) are not supported and will be ignored.
  * [`django-celery-beat`](https://docs.celeryproject.org/en/stable/userguide/periodic-tasks.html#using-custom-scheduler-classes) is not yet supported, but is in the works.
  * If you use the default `PersistentScheduler`, the celerybeat integration overrides the celerybeat local task run database (as referenced [here](https://docs.celeryproject.org/en/stable/userguide/periodic-tasks.html#starting-the-scheduler) in the docs), named `celerybeat-schedule` by default. If you currently specify a custom location for this database, this integration will override it. **Very** few people require setting custom locations for this database. If you fall into this group and want to use `cronitor-python`'s celerybeat integration, please reach out to Cronitor support.


  ```python
  import cronitor.celery
  from celery import Celery

  app = Celery()
  app.conf.beat_schedule = {
      'run-me-every-minute': {
          'task': 'tasks.every_minute_celery_task',
          'schedule': 60
      }
  }


  cronitor.celery.initialize(app, api_key="apiKey123")

  @app.task
  def every_minute_celery_task():
      print("running a background job with celery...")

  @app.task
  def non_scheduled_celery_task():
      print("Even though I'm not on a schedule, I'll still be monitored!")
  ```

  If you want only to monitor Celerybeat periodic tasks, and not tasks triggered any other way, you can set `celereybeat_only=True` when initializing:
  ```python
  app = Celery()
  cronitor.celery.initialize(app, api_key="apiKey123", celerybeat_only=True)
  ```



  The `@cronitor.job` is a lightweight way to monitor any background task regardless of how it is executed. It will send telemetry events before calling your function and after it exits. If your function raises an exception a `fail` event will be sent (and the exception re-raised).

  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'



  @cronitor.job('send-invoices')
  def send_invoices_task(*args, **kwargs):
      ...
  ```



  If you want to send a heartbeat events, or want finer control over when/how [telemetry events](https://cronitor.io/docs/telemetry-api) are sent for your jobs, you can create a monitor instance and call the `.ping` method.

  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'


  cronitor.environment = 'staging'

  monitor = cronitor.Monitor('heartbeat-monitor')
  monitor.ping() # send a heartbeat event



  monitor.ping(
      state='run|complete|fail|ok', # run|complete|fail used to measure lifecycle of a job, ok used for manual reset only.
      message='', # message that will be displayed in alerts as well as monitor activity panel on your dashboard.
      metrics={
          'duration': 100, # how long the job ran (complete|fail only). cronitor will calculate this when not provided
          'count': 4500, # if your job is processing a number of items you can report a count
          'error_count': 10 # the number of errors that occurred while this job was running
      }
  )
  ```



  You can configure all of your monitors using a single YAML file. This can be version controlled and synced to Cronitor as part of
  a deployment or build process. For details on all of the attributes that can be set, see the [Monitor API](https://cronitor.io/docs/monitor-api) documentation.


  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'

  cronitor.read_config('./cronitor.yaml') # parse the yaml file of monitors

  cronitor.validate_config() # send monitors to Cronitor for configuration validation

  cronitor.apply_config() # sync the monitors from the config file to Cronitor

  cronitor.generate_config() # generate a new config file from the Cronitor API
  ```

  The timeout value for validate_config, apply_config and generate_config is 10 seconds by default. The value can be rewritten by setting the environment variable `CRONITOR_TIMEOUT`. It can also be rewritten by assigning a value to cronitor.timeout.

  ```python
  import cronitor

  cronitor.timeout = 30
  cronitor.apply_config()
  ```

  The `cronitor.yaml` file includes three top level keys `jobs`, `checks`, `heartbeats`. You can configure monitors under each key by defining [monitors](https://cronitor.io/docs/monitor-api#attributes).

  ```yaml
  jobs:
      nightly-database-backup:
          schedule: 0 0 * * *
          notify:
              - devops-alert-pagerduty
          assertions:
              - metric.duration < 5 minutes

      send-welcome-email:
          schedule: every 10 minutes
          assertions:
              - metric.count > 0
              - metric.duration < 30 seconds

  checks:
      cronitor-homepage:
          request:
              url: https://cronitor.io
              regions:
                  - us-east-1
                  - eu-central-1
                  - ap-northeast-1
          assertions:
              - response.code = 200
              - response.time < 2s

      cronitor-ping-api:
          request:
              url: https://cronitor.link/ping
          assertions:
              - response.body contains ok
              - response.time < .25s

  heartbeats:
      production-deploy:
          notify:
              alerts: ['deploys-slack']
              events: true # send alert when the event occurs

  ```

  You can also create and update monitors by calling `Monitor.put`. For details on all of the attributes that can be set see the Monitor API [documentation)(https://cronitor.io/docs/monitor-api#attributes).

  ```python
  import cronitor

  monitors = cronitor.Monitor.put([
    {
      'type': 'job',
      'key': 'send-customer-invoices',
      'schedule': '0 0 * * *',
      'assertions': [
          'metric.duration < 5 min'
      ],
      'notify': ['devops-alerts-slack']
    },
    {
      'type': 'check',
      'key': 'Cronitor Homepage',
      'schedule': 'every 45 seconds',
      'request': {
          'url': 'https://cronitor.io'
      },
      'assertions': [
          'response.code = 200',
          'response.time < 600ms',
      ]
    }
  ])
  ```



  ```python
  import cronitor

  monitor = cronitor.Monitor('heartbeat-monitor');

  monitor.pause(24) # pause alerting for 24 hours
  monitor.unpause() # alias for .pause(0)
  monitor.ok() # manually reset to a passing state alias for monitor.ping({state: ok})
  monitor.delete() # destroy the monitor
  ```



  The package needs to be configured with your account's `API key`, which is available on the [account settings](https://cronitor.io/settings) page. You can also optionally specify an `api_version` and an `environment`. If not provided, your account default is used. These can also be supplied using the environment variables `CRONITOR_API_KEY`, `CRONITOR_API_VERSION`, `CRONITOR_ENVIRONMENT`.

  ```python
  import cronitor


  cronitor.api_key = 'apiKey123'
  cronitor.api_version = '2020-10-01'
  cronitor.environment = 'cluster_1_prod'
  ```



  ```bash
  >> python -m cronitor -h

  usage: cronitor [-h] [--apikey APIKEY] [--key KEY] [--msg MSG]
                  (--run | --complete | --fail | --ok | --pause PAUSE)

  Send status messages to Cronitor ping API.

  optional arguments:
    -h, --help            show this help message and exit
    --authkey AUTHKEY, -a AUTHKEY
                          Auth Key from Account page
    --key KEY, -k KEY     Unique key for the monitor to take ping
    --msg MSG, -m MSG     Optional message to send with ping/fail
    --tick, -t            Call ping on given monitor
    --run, -r             Call ping with state=run on given monitor
    --complete, -C        Call ping with state=complete on given monitor
    --fail, -f            Call ping with state=fail on given monitor
    --pause PAUSE, -P PAUSE
                          Call pause on given monitor
  ```




  Pull requests and features are happily considered! By participating in this project you agree to abide by the [Code of Conduct](http://contributor-covenant.org/version/2/0).



  Fork, then clone the repo:

      git clone git@github.com:your-username/cronitor-python.git

  Set up your machine:

      pip install -r requirements

  Make sure the tests pass:

      pytest

  Make your change. Add tests for your change. Make the tests pass:

      pytest


  Push to your fork and [submit a pull request]( https://github.com/cronitorio/cronitor-python/compare/)


pkgId: 5c039dd7355461b4e7e954992681fab7527adee0575d3afc068dc602d4fd7b4c
name: python-cronken
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/populi/cronken
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cronken-0.1.20-1.src.rpm
checksum_type: sha256
description:
  [![GitHub license](https://img.shields.io/github/license/Populi/cronken.svg)](https://github.com/Populi/cronken/blob/master/LICENSE)
  [![PyPI version](https://img.shields.io/pypi/v/cronken)](https://pypi.org/project/cronken/)

  ![Cronken logo](cronken-logo.png)


  Cronken is a Redis-backed distributed cron system which allows running cronjobs across a set of servers without
  risking double-running them on multiple boxes at once.  To facilitate this, it uses Redis locks to ensure that
  only one server at a time runs any particular job.  It also uses Redis for all of its input and output,
  reading its job list from Redis, storing results to Redis, and subscribing to a Redis pub/sub channel to allow for
  centralized control of all cronken instances.


  A barebones example using a local Redis server can be found in [example_server.py](example_server.py), and a
  slightly more sophisticated example that uses aiohttp to expose a web interface can be found in
  [example_web.py](example_web.py).


  A full description of the backend Redis data format can be found in [cronken_specification.md](cronken_specification.md).


pkgId: c440277191b6df8905fbfe3e679ac796acae445f307bdc7741b86edc0a3ee5c5
name: python-crono-api-client
arch: src
version: 0.1.17
epoch: 0
release: 1
summary: Crono API client
url: https://github.com/gduverger/crono-api-client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crono-api-client-0.1.17-1.src.rpm
checksum_type: sha256
description:
  Python client for the 🔮 Crono API: https://crono.com/

  ```python
  >>> import crono_api_client as crono
  >>> crono.request('POST', https://your.app/').after(hours=42)
  ```



  Install package:
  ```console
  $ pip install crono_api_client
  ```

  Configure `.env` variables:
  ```
  CRONO_API_URL=…
  CRONO_API_KEY=…
  ```

  Get all jobs:
  ```python
  >>> job_uuids = crono.jobs()
  ```

  Get a job:
  ```python
  >>> job_json = crono.job(<string:job_uuid>)
  ```

  Schedule a job:
  ```python
  >>> job_uuid = crono.<task>(<args>, <kwargs>).<trigger>(<args>, <kwargs>)
  >>> # or
  >>> job_uuid = crono.<trigger>(<args>, <kwargs>).<task>(<args>, <kwargs>)
  ```

  Delete a job:
  ```python
  >>> job_uuid = crono.delete(<string:job_uuid>)
  ```



  Packaging

  ```console

  $ python setup.py sdist bdist_wheel


  $ twine upload --skip-existing dist/*
  ```


pkgId: 79dc676c8dc151c3f6d2a9ac20f3978c1e85c86718d452733fffbd71e37d3afb
name: python-cronos-chain-client
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A Python client for interacting with the Cronos Chains
url: https://github.com/cronos-labs/cronos-chain-client/tree/main/py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cronos-chain-client-0.1.5-1.src.rpm
checksum_type: sha256
description:
  The Cronos Chain Client is a Python library designed to facilitate easy and efficient interactions with the Cronos Chains. This client library provides methods to fetch CRC20 tokens, making it easy for developers to work with tokens on the Cronos chain.



  - Simple and intuitive API for interacting with the Cronos blockchain.
  - Supports fetching a list of CRC20 tokens.
  - Configurable client instances tailored to your specific blockchain endpoint and API key needs.



  To install the package, run the following command in your project directory:

  ```bash
  pip install cronos-chain-client
  ```



  Here’s how you can use the Cronos Chain Client in your project:



  ```python
  from cronos_chain_client import create_client

  client = create_client({
      'chain': 'evm',
      'network': 'mainnet',
      'explorer': {
          'apiKey': 'OPPTIONAL_API_KEY', # Optional
      }
  })
  ```



  To get a list of CRC20 tokens with their id, name, symbol, and contract_address, you can call the following method:

  ```python
  tokens = client.tokens.getCRC20TokenList()
  print(tokens)
  ```

  Example output:

  ```python
  [
  {"id": 1, "name": "Tether USD", "symbol": "USDT", "contract_address": "0x66e428c3f67a68878562e79a0234c1f83c208770"},
  {"id": 2, "name": "USD Coin", "symbol": "USDC", "contract_address": "0xc21223249ca28397b4b6541dffaecc539bff0c59"},
  {"id": 3, "name": "Dogecoin", "symbol": "DOGE", "contract_address": "0x1a8e39ae59e5556b56b76fcba98d22c9ae557396"},
  ]
  ```







  - `getCRC20TokenList()`: Fetches the list of CRC20 tokens.



  The code in this project is licensed under the MIT license.



  If you have any questions or comments about the library, feel free to open an issue or a pull request on our GitHub repository.


pkgId: bd8f788a6ba4d15e129ab43ae6c4cce638ae3285436b2f04d7635619b3579a3a
name: python-cronsim
arch: src
version: 2.5
epoch: 0
release: 1
summary: Cron expression parser and evaluator
url: https://github.com/cuu508/cronsim
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cronsim-2.5-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/cuu508/cronsim/actions/workflows/pytest.yml/badge.svg)](https://github.com/cuu508/cronsim/actions/workflows/pytest.yml)

  Cron Sim(ulator), a cron expression parser and evaluator. Works with Python 3.8+.
  CronSim is written for and being used in
  [Healthchecks](https://github.com/healthchecks/healthchecks/)
  (a cron job monitoring service).

  Development priorities:

  * Correctness. CronSim tries to match Debian's cron as closely as possible,
    including its quirky behaviour during DST transitions.
  * Readability. Prefer simple over clever.
  * Minimalism. Don't implement features that Healthchecks will not use
    (for example, iteration in reverse, or the seconds field in cron expressions).



  ```
  pip install cronsim
  ```



  ```python
  from datetime import datetime
  from cronsim import CronSim

  it = CronSim("0 0 * 2 MON#5", datetime.now())
  for x in range(0, 10):
      print(next(it))
  ```

  Produces:

  ```
  2044-02-29 00:00:00
  2072-02-29 00:00:00
  2112-02-29 00:00:00
  2140-02-29 00:00:00
  2168-02-29 00:00:00
  2196-02-29 00:00:00
  2208-02-29 00:00:00
  2236-02-29 00:00:00
  2264-02-29 00:00:00
  2292-02-29 00:00:00
  ```

  If CronSim receives an invalid cron expression, it raises `cronsim.CronSimError`:

  ```python
  from datetime import datetime
  from cronsim import CronSim

  CronSim("123 * * * *", datetime.now())
  ```

  Produces:

  ```
  cronsim.cronsim.CronSimError: Bad minute
  ```

  If CronSim cannot find a matching datetime in the next 50 years from the start
  date or from the previous match, it stops iteration by raising `StopIteration`:

  ```python
  from datetime import datetime
  from cronsim import CronSim



  it = CronSim("* * */20 * 1L", datetime.now())
  print(next(it))
  ```

  Produces:

  ```
  StopIteration
  ```



  CronSim starting from version 2.0 is designed to work with timezones provided by
  the zoneinfo module.

  A previous version, CronSim 1.0, was designed for pytz and relied on its
  following non-standard features:

  * the non-standard `is_dst` flag in the `localize()` method
  * the `pytz.AmbiguousTimeError` and `pytz.NonExistentTimeError` exceptions
  * the `normalize()` method



  CronSim aims to match [Debian's cron implementation](https://salsa.debian.org/debian/cron/-/tree/master/)
  (which itself is based on Paul Vixie's cron, with modifications). If CronSim evaluates
  an expression differently from Debian's cron, that's a bug.

  CronSim is open to adding support for non-standard syntax features, as long as
  they don't conflict or interfere with the standard syntax.



  CronSim handles Daylight Saving Time transitions the same as
  Debian's cron. Debian has special handling for jobs with a granularity
  greater than one hour:

  ```
  Local time changes of less than three hours, such as  those  caused  by
  the  start or end of Daylight Saving Time, are handled specially.  This
  only applies to jobs that run at a specific time and jobs that are  run
  with  a    granularity  greater  than  one hour.  Jobs that run more fre-
  quently are scheduled normally.

  If time has moved forward, those jobs that would have run in the inter-
  val that has been skipped will be run immediately.  Conversely, if time
  has moved backward, care is taken to avoid running jobs twice.
  ```

  See test cases in `test_cronsim.py`, `TestDstTransitions` class
  for examples of this special handling.



  | Feature                              | Debian | Quartz | croniter | cronsim |
  | ------------------------------------ | :----: | :----: | :------: | :-----: |
  | Seconds in the 6th field             | No     | Yes    | Yes      | No      |
  | "L" as the day-of-month              | No     | Yes    | Yes      | Yes     |
  | "LW" as the day-of-month             | No     | Yes    | No       | Yes     |
  | "L" in the day-of-week field         | No     | Yes    | No       | Yes     |
  | Nth weekday of month                 | No     | Yes    | Yes      | Yes     |


  **Seconds in the 6th field**: an optional sixth field specifying seconds.
  Supports the same syntax features as the minutes field. Quartz Scheduler
  expects seconds in the first field, croniter expects seconds in the last field.

  Quartz example: `*/15 * * * * *` (every 15 seconds).

  **"L" as the day-of-month**: support for the "L" special character in the
  day-of-month field. Interpreted as "the last day of the month".

  Example: `0 0 L * *` (at the midnight of the last day of every month).

  **"LW" as the day-of-month**: support for the "LW" special value in the
  day-of-month field. Interpreted as "the last weekday (Mon-Fri) of the month".

  Example: `0 0 LW * *` (at the midnight of the last weekday of every month).

  **"L" in the day-of-week field**: support for the "{weekday}L" syntax.
  For example, "5L" means "the last Friday of the month".

  Example: `0 0 * * 6L` (at the midnight of the last Saturday of every month).

  **Nth weekday of month**: support for "{weekday}#{nth}" syntax.
  For example, "MON#1" means "first Monday of the month", "MON#2" means "second Monday
  of the month".

  Example: `0 0 * * MON#1` (at midnight of the first monday of every month).



  Starting from version 2.4, the CronSim objects have an `explain()` method
  which generates a text description of the supplied cron expression.

  ```python
  from datetime import datetime
  from cronsim import CronSim

  expr = CronSim("*/5 9-17 * * *", datetime.now())
  print(expr.explain())
  ```

  Outputs:

  ```
  Every fifth minute from 09:00 through 17:59
  ```

  The text descriptions are available in English only. The text descriptions
  use the 24-hour time format ("23:00" instead of "11:00 PM").

  For examples of generated descriptions see `tests/test_explain.py`.


pkgId: 9f60666a4f4840d00b4ebed88c5f7315ceba022bbe50a36dd4a7dbd00f1d01d6
name: python-cronsim
arch: src
version: 2.6
epoch: 0
release: 1
summary: Cron expression parser and evaluator
url: https://github.com/cuu508/cronsim
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cronsim-2.6-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/cuu508/cronsim/actions/workflows/pytest.yml/badge.svg)](https://github.com/cuu508/cronsim/actions/workflows/pytest.yml)

  Cron Sim(ulator), a cron expression parser and evaluator. Works with Python 3.8+.
  CronSim is written for and being used in
  [Healthchecks](https://github.com/healthchecks/healthchecks/)
  (a cron job monitoring service).

  Development priorities:

  * Correctness. CronSim tries to match Debian's cron as closely as possible,
    including its quirky behaviour during DST transitions.
  * Readability. Prefer simple over clever.
  * Minimalism. Don't implement features that Healthchecks will not use
    (for example, the seconds field in cron expressions).



  ```
  pip install cronsim
  ```



  ```python
  from datetime import datetime
  from cronsim import CronSim

  it = CronSim("0 0 * 2 MON#5", datetime(2020, 1, 1))
  for x in range(0, 5):
      print(next(it))
  ```

  Produces:

  ```
  2044-02-29 00:00:00
  2072-02-29 00:00:00
  2112-02-29 00:00:00
  2140-02-29 00:00:00
  2168-02-29 00:00:00
  ```

  To iterate backwards in time, add `reverse=True` in the constructor:

  ```python
  from datetime import datetime
  from cronsim import CronSim

  it = CronSim("0 0 * 2 MON#5", datetime(2020, 1, 1), reverse=True)
  print(next(it))
  ```

  Produces:

  ```
  2016-02-29 00:00:00
  ```

  If CronSim receives an invalid cron expression, it raises `cronsim.CronSimError`:

  ```python
  from datetime import datetime
  from cronsim import CronSim

  CronSim("123 * * * *", datetime(2020, 1, 1))
  ```

  Produces:

  ```
  cronsim.cronsim.CronSimError: Bad minute
  ```

  If CronSim cannot find a matching datetime in the next 50 years from the start
  date or from the previous match, it stops iteration by raising `StopIteration`:

  ```python
  from datetime import datetime
  from cronsim import CronSim



  it = CronSim("* * */20 * 1L", datetime(2020, 1, 1))
  print(next(it))
  ```

  Produces:

  ```
  StopIteration
  ```



  CronSim starting from version 2.0 is designed to work with timezones provided by
  the zoneinfo module.

  A previous version, CronSim 1.0, was designed for pytz and relied on its
  following non-standard features:

  * the non-standard `is_dst` flag in the `localize()` method
  * the `pytz.AmbiguousTimeError` and `pytz.NonExistentTimeError` exceptions
  * the `normalize()` method



  CronSim aims to match [Debian's cron implementation](https://salsa.debian.org/debian/cron/-/tree/master/)
  (which itself is based on Paul Vixie's cron, with modifications). If CronSim evaluates
  an expression differently from Debian's cron, that's a bug.

  CronSim is open to adding support for non-standard syntax features, as long as
  they don't conflict or interfere with the standard syntax.



  CronSim handles Daylight Saving Time transitions the same as
  Debian's cron. Debian has special handling for jobs with a granularity
  greater than one hour:

  ```
  Local time changes of less than three hours, such as  those  caused  by
  the  start or end of Daylight Saving Time, are handled specially.  This
  only applies to jobs that run at a specific time and jobs that are  run
  with  a    granularity  greater  than  one hour.  Jobs that run more fre-
  quently are scheduled normally.

  If time has moved forward, those jobs that would have run in the inter-
  val that has been skipped will be run immediately.  Conversely, if time
  has moved backward, care is taken to avoid running jobs twice.
  ```

  See test cases in `test_cronsim.py`, `TestDstTransitions` class
  for examples of this special handling.



  | Feature                              | Debian | Quartz | croniter | cronsim |
  | ------------------------------------ | :----: | :----: | :------: | :-----: |
  | Seconds in the 6th field             | No     | Yes    | Yes      | No      |
  | "L" as the day-of-month              | No     | Yes    | Yes      | Yes     |
  | "LW" as the day-of-month             | No     | Yes    | No       | Yes     |
  | "L" in the day-of-week field         | No     | Yes    | No       | Yes     |
  | Nth weekday of month                 | No     | Yes    | Yes      | Yes     |


  **Seconds in the 6th field**: an optional sixth field specifying seconds.
  Supports the same syntax features as the minutes field. Quartz Scheduler
  expects seconds in the first field, croniter expects seconds in the last field.

  Quartz example: `*/15 * * * * *` (every 15 seconds).

  **"L" as the day-of-month**: support for the "L" special character in the
  day-of-month field. Interpreted as "the last day of the month".

  Example: `0 0 L * *` (at the midnight of the last day of every month).

  **"LW" as the day-of-month**: support for the "LW" special value in the
  day-of-month field. Interpreted as "the last weekday (Mon-Fri) of the month".

  Example: `0 0 LW * *` (at the midnight of the last weekday of every month).

  **"L" in the day-of-week field**: support for the "{weekday}L" syntax.
  For example, "5L" means "the last Friday of the month".

  Example: `0 0 * * 6L` (at the midnight of the last Saturday of every month).

  **Nth weekday of month**: support for "{weekday}#{nth}" syntax.
  For example, "MON#1" means "first Monday of the month", "MON#2" means "second Monday
  of the month".

  Example: `0 0 * * MON#1` (at midnight of the first monday of every month).



  Starting from version 2.4, the CronSim objects have an `explain()` method
  which generates a text description of the supplied cron expression.

  ```python
  from datetime import datetime
  from cronsim import CronSim

  expr = CronSim("*/5 9-17 * * *", datetime.now())
  print(expr.explain())
  ```

  Outputs:

  ```
  Every fifth minute from 09:00 through 17:59
  ```

  The text descriptions are available in English only. The text descriptions
  use the 24-hour time format ("23:00" instead of "11:00 PM").

  For examples of generated descriptions see `tests/test_explain.py`.


pkgId: 2fc24727c531797e8b3adfe8db6777ea3e8fb9a3538d17dc4607c98c43424254
name: python-crontab
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Parse and use crontab schedules in Python
url: https://github.com/josiahcarlson/parse-crontab
rpm_license: GNU LGPL v2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crontab-1.0.1-1.src.rpm
checksum_type: sha256
description:
  This package intends to offer a method of parsing crontab schedule entries and
  determining when an item should next be run. More specifically, it calculates
  a delay in seconds from when the .next() method is called to when the item
  should next be executed.
  Comparing the below chart to http://en.wikipedia.org/wiki/Cron#CRON_expression


pkgId: 65745c3592b6f94591c8e1fae5afa32823df5d65ac0fc4e41e08d6380f9b6c7a
name: python-crop-utils
arch: src
version: 4.3.31
epoch: 0
release: 1
summary: 主体贴边缘不扩边
url: http://git.chaomy.com/libo/ecpro-utils.git
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crop-utils-4.3.31-1.src.rpm
checksum_type: sha256
description:
  为了区分3.0与4.0版本，同时资源图与详情页也共用的一套裁剪逻辑代码。

  为了降低裁剪部分维护与开发难度，封装为裁剪工具包







  环境：win

  python版本: 3.9





  https://packaging.python.org/tutorials/packaging-projects/#



  项目目录结构

  ~~~markdown
   ecpro-util/

   	|-- src/

   	|   |-- ecpro/

   	|   |  |-- init.py

   	|   |  |-- html_slot_config.py

   	|   |  |-- image.py

   	|   |  |-- img_crop.py

   	|--tests/

   	|   |--test.py

   	|--setup.py

   	|--LICENSE

   	|--MANIFEST.IN

   	|--pyproject.toml

   	|--READNE.md
  ~~~


  > python setup.py sdist bdist_wheel





  首先需要在pypi上注册并绑定邮箱才有权限上传

  > twine upload dist/*







  pip install crop-utils==4.3.31 -i  https://pypi.python.org/simple/


pkgId: 93fc3135b1b729edac12bbe4edd6e69e1c91297af66339b4fbb0092083c7af65
name: python-cropclassification
arch: src
version: 0.2
epoch: 0
release: 1
summary: Package to classify crops based on sentinel images.
url: https://github.com/theroggy/cropclassification
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cropclassification-0.2-1.src.rpm
checksum_type: sha256
description:
  This is a collection of scripts that can help to classify crops using Sentinel data.

  Probably this documentation won't suffice to get you started, but you are free to reach out for more info if you are really interested.

  In general, you should also be aware that the package isn't really meant to be an easy-to-use solution for crop classification. It is rather a quite specialised solution for our specific needs. Nonetheless we want to make the code public so if anyone is interested, they can have a look and possibly get some inspiration.


  1. Install conda

  As the scripts are written in Python, you need to use a package manager to be able to install the packages the scripts depend on. The rest of the installation manual assumes you use anaconda and python 3.6+. The installer for anaconda can be found here: https://www.anaconda.com/download/.

  2. Create new environment and install dependencies

  Once you have anaconda installed, you can open an anaconda terminal window and follow the following steps:

        1. Create and activate a new conda environment
        ```
        conda create --name cropclassification
        conda activate cropclassification
        conda config --env --add channels conda-forge
        conda config --env --set channel_priority strict
        ```
        2. Install the dependencies for the crop classification scripts:
        ```
        conda install python=3.9 geopandas geofileops "h5py<3" openeo psutil qgis rasterio rasterstats scikit-learn
        ```
        3. If it was the first time you installed anaconda/geopandas, you might have to restart your computer to proceed
        4. Start the anaconda terminal window again and activate the environment
        ```
        conda activate cropclassification
        ```
        5. Now install cropclassification and dependencies that need pip with pip
        ```
        pip install cropclassification
        ```
  4. Calculate time series

  To calculate time series, you need to run `cropclassification -t <tasks_dir>`, with a 'calc_timeseries' type of task in the tasks dir
  on a server that has access to sentinel CARD images.

  Mind: the sentinel CARD image structure as expected for timeseries calculation depends on the image type:
    * for Sentinel 2 images this is the standard S2 L2A format as available on the open acces copernicus hub.
    * for Sentinel 1 backscatter and sentinel 1 coherence data this is a non-standardized data structure as there isn't a standard format (yet) for level 2 processed sentinel 1 images (as far as I know). Check out the code to see the expected data structure ;-).

  5. Start a crop classification

  Run `cropclassification -t <tasks_dir>`, with a 'calc_marker' type of task in the tasks dir.


pkgId: 93574e59f2fa1b63be57c5b241b181935d018fdeeaee684965603c7abdbd352b
name: python-cropnet
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: A Python package for the CropNet dataset
url: https://pypi.org/project/cropnet/
rpm_license: Free for non-commercial use
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cropnet-0.2.1-1.src.rpm
checksum_type: sha256
description:
  CropNet is an open, large-scale, and deep learning-ready dataset, specifically targeting climate change-aware crop yield predictions for the contiguous United States (U.S.) continent at the county level. It is composed of three modalities of data, i.e., Sentinel-2 Imagery, WRF-HRRR Computed Dataset, and USDA Crop Dataset, aligned in both the spatial and temporal domains, for over 2200 U.S. counties spanning 6 years (2017-2022). It is expected to facilitate researchers in developing deep learning models for timely and precisely predicting crop yields at the county level, by accounting for the effects of both short-term growing season weather variations and long-term climate change on crop yields. Although our initial goal of crafting the CropNet dataset is for precise crop yield prediction, we believe its future applicability is broad and can benefit the deep learning, agriculture, and meteorology communities, for exploring more interesting and critical climate change-related applications, by using one or more modalities of data.





  The CropNet dataset is composed of three modalities of data, i.e., Sentinel-2 Imagery, WRF-HRRR Computed Dataset, and USDA Crop Dataset, spanning from 2017 to 2022 (i.e., 6 years) across 2291 U.S. counties.

  - The dataset is available at [Google Drive](https://drive.google.com/drive/folders/1Js98GAxf1LeAUTxP1JMZZIrKvyJStDgz)

  - The tutorials for each modality of data are availbale at [Github](https://anonymous.4open.science/r/CropNet)





  The Sentinel-2 Imagery, obtained from the [Sentinel-2 mission](https://sentinel.esa.int/web/sentinel/missions/sentinel-2), provides high-resolution satellite images for monitoring crop growth on the ground. It contains two types of 224x224 RGB satellite images, agriculture imagery (AG) and normalized difference vegetation index (NDVI), both with a spatial resolution of 9x9 km, and a revisit frequency of 14 days.



  The WRF-HRRR Computed Dataset, sourced from the [WRF-HRRR model](https://home.chpc.utah.edu/~u0553130/Brian_Blaylock/hrrr_FAQ.html), contains daily and monthly meteorological parameters, with the former and the latter designed for capturing the direct effects of short-term growing season weather variations on crop growth, and for learning the indirect impacts of long-term climate change on crop yields, respectively. It contains 9 meteorological parameters gridded at 9 km in a one-day (and one-month) interval.



  The USDA Crop Dataset, collected from the [USDA Quick Statistic website](https://quickstats.nass.usda.gov/), offers valuable crop information, such as production, yield, etc., for crops grown at each available county. It offers crop information for four types of crops, i.e., corn, cotton, soybeans, and winter wheat, at a county-level basis, with a temporal resolution of one year.





  This repository includes three types of APIs for facilitating researchers in downloading the CropNet data based on the time and region of interest, and flexibly building their deep learning models for accurate crop yield predictions, with their details listed below:

  - **DataDownloader**: This API allows users to download the CropNet data over the time/region of interest on the fly.

  - **DataRetriever**: With this API, users can conveniently obtain the CropNet data stored in the local machine (e.g., if you have downloaded our curated CropNet from Google Drive) over the time/region of interest.

  - **DataLoader**: This API is designed to facilitate researchers in developing their DNNs for accurate crop yield predictions. Specifically, the code in this API ( 1) combines all three modalities of data to create $(\mathbf{x}, \mathbf{y_{s}}, \mathbf{y_{l}}, \mathbf{z})$ tuples, with $\mathbf{x}, \mathbf{y_{s}}, \mathbf{y_{l}}, \text{and}~ \mathbf{z}$, respectively representing satellite images, short-term daily whether parameters, long-term monthly meteorological parameters, and ground-truth crop yield (or production) information, and then (2) exposes those tuples via a `Dataset` object after appropriate data pre-processing techniques.





  Researchers and practitioners can install the latest version of CropNet with the following commands:

  ```python

  conda create -n cropnet_api python=3.10
  conda activate cropnet_api


  pip install cropnet


  pip install ecmwflibs
  ```




  - **Example 1: A DataDownloader Example for Downloading the Up-to-date CropNet Data**

    Given the time and region (i.e., the FIPS codes for two U.S. counties) of interest, the following code presents how to utilize the **DataDownloader** to download the up-to-date CropNet data:

  ```python
  from cropnet.data_downloader import DataDownloader


  downloader = DataDownloader(target_dir="./data")



  downloader.download_USDA("Soybean", fips_codes=["10003", "22007"], years=["2022"])


  downloader.download_Sentinel2(fips_codes=["10003", "22007"], years=["2023"], image_type="AG")
  downloader.download_Sentinel2(fips_codes=["10003", "22007"], years=["2023"], image_type="NDVI")


  downloader.download_HRRR(fips_codes=["10003", "22007"], years=["2023"])
  ```



  - **Example 2: A DataRetriever Example for Obtaining Our Curated CropNet Data**

    Given the time and region of interest, the following code shows how to use the **DataRetriever** to obtain the CropNet data stored in the local machine in a user-friendly format:

  ```python

  retriever = DataRetriever(base_dir="/mnt/data/CropNet")


  usda_data = retriever.retrieve_USDA(crop_type="Soybean", fips_codes=["10003", "22007"], years=["2022"])


  sentinel2_data = retriever.retrieve_Sentinel2(fips_codes=["10003", "22007"], years=["2022"], image_type="AG")
  sentinel2_data = retriever.retrieve_Sentinel2(fips_codes=["10003", "22007"], years=["2022"], image_type="NDVI")


  hrrr_data = retriever.retrieve_HRRR(fips_codes=["10003","22007"], years=["2022"])
  ```



  - **Example 3: A PyTorch Example for Using the DataLoader API for Training DNNs**

  The following code presents a PyTorch example of training a deep learning model (i.e., MMST-ViT) for climate change-aware crop yield predictions, by utilizing the DataLoader  APIs:

  ```python
  import torch
  from torch.utils.data import DataLoader
  from models_mmst_vit import MMST_ViT
  from cropnet.dataset.hrrr_computed_dataset import HRRRComputedDataset
  from cropnet.dataset.sentinel2_imagery import Sentinel2Imagery
  from cropnet.dataset.usda_crop_dataset import USDACropDataset


  base_dir = "/mnt/data/CropNet"

  config_file = "data/soybeans_train.json"


  sentinel2_loader = DataLoader(Sentinel2Imagery(base_dir, config_file), batch_size=1)
  hrrr_loader = DataLoader(HRRRComputedDataset(base_dir, config_file), batch_size=1)
  usda_loader = DataLoader(USDACropDataset(base_dir, config_file), batch_size=1)


  model = MMST_ViT()
  optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, betas=(0.9, 0.999))
  criterion = torch.nn.MSELoss()


  for s, h, u in zip(sentinel2_loader, hrrr_loader, usda_loader):
      
      
      
      x, ys, yl, z, = s[0], h[0], h[1], u[0]

      optimizer.zero_grad()
      z_hat = model(x, ys, yl)
      loss = criterion(z, z_hat)

      loss.backward()
      optimizer.step()
  ```





  CropNet has a [Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)](https://creativecommons.org/licenses/by-nc/4.0/) license.


pkgId: 8090f5ce03bd6e2c8a10c613d2b90cb13b74300e37c34994bcaf71287931aa04
name: python-cross_ml
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: A comprehensive library for data preprocessing and feature engineering in machine learning
url: https://github.com/andresdigiovanni/cross
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cross_ml-0.2.0-1.src.rpm
checksum_type: sha256
description:
  ![PyPI version](https://img.shields.io/pypi/v/cross_ml)
  ![Downloads](https://img.shields.io/pypi/dm/cross_ml)
  Cross is a Python library for data processing to train machine learning models, featuring scaling, normalization, feature creation through binning, and various mathematical operations between columns. It includes a graphical interface for exploring and generating transformations, with the option to export and reuse them.
  ![UI Cross](assets/ui_outliers_handling.png)
  - [Getting Started](#getting-started)
  - [Example of Use](#example-of-use)
    - [Define transformations](#define-transformations)
    - [Import Transformations from UI](#import-transformations-from-ui)
    - [Save and Load Transformations](#save-and-load-transformations)
    - [Auto transformations](#auto-transformations)
  - [Transformations](#transformations)
    - [Clean Data](#clean-data)
      - [Column Selection](#column-selection)
      - [Column Casting](#column-casting)
      - [Missing Values](#missing-values)
      - [Handle Outliers](#handle-outliers)
    - [Preprocessing](#preprocessing)
      - [Non-Linear Transformation](#non-linear-transformation)
      - [Quantile Transformations](#quantile-transformations)
      - [Scale Transformations](#scale-transformations)
      - [Normalization](#normalization)
    - [Feature Engineering](#feature-engineering)
      - [Correlated Substring Encoder](#correlated-substring-encoder)
      - [Categorical Encoding](#categorical-encoding)
      - [Date Time Transforms](#date-time-transforms)
      - [Cyclical Features Transforms](#cyclical-features-transforms)
      - [Numerical Binning](#numerical-binning)
      - [Mathematical Operations](#mathematical-operations)

  To install the Cross library, run the following command:
  ```bash
  pip install cross_ml
  ```
  You can initialize the graphical interface with the command:
  ```bash
  cross run
  ```
  Access the application by navigating to `http://localhost:8501` in your browser.


  ```python
  transformations = [
      OutliersHandler(
          handling_options={
              "sepal length (cm)": ("median", "iqr"),
              "sepal width (cm)": ("cap", "zscore"),
          },
          thresholds={
              "sepal length (cm)": 1.5,
              "sepal width (cm)": 2.5,
          },
      ),
      ScaleTransformation(
          transformation_options={
              "sepal length (cm)": "min_max",
              "sepal width (cm)": "min_max",
          }
      ),
      NumericalBinning(
          binning_options={
              "sepal length (cm)": "uniform",
          },
          num_bins={
              "sepal length (cm)": 5,
          },
      ),
      MathematicalOperations(
          operations_options=[
              ("sepal length (cm)", "sepal width (cm)", "add"),
          ]
      ),
  ]
  cross = CrossTransformer(transformations)

  x_train, y_train = cross.fit_transform(x_train, y_train)
  x_test, y_test = cross.transform(x_test, y_test)
  ```

  You can export transformations created in the graphical interface (UI) to a file and later import them into your scripts:
  ```python
  import pickle

  with open("cross_transformations.pkl", "rb") as f:
      transformations = pickle.load(f)
  cross = CrossTransformer(transformations)

  x_train, y_train = cross.fit_transform(x_train, y_train)
  x_test, y_test = cross.transform(x_test, y_test)
  ```

  To save and reuse the transformations, save them and load them in future sessions:
  ```python
  import pickle

  transformations = cross.get_params()
  with open("cross_transformations.pkl", "wb") as f:
      pickle.dump(transformations, f)

  with open("cross_transformations.pkl", "rb") as f:
      transformations = pickle.load(f)
  cross.set_params(**transformations)
  ```

  You can allow the library to create automatically the transformations that best fits:
  ```python
  from cross import auto_transform, CrossTransformer
  from sklearn.neighbors import KNeighborsClassifier

  model = KNeighborsClassifier()
  scoring = "accuracy"
  direction = "maximize"

  transformations = auto_transform(x, y, model, scoring, direction)

  transformer = CrossTransformer(transformations)

  x_train, y_train = transformer.fit_transform(x_train, y_train)
  x_test, y_test = transformer.transform(x_test, y_test)
  ```



  Allows you to select specific columns for further processing.
  - Parameters:
      - `columns`: List of column names to select.
  ```python
  ColumnSelection(
      columns=[
          "sepal length (cm)",
          "sepal width (cm)",
      ]
  )
  ```

  Casts columns to specific data types.
  - Parameters:
      - `cast_options`: A dictionary specifying the type for each column. Options include: `category`, `number`, `bool`, `datetime`, `timedelta`.
  ```python
  CastColumns(
      cast_options={
          "sepal length (cm)": "number",
          "sepal width (cm)": "number",
      }
  )
  ```

  Handles missing values in the dataset.
  - Parameters:
      - `handling_options`: Dictionary that specifies the handling strategy for each column. Options: `fill_0`, `most_frequent`, `fill_mean`, `fill_median`, `fill_mode`, `fill_knn`.
      - `n_neighbors`: Number of neighbors for K-Nearest Neighbors imputation (used with `fill_knn`).
  ```python
  MissingValuesHandler(
      handling_options={
          'sepal width (cm)': 'fill_knn',
          'petal length (cm)': 'fill_mode',
          'petal width (cm)': 'most_frequent',
      },
      n_neighbors= {
          'sepal width (cm)': 5,
      }
  )
  ```

  Manages outliers in the dataset using different strategies. The action can be either cap or median, while the method can be `iqr`, `zscore`, `lof`, or `iforest`. Note that `lof` and `iforest` only accept the `median` action.
  - Parameters:
      - `handling_options`: Dictionary specifying the handling strategy. The strategy is a tuple where the first element is the action (`cap` or `median`) and the second is the method (`iqr`, `zscore`, `lof`, `iforest`).
      - `thresholds`: Dictionary with thresholds for `iqr` and `zscore` methods.
      - `lof_params`: Dictionary specifying parameters for the LOF method.
      - `iforest_params`: Dictionary specifying parameters for Isolation Forest.
  ```python
  OutliersHandler(
      handling_options={
          'sepal length (cm)': ('median', 'iqr'),
          'sepal width (cm)': ('cap', 'zscore'),
          'petal length (cm)': ('median', 'lof'),
          'petal width (cm)': ('median', 'iforest'),
      },
      thresholds={
          'sepal length (cm)': 1.5,
          'sepal width (cm)': 2.5,
      },
      lof_params={
          'petal length (cm)': {
              'n_neighbors': 20,
          }
      },
      iforest_params={
          'petal width (cm)': {
              'contamination': 0.1,
          }
      }
  )
  ```


  Applies non-linear transformations, including logarithmic, exponential, and Yeo-Johnson transformations.
  - Parameters:
      - `transformation_options`: A dictionary specifying the transformation to be applied for each column. Options include: `log`, `exponential`, and `yeo_johnson`.
  ```python
  NonLinearTransformation(
      transformation_options={
          "sepal length (cm)": "log",
          "sepal width (cm)": "exponential",
          "petal length (cm)": "yeo_johnson",
      }
  )
  ```

  Applies quantile transformations for normalizing data.
  - Parameters:
      - `transformation_options`: Dictionary specifying the transformation type. Options: `uniform`, `normal`.
  ```python
  QuantileTransformation(
      transformation_options={
          'sepal length (cm)': 'uniform',
          'sepal width (cm)': 'normal',
      }
  )
  ```

  Scales numerical data using different scaling methods.
  - Parameters:
      - `transformation_options`: Dictionary specifying the scaling method for each column. Options: `min_max`, `standard`, `robust`, `max_abs`.
  ```python
  ScaleTransformation(
      transformation_options={
          'sepal length (cm)': 'min_max',
          'sepal width (cm)': 'standard',
          'petal length (cm)': 'robust',
          'petal width (cm)': 'max_abs',
      }
  )
  ```

  Normalizes data using L1 or L2 norms.
  - Parameters:
      - `transformation_options`: Dictionary specifying the normalization type. Options: `l1`, `l2`.
  ```python
  Normalization(
      transformation_options={
          'sepal length (cm)': 'l1',
          'sepal width (cm)': 'l2',
      }
  )
  ```


  Encodes a new column based on the presence of specific substrings in a target column. This technique is useful for finding latent relationships between categorical values that share common substrings, such as part codes or abbreviations.
  - Parameters:
      - `substrings`: A dictionary where each key is a column name and the value is a list of substrings to search within that column. If a substring is found, it is added to a new column with the suffix `__corr_substring`.
  ```python
  CorrelatedSubstringEncoder(
      substrings={
          "product_description": ["eco", "premium", "budget"],
          "customer_feedback": ["satisfied", "disappointed"],
      }
  )
  ```

  Encodes categorical variables using various methods.
  - Parameters:
      - `encodings_options`: Dictionary specifying the encoding method for each column. Options: `label`, `ordinal`, `onehot`, `dummy`, `binary`, `count`, `target`.
      - `ordinal_orders`: Specifies the order for ordinal encoding.
  ```python
  CategoricalEncoding(
      encodings_options={
          'Sex': 'label',
          'Size': 'ordinal',
      },
      ordinal_orders={
          "Size": ["small", "medium", "large"]
      }
  )
  ```

  Transforms datetime columns into useful features.
  - Parameters:
      - `datetime_columns`: List of columns to extract date/time features from.
  ```python
  DateTimeTransformer(
      datetime_columns=["date"]
  )
  ```

  Transforms cyclical features like time into a continuous representation.
  - Parameters:
      - `columns_periods`: Dictionary specifying the period for each cyclical column.
  ```python
  CyclicalFeaturesTransformer(
      columns_periods={
          "date_minute": 60,
          "date_hour": 24,
      }
  )
  ```

  Bins numerical columns into categories. You can now specify the column, the binning method, and the number of bins in a tuple.
  - Parameters:
      - `binning_options`: List of tuples where each tuple specifies the column name, binning method, and number of bins. Options for binning methods are `uniform`, `quantile` or `kmeans`.
  ```python
  NumericalBinning(
      binning_options=[
          ("sepal length (cm)", "uniform", 5),
          ("sepal width (cm)", "quantile", 6),
          ("petal length (cm)", "kmeans", 7),
      ]
  )
  ```

  Performs mathematical operations between columns.
  - Parameters:
      - `operations_options`: List of tuples specifying the columns and the operation.
  - **Options**:
      - `add`: Adds the values of two columns.
      - `subtract`: Subtracts the values of two columns.
      - `multiply`: Multiplies the values of two columns.
      - `divide`: Divides the values of two columns.
      - `modulus`: Computes the modulus of two columns.
      - `hypotenuse`: Computes the hypotenuse of two columns.
      - `mean`: Calculates the mean of two columns.
  ```python
  MathematicalOperations(
      operations_options=[
          ('sepal length (cm)', 'sepal width (cm)', 'add'),
          ('petal length (cm)', 'petal width (cm)', 'subtract'),
          ('sepal length (cm)', 'petal length (cm)', 'multiply'),
          ('sepal width (cm)', 'petal width (cm)', 'divide'),
          ('sepal length (cm)', 'petal width (cm)', 'modulus'),
          ('sepal length (cm)', 'sepal width (cm)', 'hypotenuse'),
          ('petal length (cm)', 'petal width (cm)', 'mean'),
      ]
  )
  ```


pkgId: b559e3afbfb42b68f2b896341b7390020a57babb5af9b73a65cfba4e12e99032
name: python-crossenv
arch: src
version: 1.5.0
epoch: 0
release: 1
summary: A cross-compiling tool for Python extension modules
url: https://github.com/benfogle/crossenv
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crossenv-1.5.0-1.src.rpm
checksum_type: sha256
description:
  |build status| |test status| |coverage status|
  Documentation is available online at https://crossenv.readthedocs.io and in the
  ``docs`` directory.
  Porting a Python app to an embedded device can be complicated. Once you have
  Python built for your system, you may find yourself needing to include many
  third-party libraries. Pure-Python libraries usually just work, but many
  popular libraries rely on compiled C code, which can be challenging to build.
  This package is a tool for cross-compiling extension modules. It creates a
  special virtual environment such that ``pip`` or ``setup.py`` will cross
  compile packages for you, usually with no further work on your part.
  It can be used to:
  * Build binary wheels, for installation on target.
  * Install packages to a directory for upload or inclusion in a firmware image.
  **Note**: While this tool can cross-compile *most* Python packages, it can't
  solve all the problems of cross-compiling. In some cases manual intervention
  may still be necessary.
  This tool requires Python 3.5 or higher (host and build). Significant work has
  gone into cross-compiling Python in newer versions, and many of the techniques
  needed to do the cross compilation properly are not available on older
  releases.
  This tool currently only supports Linux build machines.


pkgId: c8d17db288294a043de36a0febd0ed62d745c23d84eafe3acccf709d5f4b9db2
name: python-crossfit
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Offline inference and metric calculation library
url: https://github.com/rapidsai/crossfit/
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crossfit-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/crossfit.svg)](https://pypi.org/project/crossfit/)
  [![Changelog](https://img.shields.io/github/v/release/rapidsai/crossfit?include_prereleases&label=changelog)](https://github.com/rapidsai/crossfit/releases)
  [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/rapidsai/crossfit/blob/main/LICENSE)

  Multi Node Multi GPU Offline Inference and metric calculation library



  Install this library using `pip`:

      pip install crossfit



  ```
  git clone https://github.com/rapidsai/crossfit.git
  cd crossfit
  pip install --extra-index-url https://pypi.nvidia.com ".[cuda12x]"
  ```



  Usage instructions go here.



  To contribute to this library, first create a conda environment with the necessary dependencies:
  ```
  cd crossfit
  mamba env create -f conda/environments/cuda_dev.yaml
  conda activate crossfit_dev
  ```

  Now install the dependencies and test dependencies:

      pip install -e '.[test]'

  To run the tests:

      pytest


pkgId: 3b7e1b7116116fa61397eec1a2413b3bb4996b5f51fa614b0497f2df2c8f6e80
name: python-crosshair-tool
arch: src
version: 0.0.74
epoch: 0
release: 1
summary: Analyze Python code for correctness using symbolic execution.
url: https://github.com/pschanely/CrossHair
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crosshair-tool-0.0.74-1.src.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)!
  This integration is much more effective at bug-finding than running crosshair
  with the `--analysis_kind=hypothesis` option.


  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: 7328bbd60b2dd99e757ea3da24b36926b2f8bb69f78eb503c39965841b28961e
name: python-crosshair-tool
arch: src
version: 0.0.78
epoch: 0
release: 1
summary: Analyze Python code for correctness using symbolic execution.
url: https://github.com/pschanely/CrossHair
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crosshair-tool-0.0.78-1.src.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: 7852be9192f43c975e241958b7d69b158f9b1ded421efe433978548986d78984
name: python-crossplane
arch: src
version: 0.5.8
epoch: 0
release: 1
summary: Reliable and fast NGINX configuration file parser.
url: https://github.com/nginxinc/crossplane
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crossplane-0.5.8-1.src.rpm
checksum_type: sha256
description:
  ![Crossplane Logo](https://raw.githubusercontent.com/nginxinc/crossplane/master/ext/crossplane-logo.png)
  <h1 align="center">crossplane</h1>
  <h3 align="center">Reliable and fast NGINX configuration file parser and builder</h3>

  <p align="center">
  <a href="https://github.com/nginxinc/crossplane/actions/workflows/crossplane-ci.yml"><img src="https://github.com/nginxinc/crossplane/actions/workflows/crossplane-ci.yml/badge.svg"></a>
  <a href="https://github.com/nginxinc/crossplane/releases"><img src="https://img.shields.io/github/release/nginxinc/crossplane.svg"></a>
  <a href="https://pypi.python.org/pypi/crossplane"><img src="https://img.shields.io/pypi/l/crossplane.svg"></a>
  <a href="https://pypi.python.org/pypi/crossplane"><img src="https://img.shields.io/pypi/pyversions/crossplane.svg"></a>
  </p>

    - [Install](#install)
    - [Command Line Interface](#command-line-interface)
        - [crossplane parse](#crossplane-parse)
        - [crossplane build](#crossplane-build)
        - [crossplane lex](#crossplane-lex)
        - [crossplane format](#crossplane-format)
        - [crossplane minify](#crossplane-minify)
    - [Python Module](#python-module)
        - [crossplane.parse()](#crossplaneparse)
        - [crossplane.build()](#crossplanebuild)
        - [crossplane.lex()](#crossplanelex)
    - [Other Languages](#other-languages)



  You can install both the [Command Line
  Interface](#command-line-interface) and [Python Module](#python-module)
  via:

      pip install crossplane



  ```
  usage: crossplane <command> [options]

  various operations for nginx config files

  optional arguments:
    -h, --help            show this help message and exit
    -V, --version         show program's version number and exit

  commands:
    parse                 parses a json payload for an nginx config
    build                 builds an nginx config from a json payload
    lex                   lexes tokens from an nginx config file
    minify                removes all whitespace from an nginx config
    format                formats an nginx config file
    help                  show help for commands
  ```



  This command will take a path to a main NGINX config file as input, then
  parse the entire config into the schema defined below, and dumps the
  entire thing as a JSON payload.

  ```
  usage: crossplane parse [-h] [-o OUT] [-i NUM] [--ignore DIRECTIVES]
                          [--no-catch] [--tb-onerror] [--single-file]
                          [--include-comments] [--strict]
                          filename

  parses a json payload for an nginx config

  positional arguments:
    filename              the nginx config file

  optional arguments:
    -h, --help            show this help message and exit
    -o OUT, --out OUT     write output to a file
    -i NUM, --indent NUM  number of spaces to indent output
    --ignore DIRECTIVES   ignore directives (comma-separated)
    --no-catch            only collect first error in file
    --tb-onerror          include tracebacks in config errors
    --combine             use includes to create one single file
    --single-file         do not include other config files
    --include-comments    include comments in json
    --strict              raise errors for unknown directives
  ```

  **Privacy and Security**

  Since `crossplane` is usually used to create payloads that are sent to
  different servers, it's important to keep security in mind. For that
  reason, the `--ignore` option was added. It can be used to keep certain
  sensitive directives out of the payload output entirely.

  For example, we always use the equivalent of this flag in the [NGINX Amplify
  Agent](https://github.com/nginxinc/nginx-amplify-agent/) out of respect
  for our users'
      privacy:

      --ignore=auth_basic_user_file,secure_link_secret,ssl_certificate_key,ssl_client_certificate,ssl_password_file,ssl_stapling_file,ssl_trusted_certificate



  **Response Object**

  ```js
  {
      "status": String, // "ok" or "failed" if "errors" is not empty
      "errors": Array,  // aggregation of "errors" from Config objects
      "config": Array   // Array of Config objects
  }
  ```

  **Config Object**

  ```js
  {
      "file": String,   // the full path of the config file
      "status": String, // "ok" or "failed" if errors is not empty array
      "errors": Array,  // Array of Error objects
      "parsed": Array   // Array of Directive objects
  }
  ```

  **Directive Object**

  ```js
  {
      "directive": String, // the name of the directive
      "line": Number,      // integer line number the directive started on
      "args": Array,       // Array of String arguments
      "includes": Array,   // Array of integers (included iff this is an include directive)
      "block": Array       // Array of Directive Objects (included iff this is a block)
  }
  ```

  <div class="note">

  <div class="admonition-title">

  Note

  </div>

  If this is an `include` directive and the `--single-file` flag was not
  used, an `"includes"` value will be used that holds an Array of indices
  of the configs that are included by this directive.

  If this is a block directive, a `"block"` value will be used that holds
  an Array of more Directive Objects that define the block context.

  </div>

  **Error Object**

  ```js
  {
      "file": String,     // the full path of the config file
      "line": Number,     // integer line number the directive that caused the error
      "error": String,    // the error message
      "callback": Object  // only included iff an "onerror" function was passed to parse()
  }
  ```

  <div class="note">

  <div class="admonition-title">

  Note

  </div>

  If the `--tb-onerror` flag was used by crossplane parse, `"callback"`
  will contain a string that represents the traceback that the error
  caused.

  </div>



  The main NGINX config file is at `/etc/nginx/nginx.conf`:

  ```nginx
  events {
      worker_connections 1024;
  }

  http {
      include conf.d/*.conf;
  }
  ```

  And this config file is at `/etc/nginx/conf.d/servers.conf`:

  ```nginx
  server {
      listen 8080;
      location / {
          try_files 'foo bar' baz;
      }
  }

  server {
      listen 8081;
      location / {
          return 200 'success!';
      }
  }
  ```

  So then if you run this:

      crossplane parse --indent=4 /etc/nginx/nginx.conf

  The prettified JSON output would look like this:

  ```js
  {
      "status": "ok",
      "errors": [],
      "config": [
          {
              "file": "/etc/nginx/nginx.conf",
              "status": "ok",
              "errors": [],
              "parsed": [
                  {
                      "directive": "events",
                      "line": 1,
                      "args": [],
                      "block": [
                          {
                              "directive": "worker_connections",
                              "line": 2,
                              "args": [
                                  "1024"
                              ]
                          }
                      ]
                  },
                  {
                      "directive": "http",
                      "line": 5,
                      "args": [],
                      "block": [
                          {
                              "directive": "include",
                              "line": 6,
                              "args": [
                                  "conf.d/*.conf"
                              ],
                              "includes": [
                                  1
                              ]
                          }
                      ]
                  }
              ]
          },
          {
              "file": "/etc/nginx/conf.d/servers.conf",
              "status": "ok",
              "errors": [],
              "parsed": [
                  {
                      "directive": "server",
                      "line": 1,
                      "args": [],
                      "block": [
                          {
                              "directive": "listen",
                              "line": 2,
                              "args": [
                                  "8080"
                              ]
                          },
                          {
                              "directive": "location",
                              "line": 3,
                              "args": [
                                  "/"
                              ],
                              "block": [
                                  {
                                      "directive": "try_files",
                                      "line": 4,
                                      "args": [
                                          "foo bar",
                                          "baz"
                                      ]
                                  }
                              ]
                          }
                      ]
                  },
                  {
                      "directive": "server",
                      "line": 8,
                      "args": [],
                      "block": [
                          {
                              "directive": "listen",
                              "line": 9,
                              "args": [
                                  "8081"
                              ]
                          },
                          {
                              "directive": "location",
                              "line": 10,
                              "args": [
                                  "/"
                              ],
                              "block": [
                                  {
                                      "directive": "return",
                                      "line": 11,
                                      "args": [
                                          "200",
                                          "success!"
                                      ]
                                  }
                              ]
                          }
                      ]
                  }
              ]
          }
      ]
  }
  ```



  This tool uses two flags that can change how `crossplane` handles
  errors.

  The first, `--no-catch`, can be used if you'd prefer that crossplane
  quit parsing after the first error it finds.

  The second, `--tb-onerror`, will add a `"callback"` key to all error
  objects in the JSON output, each containing a string representation of
  the traceback that would have been raised by the parser if the exception
  had not been caught. This can be useful for logging purposes.



  This command will take a path to a file as input. The file should
  contain a JSON representation of an NGINX config that has the structure
  defined above. Saving and using the output from `crossplane parse` to
  rebuild your config files should not cause any differences in content
  except for the formatting.

  ```
  usage: crossplane build [-h] [-d PATH] [-f] [-i NUM | -t] [--no-headers]
                          [--stdout] [-v]
                          filename

  builds an nginx config from a json payload

  positional arguments:
    filename              the file with the config payload

  optional arguments:
    -h, --help            show this help message and exit
    -v, --verbose         verbose output
    -d PATH, --dir PATH   the base directory to build in
    -f, --force           overwrite existing files
    -i NUM, --indent NUM  number of spaces to indent output
    -t, --tabs            indent with tabs instead of spaces
    --no-headers          do not write header to configs
    --stdout              write configs to stdout instead
  ```



  This command takes an NGINX config file, splits it into tokens by
  removing whitespace and comments, and dumps the list of tokens as a JSON
  array.

  ```
  usage: crossplane lex [-h] [-o OUT] [-i NUM] [-n] filename

  lexes tokens from an nginx config file

  positional arguments:
    filename              the nginx config file

  optional arguments:
    -h, --help            show this help message and exit
    -o OUT, --out OUT     write output to a file
    -i NUM, --indent NUM  number of spaces to indent output
    -n, --line-numbers    include line numbers in json payload
  ```



  Passing in this NGINX config file at `/etc/nginx/nginx.conf`:

  ```nginx
  events {
      worker_connections 1024;
  }

  http {
      include conf.d/*.conf;
  }
  ```

  By running:

      crossplane lex /etc/nginx/nginx.conf

  Will result in this JSON
  output:

  ```js
  ["events","{","worker_connections","1024",";","}","http","{","include","conf.d/*.conf",";","}"]
  ```

  However, if you decide to use the `--line-numbers` flag, your output
  will look
  like:

  ```js
  [["events",1],["{",1],["worker_connections",2],["1024",2],[";",2],["}",3],["http",5],["{",5],["include",6],["conf.d/*.conf",6],[";",6],["}",7]]
  ```



  This is a quick and dirty tool that uses [crossplane
  parse](#crossplane-parse) internally to format an NGINX config file.
  It serves the purpose of demonstrating what you can do with `crossplane`'s
  parsing abilities. It is not meant to be a fully fleshed out, feature-rich
  formatting tool. If that is what you are looking for, then you may want to
  look writing your own using crossplane's Python API.

  ```
  usage: crossplane format [-h] [-o OUT] [-i NUM | -t] filename

  formats an nginx config file

  positional arguments:
    filename              the nginx config file

  optional arguments:
    -h, --help            show this help message and exit
    -o OUT, --out OUT     write output to a file
    -i NUM, --indent NUM  number of spaces to indent output
    -t, --tabs            indent with tabs instead of spaces
  ```



  This is a simple and fun little tool that uses [crossplane
  lex](#crossplane-lex) internally to remove as much whitespace from an
  NGINX config file as possible without affecting what it does. It can't
  imagine it will have much of a use to most people, but it demonstrates
  the kinds of things you can do with `crossplane`'s lexing abilities.

  ```
  usage: crossplane minify [-h] [-o OUT] filename

  removes all whitespace from an nginx config

  positional arguments:
    filename           the nginx config file

  optional arguments:
    -h, --help         show this help message and exit
    -o OUT, --out OUT  write output to a file
  ```



  In addition to the command line tool, you can import `crossplane` as a
  python module. There are two basic functions that the module will
  provide you: `parse` and `lex`.



  ```python
  import crossplane
  payload = crossplane.parse('/etc/nginx/nginx.conf')
  ```

  This will return the same payload as described in the [crossplane
  parse](#crossplane-parse) section, except it will be Python dicts and
  not one giant JSON string.



  ```python
  import crossplane
  config = crossplane.build(
      [{
          "directive": "events",
          "args": [],
          "block": [{
              "directive": "worker_connections",
              "args": ["1024"]
          }]
      }]
  )
  ```

  This will return a single string that contains an entire NGINX config
  file.



  ```python
  import crossplane
  tokens = crossplane.lex('/etc/nginx/nginx.conf')
  ```

  `crossplane.lex` generates 2-tuples. Inserting these pairs into a list
  will result in a long list similar to what you can see in the
  [crossplane lex](#crossplane-lex) section when the `--line-numbers` flag
  is used, except it will obviously be a Python list of tuples and not one
  giant JSON string.



  - Go port by [@aluttik](https://github.com/aluttik):
      <https://github.com/aluttik/go-crossplane>
  - Ruby port by [@gdanko](https://github.com/gdanko):
      <https://github.com/gdanko/crossplane>


pkgId: 0f168a1b71e05f5b22710d0b1bb68ae65d7488efe6cd3180e3c19621327025b6
name: python-crossplane-function-sdk-python
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: The Python SDK for Crossplane composition functions
url: https://pypi.org/project/crossplane-function-sdk-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crossplane-function-sdk-python-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/crossplane/function-sdk-python/actions/workflows/ci.yml/badge.svg)](https://github.com/crossplane/function-sdk-python/actions/workflows/ci.yml) [![GitHub release (latest SemVer)](https://img.shields.io/github/release/crossplane/function-sdk-python)](https://github.com/crossplane/function-sdk-python/releases) [![PyPI - Version](https://img.shields.io/pypi/v/crossplane-function-sdk-python)](https://pypi.org/project/crossplane-function-sdk-python/)


  The [Python][python] SDK for writing [composition functions][functions].

  This SDK is currently a beta. We try to avoid breaking changes, but it will not
  have a stable API until it reaches v1.0.0. It follows the same [contributing
  guidelines] as Crossplane.

  To learn how to use this SDK:

  * [Follow the guide to writing a composition function in Python][function guide]
  * [Learn about how composition functions work][functions]
  * [Read the package documentation][package docs]

  The `RunFunctionRequest` and `RunFunctionResponse` types provided by this SDK
  are generated from a proto3 protocol buffer schema. Their fields behave
  similarly to built-in Python types like lists and dictionaries, but there are
  some differences. Read the [generated code documentation][python-protobuf] to
  familiarize yourself with the the differences.

  If you just want to jump in and get started, consider using the
  [function-template-python] template repository.



  This project follows the Crossplane [contributing guidelines], where applicable
  to Python. It is linted, tested, and built using [Hatch][hatch].

  Some useful commands:

  ```shell

  hatch run generate:protoc


  hatch fmt


  hatch test


  hatch build
  ```

  [python]: https://python.org
  [functions]: https://docs.crossplane.io/latest/concepts/composition-functions
  [python-protobuf]: https://protobuf.dev/reference/python/python-generated/
  [function-template-python]: https://github.com/crossplane/function-template-python
  [function guide]: https://docs.crossplane.io/knowledge-base/guides/write-a-composition-function-in-python
  [package docs]: https://crossplane.github.io/function-sdk-python
  [contributing guidelines]: https://github.com/crossplane/crossplane/tree/master/contributing
  [hatch]: https://github.com/pypa/hatch


pkgId: 9e8a18507eabb61ec2570190b0860291d2de7a4cb990b6c885bf693cbe92192f
name: python-crosspredict
arch: src
version: 1.1.11
epoch: 0
release: 1
summary: package for easy crossvalidation
url: https://pypi.org/project/crosspredict/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crosspredict-1.1.11-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/crosspredict.svg)](https://badge.fury.io/py/crosspredict)
  [![Documentation Status](https://readthedocs.org/projects/crosspredict/badge/?version=latest)](https://crosspredict.readthedocs.io/en/latest/?badge=latest)

  * The library makes cross validation and reports generation easy
  * Easy to extend to other models
  * Supports Lightgbm, XGBoost, CatBoost
  * Supports different crossvalidation strategies:
      * Supports crossvalidation by users (RepeatedKFold)
      * Supports stratified crossvalidation by target column (RepeatedStratifiedKFold)
      * Supports simple crossvalidation (RepeatedKFold)
  * Easy use of target encoding with double crossvalidation
  * Supports target encoding library category_encoders
  * ML Pipeline building blocks



  - [Installation](#installation)
  - [ReportsPreview](#reportspreview)
  - [Target Encoding with DoubleCrossValidation](#target-encoding-with-doublecrossvalidation)
  - [How to use](#how-to-use)
  - [Authors](#authors)


  ```bash
  python -m pip install crosspredict
  ```


  ```python

  a = ReportBinary()
  ```
  ``` python
  a.plot_report(
      df,
      report_shape = (5,2),
      report={'Roc-Auc':  {'loc':(0, 0)},
            'Precision-Recall': [{'loc':(0, 1)}],
            'MeanTarget-by-Probability': [{'loc':(1, 0)},{'loc':(1, 1)}],
            'Gini-by-Generations': {'loc':(2,0), 'colspan':2},
            'MeanTarget-by-Generations': {'loc':(3,0), 'colspan':2},
            'Probability-Distribution': [{'loc':(4,0)},{'loc':(4,1)}]},
      cols_score = ['result_egr_to_one','probability'],
      cols_target = ['target','target2'],
      col_generation_deals='first_dt_no_comm_mon'
  )
  a.fig.savefig('report1.png')
  ```
  ![Report1](notebooks/report1.png "Report#1")
  ```python
  a.plot_report(report_shape = (3,2),
                report={'roc-auc':  {'loc':(0, 0)},
                        'precision-recall': {'loc':(0, 1)},
                        'mean-prob': {'loc':(1, 0)},
                        'gen-gini': [{'loc':(2,0), 'colspan':2}],
                        'distribution': {'loc':(1,1)}
                       },
                cols_score=['probability'])
  a.fig.savefig('report2.png')
  ```
  ![Report2](notebooks/report2.png "Report#2")


  ```python

  iter_df = Iterator(n_repeats=3,
                      n_splits=10,
                      random_state = 0,
                      col_client = 'userid',
                      cv_byclient=True)


  cross_encoder = CrossTargetEncoder(iterator = iter_df,
                                      encoder_class=WOEEncoder,
                                      n_splits= 5,
                                      n_repeats= 3,
                                      random_state= 0,
                                      col_client= 'userid',
                                      cv_byclient= True,
                                      col_encoded= 'goal1',
                                      cols= ['field3','field2','field11','field23','field18','field20']
                                    )
  cross_encoder.fit(train)


  model_class = CrossLightgbmModel(iterator=iter_df,
                                   feature_name=feature_name,
                                   params=params,
                                   cols_cat = ['field3', 'field2', 'field11', 'field23', 'field18', 'field20'],
                                   num_boost_round = 9999,
                                   early_stopping_rounds = 50,
                                   valid = True,
                                   random_state = 0,
                                   col_target = 'goal1',
                                   cross_target_encoder = cross_encoder)
  result = model_class.fit(train)
  ```


  **ML Pipeline Calculation** - [`ML_Pipeline.ipynb`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/ML_Pipeline.ipynb)
  Configuration file for pipeline - [`params.yaml`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/params.yaml)

  **Plot_Reports_for_Binary_Classification_problem_example** - [`Plot_Reports_for_Binary_Classification_problem_example.ipynb`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/Plot_Reports_for_Binary_Classification_problem_example.ipynb)

  **Simple_example_in_one_Notebook** - [`Simple_example_in_one_Notebook.ipynb`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/Simple_example_in_one_Notebook.ipynb)

  **Iterator_class** - [`Iterator_class.ipynb`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/Iterator_class.ipynb)

  **CrossModelFabric_class** - [`CrossModelFabric_class.ipynb`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/CrossModelFabric_class.ipynb)

  **CrossTargetEncoder_class** - [`CrossTargetEncoder_class.ipynb`](https://github.com//ya-ds/crosspredict/blob/master/notebooks/CrossTargetEncoder_class.ipynb)



  [Vladislav Boyadzhi](https://www.linkedin.com/in/vladislav-boyadzhi/)
  [Alexander Tarelkin](https://github.com/Tarelkinal)


pkgId: bdeb80139bebec48e9d20020223b40ee584e85ebeff826df6f2a682b79f88ce5
name: python-crossroads-segmentation
arch: src
version: 0.1.27
epoch: 0
release: 1
url: https://github.com/jmtrivial/crossroads-segmentation/
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crossroads-segmentation-0.1.27-1.src.rpm
checksum_type: sha256
summary:
  Crossroads segmentation is a python tool that produces automatic segmentations of data from OpenStreetMap.

description:
  **Crossroads segmentation** is a python tool that produces automatic segmentations of data from OpenStreetMap.



  With pip, use the following command line to install crseg:

  * ```pip install crossroads-segmentation```

  Dependancies:

  * [OSMnx](https://osmnx.readthedocs.io/) that includes [NetworkX](https://networkx.org/) and [pandas](https://osmnx.readthedocs.io/).
  * [argparse](https://docs.python.org/3/library/argparse.html)



  The computation uses both geometric and semantic information to identify and segment crossroads.



  <img src="images/segmentation-step1.png" width="300px" alt="">



  <img src="images/segmentation-step2.png" width="300px" alt="">



  <img src="images/segmentation-step3.png" width="300px" alt="">



  <img src="images/segmentation-step4.png" width="300px" alt="">



  <img src="images/segmentation-step5.png" width="300px" alt="">


  A paper presenting the algorithms implemented in this tool has been accepted at the AGILE 2022 conference:

  * Favreau, J.-M. and Kalsron, J., *[What are intersections for pedestrian users?](https://agile-giss.copernicus.org/articles/3/4/2022/)*, in proceedings of the 25th AGILE International Conference on Geographic Information Science, Vilnius, Lithuania, 2022. ([presentation](https://github.com/jmtrivial/crossroads-segmentation/raw/master/presentation/JM%20Favreau%20-%20AGILE2022%20-%20presentation%20-%20What%20are%20intersections%20for%20pedestrian%20users.pdf)).

  This tool has been also be presented at [SOTM-fr](https://sotm2022.openstreetmap.fr/) 2022.





  If you installed crossroads-segmentation using pip, a console script is now available using ```get_crossroad_segmentation```. A slightly more complete version is available in the examples folder (```PYTHONPATH=$PWD examples/get-crossroad-segmentation.py```). You will find a complete segmentation of the possible parameters using the ```--help``` parameter.

  This tool is using OSMnx to download OpenStreetMap data from the selected region. It uses a cache, stored in ```cache/``` directory. If a region has already been asked, it will use the cached data and not download it again. You can of course delete the cache directory to download again the data.

  The location of the region can be choosen using coordinates (```--by-coordinates LAT LNG```) or using an predefined coordinate defined by a name in the example version (```--by-name NAME```). A radius (```-r VALUE```) with a default value of 150 meters can be adjusted to choose the size of the region to consider.

  Several outputs are possible:

  * to display the segmentation with all the crossings in the region (```--display-segmentation```), or only focussing on the main crossroad (```--display-main-crossroad```) closest to the input coordinate. This second display gives also the branches of the crossroad.
  * to produce a text version of the selection (```--to-text```, ```--to-text-all```) in the standard output
  * to produce a ```json``` file that contains all the detected crossroads (```--to-json-all FILENAME```) or only the main one (```--to-json FILENAME```). Branches are also contained in this output.


  * 3 parameters (C0, C1 and C2) to drive the creation and merge of the crossroads (see associated publication)
  * a maximum number of crossroads in a ring (```--max-cycle-elements NB```), with default value of 10 for the last step of the segmentation.


  Several of these outputs (```--to-json```, ```--to-json-all```, ```--display-main-crossroad```, ```--to-geopackage```) can be adjusted using the parameter ```--multiscale``` to describe the small crossroad that has been merged to produce the large ones.



  A very basic non regression test is provided in ```test``` directory. Usage:

  * run first ```./regenerate_references.sh```
  * run ```./test.sh``` each time you want to check for regressions



  A separated project is available to evaluate segmentation quality. See [crossroads-evaluation](https://github.com/jmtrivial/crossroads-evaluation).




  ```./get-crossroad-segmentation.py --by-name POC1  --display-main-crossroad --multiscale```

  ![POC1](https://raw.githubusercontent.com/jmtrivial/crossroads-segmentation/master/images/POC1.png)


  ```./get-crossroad-segmentation.py --by-name obélisque  --display-segmentation -r 1000```

  ![R1000](https://raw.githubusercontent.com/jmtrivial/crossroads-segmentation/master/images/R1000.png)


pkgId: 6ff5a57ba901b295665b7f9158d05308172badd2eea42652086e24a10078af41
name: python-crosstab
arch: src
version: 0.0.13
epoch: 0
release: 1
summary: Rearrange data from a normalized CSV format to a crosstabulated format, with styling.
url: https://crosstab.readthedocs.io
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crosstab-0.0.13-1.src.rpm
checksum_type: sha256
description:
  [![ci/cd](https://github.com/geocoug/crosstab/actions/workflows/ci-cd.yaml/badge.svg)](https://github.com/geocoug/crosstab/actions/workflows/ci-cd.yaml)
  [![Documentation Status](https://readthedocs.org/projects/crosstab/badge/?version=latest)](https://crosstab.readthedocs.io/en/latest/?badge=latest)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/crosstab.svg)](https://pypi.org/project/crosstab/)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/crosstab.svg?label=pypi%20downloads)](https://pypi.org/project/crosstab/)
  [![Python Version Support](https://img.shields.io/pypi/pyversions/crosstab.svg)](https://pypi.org/project/crosstab/)

  **crosstab** is a Python package that rearranges data from a normalized CSV format to a crosstabulated format, with styling.

  Go from this:

  ![Crosstab Input](https://raw.githubusercontent.com/geocoug/crosstab/main/crosstab-input.png)

  To this:

  ![Crosstab Output](https://raw.githubusercontent.com/geocoug/crosstab/main/crosstab-output.png)



  You can install **crosstab** via pip from PyPI:

  ```bash
  pip install crosstab
  ```

  There is also a Docker image available on the GitHub Container Registry:

  ```bash
  docker pull ghcr.io/geocoug/crosstab:latest
  ```



  The following examples demonstrate how to use **crosstab** to crosstabulate a CSV file. By default, the output is an Excel file with two sheets: one that contains metadata about the crosstabulation (ie. who ran the script, when it was run, etc.) and another with the data crosstabulated. If the `keep_sqlite` parameter is set to `True`, the SQLite database used to store the source data is kept. The SQLite file will have the same basename as the output Excel file, but with a `.sqlite` extension. If the `keep_src` parameter is set to `True`, the source CSV data is copied to the Excel file as a third sheet.

  Each of the examples below will produce the exact same output.



  ```python
  from pathlib import Path

  from crosstab import Crosstab

  Crosstab(
      incsv=Path("data.csv"),
      outxlsx=Path("crosstabbed_data.xlsx"),
      row_headers=("location", "sample"),
      col_headers=("cas_rn", "parameter"),
      value_cols=("concentration", "units"),
      keep_sqlite=True,
      keep_src=True,
  ).crosstab()
  ```



  ```bash
  crosstab -k -s -f data.csv -o crosstabbed_data.xlsx -r location sample -c cas_rn parameter -v concentration units
  ```



  ```bash
  docker run --rm -v $(pwd):/data ghcr.io/geocoug/crosstab:latest -k -s -f /data/data.csv -o /data/crosstabbed_data.xlsx -r location sample -c cas_rn parameter -v concentration units
  ```

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


pkgId: 7ddf782075ef43ef3e25e054e14d21466863ad4aada021311888fddcde9192b6
name: python-crosstech-py-tools
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Common functions, classes and interfaces that CrossTech uses in its python development.
url: https://pypi.org/project/crosstech-py-tools/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crosstech-py-tools-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Commonly used python functions and interfaces for CrossTech python development. If you are a _developer_ of this library check out [this documentation](docs/dev.md).

  - [📥 Install](#install)
    - [pip](#pip)
    - [poetry](#poetry)
  - [🏭 Modules](#modules)
    - [☁️ Cloud Funcs](#cloud-funcs)
    - [💽 Database](#database)
    - [🗺️ Location](#location)
    - [🚂 Mileage](#mileage)
    - [👷 ELRs](#elrs)



  To install the library use the commands provided below.


  ```shell
  pip install crosstech-py-tools
  ```


  ```shell
  poetry add crosstech-py-tools
  ```

  > [!WARNING]
  > When trying to add this library to an existing project using poetry, be aware that it is reliant on a large number of dependencies, meaning adding it will require some labour to sort out any conflicts. Hence, it is recommended to start your project by adding this library **first**.





  [☁️ Cloud Funcs documentation.](docs/cloud_funcs.md) This module focuses on simplifying the process of testing cloud functions by simulated calls in-code. It provides a wrapper `make_request` around Flask call, which removes the boilerplate code needed to call the cloud function normally.

  ```python
  from crosstech.clound_funcs import make_request
  ```



  [💽 Database documentation.](docs/database.md) This module provides a database interface that is proven to work in cloud functions. The `BaseDB` object can be used in an inheritance relationship or be injected into a function. Either way, this will save time on setting up the boilerplate necessary to connect to the database.

  ```python
  from crosstech.database import BaseDB
  ```



  [🗺️ Location documentation.](docs/location.md) This module contains an array of tools useful for analysing and manipulating location data.

  The `explore` function can take in geopandas GeoDataFrames and plot them all on a single map. The `LocTools` object helps with converiting between shapely points and latitude & longitude pairs and vice versa, as well as extracting points from mileages for an ELR. Finally, `TrackGeoJSON` object serves to assist in downloading track geojsons using a single function.

  ```python
  from crosstech.location import explore, LocTools, TrackGeoJSON
  ```



  [🚂 Mileage documentation.](docs/mileage.md) This module contains an object which helps in converting mileages from _Miles.Yards_ to decimal miles, or _Miles.Chains_ to decimal miles, and vice versa.

  ```python
  from crosstech.mileage import MilesYards
  ```



  [👷 ELRs documentation](docs/elrs.md) This module contains objects that help with downloading our Network Models. For more extensive documentation about the Network Model see [this article.](https://docs.crosstech.co.uk/doc/network-model-kfGqIB0lxL)

  ```python
  from crosstech.elrs import FullModel, SimplifiedModel
  ```


pkgId: 189e1e33a775729acacea6889aa2d165d0ccc6699ecca43e5ff21a43488a170b
name: python-crosstl
arch: src
version: 0.0.1.3
epoch: 0
release: 1
summary: CrossGL: Revolutionizing Shader Development
url: https://crossgl.net/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crosstl-0.0.1.3-1.src.rpm
checksum_type: sha256
description:
  <div style="display: block;" align="center">
      <img class="dark-light" width="5%" >
      <a href="https://crossgl.net/">
          <img class="dark-light" height="5%" width="5%" src="https://github.com/samthakur587/docs2.0/blob/main/web_icon.png">
      </a>
      <img class="dark-light" width="5%" >
      <a href="https://crossgl.github.io/language.html">
          <img class="dark-light" height="5%" width="5%" src="https://github.com/samthakur587/docs2.0/blob/main/docs.png">
      </a>
      <img class="dark-light" width="5%" >
      <a href="https://github.com/CrossGL/demos">
          <img class="dark-light" height="5%" width="5%" src="https://github.com/samthakur587/docs2.0/blob/main/written.png">
      </a>
      <img class="dark-light" width="5%" >
      <a href="https://crossgl.github.io/design.html">
          <img class="dark-light" height="5%" width="5%" src="https://github.com/samthakur587/docs2.0/blob/main/strategic-plan.png">
      </a>
  </div>
  <br>
  <div style="margin-top: 10px; margin-bottom: 10px; display: block;" align="center">
      <a href="https://github.com/CrossGL/crosstl/issues">
          <img class="dark-light" style="padding-right: 4px; padding-bottom: 4px;" src="https://img.shields.io/github/issues/CrossGL/crosstl">
      </a>
      <a href="https://github.com/CrossGL/crosstl/network/members">
          <img class="dark-light" style="padding-right: 4px; padding-bottom: 4px;" src="https://img.shields.io/github/forks/CrossGL/crosstl">
      </a>
      <a href="https://github.com/CrossGL/crosstl/stargazers">
          <img class="dark-light" style="padding-right: 4px; padding-bottom: 4px;" src="https://img.shields.io/github/stars/CrossGL/crosstl">
      </a>
      <a href="https://github.com/CrossGL/crosstl/pulls">
          <img class="dark-light" style="padding-right: 4px; padding-bottom: 4px;" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg">
      </a>
      <a href="https://pypi.org/project/crosstl/">
          <img class="dark-light" style="padding-right: 4px; padding-bottom: 4px;" src="https://badge.fury.io/py/crosstl.svg">
      </a>
      <a href="https://discord.com/invite/uyRQKXhcyW">
          <img class="dark-light" style="padding-right: 4px; padding-bottom: 4px;" src="https://img.shields.io/discord/1240998239206113330?color=blue&label=%20&logo=discord&logoColor=white">
      </a>
  </div>
  <br clear="all" />

  The CrossTL is a core component of our platform, enabling the conversion of CrossGL shader code directly into various graphics APIs, such as DirectX, Metal, Vulkan, and OpenGL and vice-versa. This translator simplifies shader development by allowing a single, unified shader language to be used across multiple platforms.


  In the ever-evolving world of graphics programming, **CrossGL** emerges as a solution to bridge the gap between diverse graphics APIs.

  Imagine writing a shader _once_ and deploying it across:
  - 🍎 **Metal**
  - 🎮 **DirectX**
  - 🖥️ **OpenGL**
  - 🖥️ **Vulkan**
  - 🔥 **Mojo**

  - Metal
  - DirectX
  - OpenGL

  1. **⏱️ Time-Saving**: Slash development time by eliminating the need for multiple shader versions.
  2. **🛠️ Consistency**: Ensure uniform behavior across all platforms.
  3. **🧠 Simplified Learning Curve**: Master one language instead of many.
  4. **🔍 Enhanced Debugging**: Develop universal tools for shader analysis.
  5. **🔮 Future-Proof**: Easily adapt to new graphics APIs as they emerge.

  The translator takes CrossGL shader code and processes it through several stages:
  1. **Parsing**: The code is parsed into an abstract syntax tree (AST).
  2. **Intermediate Representation**: The AST is converted into an intermediate representation (IR) for optimization.
  3. **Code Generation**: The IR is translated into the target backend code.
  4. **Optimization**: Various optimization passes are applied to ensure maximum performance.
  5. **Source Output**: The final output is produced and ready for use.

  CrossGL doesn't just translate from a universal language to platform-specific shaders - it also works in reverse! This powerful feature allows developers to convert existing shaders from various platforms into CrossGL.

  ```cpp
  shader main {
      vertex {
          input vec3 position;
          output vec2 vUV;
          void main() {
              vUV = position.xy * 10.0;
              gl_Position = vec4(position, 1.0);
          }
      }
      float perlinNoise(vec2 p) {
          return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
      }
      fragment {
          input vec2 vUV;
          output vec4 fragColor;
          void main() {
              float noise = perlinNoise(vUV);
              float height = noise * 10.0;
              vec3 color = vec3(height / 10.0, 1.0 - height / 10.0, 0.0);
              fragColor = vec4(color, 1.0);
          }
      }
  }
  ```

  First, install CrossGL's translation library using pip:
  ```bash
  pip install crosstl
  ```

  1. Create a CrossGL shader file (e.g., `shader.cgl`):
  ```glsl
  shader main {
      vertex {
          input vec3 position;
          output vec2 vUV;
          void main() {
              vUV = position.xy * 10.0;
              gl_Position = vec4(position, 1.0);
          }
      }
      fragment {
          input vec2 vUV;
          output vec4 fragColor;
          void main() {
              fragColor = vec4(vUV, 0.0, 1.0);
          }
      }
  }
  ```
  2. Translate to your desired backend:
  ```python
  import crosstl

  metal_code = crosstl.translate('shader.cgl', backend='metal', save_shader= 'shader.metal')

  hlsl_code = crosstl.translate('shader.cgl', backend='directx', save_shader= 'shader.hlsl')

  opengl_code = crosstl.translate('shader.cgl', backend='opengl', save_shader= 'shader.glsl')
  ```

  1. write your HLSL shader (e.g., `shader.hlsl`):
  ```hlsl
  struct VS_INPUT {
      float3 position : POSITION;
  };
  struct PS_INPUT {
      float4 position : SV_POSITION;
      float2 uv : TEXCOORD0;
  };
  PS_INPUT VSMain(VS_INPUT input) {
      PS_INPUT output;
      output.position = float4(input.position, 1.0);
      output.uv = input.position.xy * 10.0;
      return output;
  }
  float4 PSMain(PS_INPUT input) : SV_TARGET {
      return float4(input.uv, 0.0, 1.0);
  }
  ```
  2. Convert to CrossGL:
  ```python
  import crosstl
  crossgl_code = crosstl.translate('shader.hlsl', backend='cgl', save_shader= 'shader.cgl')
  print(crossgl_code)
  ```

  1. write your Metal shader (e.g., `shader.metal`):
  ```metal

  using namespace metal;
  struct VertexInput {
      float3 position [[attribute(0)]];
  };
  struct VertexOutput {
      float4 position [[position]];
      float2 uv;
  };
  vertex VertexOutput vertexShader(VertexInput in [[stage_in]]) {
      VertexOutput out;
      out.position = float4(in.position, 1.0);
      out.uv = in.position.xy * 10.0;
      return out;
  }
  fragment float4 fragmentShader(VertexOutput in [[stage_in]]) {
      return float4(in.uv, 0.0, 1.0);
  }
  ```
  2. Convert to CrossGL:
  ```python
  import crosstl
  crossgl_code = crosstl.translate('shader.metal', backend='cgl')
  print(crossgl_code)
  ```
  With these examples, you can easily get started with CrossGL, translating between different shader languages, and integrating existing shaders into your CrossGL workflow. Happy shader coding! 🚀✨
  For more deep dive into crosstl , check out our [Getting Started Notebook](https://colab.research.google.com/drive/1reF8usj2CA5R6M5JSrBKOQBtU4WW-si2?usp=sharing#scrollTo=D7qkQrpcQ7zF).

  We believe that everyone can contribute and make a difference. Whether
  it\'s writing code, fixing bugs, or simply sharing feedback,
  your contributions are definitely welcome and appreciated 🙌
  find out more info in our [Contributing guide](https://crossgl.github.io/contribution.html)
  <a href="https://github.com/CrossGL/crosstl/graphs/contributors">
    <img src="https://contrib.rocks/image?repo=CrossGL/crosstl" />
  </a>

  <b> Stay connected and follow our latest updates and announcements </b>
  - [Twitter](https://x.com/crossGL_)
  - [LinkedIn](https://www.linkedin.com/company/crossgl/?viewAsMember=true)
  - [Discord Channel](https://discord.com/invite/uyRQKXhcyW)
  - [YouTube](https://www.youtube.com/channel/UCxv7_flRCHp7p0fjMxVSuVQ)
  <b> See you there! </b>
  <br>
  <br>

  The CrossGL Translator is open-source and licensed under the [License](https://github.com/CrossGL/crosstl/blob/main/LICENSE).
  <br>
  Thank you for using the CrossGL Translator!
  The CrossGL Team


pkgId: 52fe3a6118d898dbf5a8d291cd0af9ed8f06ecf1fd739dd134fc318e39158a48
name: python-crossword-puzzle
arch: src
version: 2.2.97
epoch: 0
release: 1
summary: Select, generate and play always-unique crosswords.
url: https://github.com/tomasvana10/crossword_puzzle
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crossword-puzzle-2.2.97-1.src.rpm
checksum_type: sha256
description:
  `crossword_puzzle` was renamed to `xpuz` on 11/07/2024. Visit the new PyPi project page [here](https://pypi.org/project/xpuz/).


pkgId: 10bc84f3e01dab5d145eaadd99de095b96adf004d2f4d2ff57d8cd7b48324028
name: python-croston
arch: src
version: 0.1.2.4
epoch: 0
release: 1
summary: croston model for intermittent time series
url: https://github.com/HamidM6/croston
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-croston-0.1.2.4-1.src.rpm
checksum_type: sha256
description:
  A python package to forecast intermittent time series using croston's method

  [readthedocs: croston](https://croston.readthedocs.io/en/latest/)

  example:
  ```

  import numpy as np
  import random
  from croston import croston
  import matplotlib.pyplot as plt


  a = np.zeros(50)
  val = np.array(random.sample(range(100,200), 10))
  idxs = random.sample(range(50), 10)

  ts = np.insert(a, idxs, val)

  fit_pred = croston.fit_croston(ts, 10,'original')

  yhat = np.concatenate([fit_pred['croston_fittedvalues'], fit_pred['croston_forecast']])

  plt.plot(ts)
  plt.plot(yhat)
  ```


pkgId: 93467a1d9f3c2021d5877076fbe621a2a59d790f07eacfe47113751248f2b81b
name: python-croudtech-bootstrap
arch: src
version: 0.1.56
epoch: 0
release: 1
summary: Applicaton config via AWS S3 and AWS Secrets Manager
url: https://pypi.org/project/croudtech-bootstrap/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-croudtech-bootstrap-0.1.56-1.src.rpm
checksum_type: sha256
description:
  This script is used to push and pull secrets, s3 config and ssm values for use in applications.





  ```
  Usage: croudtech-bootstrap put-config [OPTIONS] VALUES_PATH

  Options:
    --prefix TEXT   The path prefix (Name prefix used when storing secrets and SSM values)
    --region TEXT   The AWS region (Defaults to the current region set using AWS_DEFAULT_REGION or AWS_REGION env vars)
    --delete-first  Delete the values in this path before pushing (useful for cleanup) This will remove any values with the current path prefix that aren't included in the files we're pushing.
    --help          Show this message and exit.
  ```

  The put-config command requires the following file structure:

  ```
  ├── ENVIRONMENT_NAME_1
  │   ├── common.yaml
  │   ├── common.secret.yaml
  │   ├── AppConfig1.yaml
  │   ├── AppConfig1.secret.yaml
  │   ├── AppConfig2.yaml
  │   └── AppConfig2.secret.yaml
  ├── ENVIRONMENT_NAME_2
  │   ├── common.yaml
  │   ├── common.secret.yaml
  │   ├── AppConfig1.yaml
  │   ├── AppConfig1.secret.yaml
  │   ├── AppConfig2.yaml
  │   └── AppConfig2.secret.yaml
  ```

  Running `python -m croudtech-bootstrap put-config CONFIG_FILES_PATH` will create config for AppConfig1 and AppConfig2 in both defined environments.

  common.yaml and common.secret.yaml files contain shared config that will be used for all applications.



  ```
  Usage: croudtech-bootstrap get-config [OPTIONS]

  Options:
    --environment-name TEXT         The environment name  [required]
    --app-name TEXT                 The app name  [required]
    --prefix TEXT                   The path prefix
    --region TEXT                   The AWS region
    --include-common / --ignore-common
                                    Include shared variables
    --output-format [json|yaml|environment|environment-export]
    --parse-redis-param / --ignore-redis-param
                                    Parse redis host and allocate a redis
                                    database number. Requires network access to the redis instance
    --help                          Show this message and exit.
  ```

  Using the put-config example above we can pull the config as follows

  ```
  croudtech-bootstrap get-config --environment-name ENVIRONMENT_NAME_1 --app-name AppConfig1 --output-format environment
  ```



  `pip install croudtech-bootstrap`


pkgId: 95f3dc9d41ae61fc10eea778c77893db49cd35af1ce59645b0f80ce4bbc0ed28
name: python-crow-api.core
arch: src
version: 2.4.0
epoch: 0
release: 1
summary: AWS CDK Construct to create a serverless API based on file structure.
url: https://github.com/thomasstep/crow-api
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crow-api.core-2.4.0-1.src.rpm
checksum_type: sha256
description:
  Crow API lets you build an API intuitively based on the file structure of a project. Provide API Gateway and Lambda function configurations and crow will build out the appropriate paths and methods to the API Gateway. All created resources are available after initialization. `lambdaFunctions` will expose all Lambda functions created for further operations like adding environment variables and providing permissions.

  | `crow-api` version | `aws-cdk` version | Notes                   |
  | ------------------ | ----------------- | ----------------------- |
  | 0                  | 1                 |                         |
  | 1                  | 2                 | Not recommended for use |
  | 2                  | 2                 |                         |

  Contents:

  * [Getting Started](#getting-started)
  * [Example File Structure](#example-file-structure)
  * [Crow API Props](#crow-api-props)

    * [`sourceDirectory`](#sourcedirectory)
    * [`sharedDirectory`](#shareddirectory)
    * [`useAuthorizerLambda`](#useauthorizerlambda)
    * [`authorizerDirectory`](#authorizerdirectory)
    * [`authorizerLambdaConfiguration`](#authorizerlambdaconfiguration)
    * [`tokenAuthorizerConfiguration`](#tokenauthorizerconfiguration)
    * [`createApiKey`](#createapikey)
    * [`logRetention`](#logretention)
    * [`apiGatewayName`](#apigatewayname)
    * [`apiGatewayConfiguration`](#apigatewayconfiguration)
    * [`lambdaConfigurations`](#lambdaconfigurations)
    * [`lambdaIntegrationOptions`](#lambdaintegrationoptions)
    * [`models`](#models)
    * [`requestValidators`](#requestValidators)
    * [`methodConfigurations`](#methodconfigurations)
  * [Properties](#properties)

    * [`gateway`](#gateway)
    * [`authorizer`](#authorizer)
    * [`authorizerLambda`](#authorizerlambda)
    * [`lambdaLayer`](#lambdalayer)
    * [`lambdaFunctions`](#lambdafunctions)
    * [`models`](#models)
    * [`requestValidators`](#requestValidators)



  [Start your application as a normal CDK app](https://docs.aws.amazon.com/cdk/v2/guide/getting_started.html)

  ```sh
  npm install -g aws-cdk
  cdk bootstrap # If this is your first cdk app, you will need to bootstrap your AWS account
  cdk init app --language typescript
  ```

  Next, install the Crow API package

  ```sh
  npm install --save crow-api
  ```

  In the `lib/` folder generated by the `cdk`, there should be a single file named `<your-app>-stack.js`. Create your Crow API construct inside of that file like so

  ```python

  from aws_cdk import Stack, StackProps
  from constructs import Construct
  from crow_api import CrowApi, ICrowApiProps

  class YourAppStack(Stack):
      def __init__(self, scope, id, props):
          super().__init__(scope, id, props)

          {
                crowApiProps,
              } = props

          api = CrowApi(self, "api", {
              (SpreadAssignment ...crowApiProps
                crow_api_props)
          })
  ```

  Your API will start to take shape as you create folders to define paths and methods (see Example File Structure below). To deploy your API, simply run `cdk synth` and `cdk deploy`. Follow the instructions as they are prompted, and you will end up receiving a URL where your API now lives.



  ```
  |-- src/
      |-- authorizer/
          |-- index.js
      |-- v1/
          |-- book/
              |-- get/
                  |-- index.js
              |-- post/
                  |-- index.js
          |-- chapters/
              |-- get/
                  |-- index.js
          |-- authors/
              |-- get/
                  |-- index.js
              |-- post/
                  |-- index.js
  ```

  The preceding file structure will create an API with the following routes:

  * GET /v1/book
  * POST /v1/book
  * GET /v1/book/chapters
  * GET /v1/authors
  * POST /v1/authors

  There needs to be an `index.js` file inside of a folder named after an HTTP method in order for a path to be created. The `index.js` file needs to export a `handler` method that will process the payload and return like the following.

  ```javascript
  exports.handler = async function (event, context, callback) {
    try {
      const data = {
        statusCode: 201,
      };
      return data;
    } catch (uncaughtError) {
      console.error(uncaughtError);
      throw uncaughtError;
    }
  }
  ```



  Crow API takes in a few props to help you customize away from defaults.



  By default, Crow walks through the `src` directory in the root of the repository to determine routes and methods, but you can change the top level directory by passing in the `sourceDirectory` prop. The string passed in should not start with or end with a slash (`/`). For example, `src`, `api/src`, or `source` are all valid options to pass in through that prop.



  By default, Crow creates a Lambda layer out of the `shared` directory in the source directory of the repository, but you can change the name of the shared directory by passing in the `sharedDirectory` prop. The string passed in should not start with or end with a slash (`/`) and must be a direct child of the source directory. For example, `common` or `utils` are valid but `shared/utils` is not.

  The Lambda layer created will be prepended to any the of the layers passed in through `lambdaConfigurations` and added to all Lambda functions created.



  Crow will create and attach an authorizer Lambda to specific methods if requested. The `useAuthorizerLambda` prop tells the `CrowApi` Construct that it should create an authorizer Lambda and accepts a boolean value. This is `false` by default.



  Crow will allow for a Lambda authorizer to be created and used by specific methods if requested. The `authorizerDirectory` prop tells Crow where to find the code for the Lambda authorizer **within the source directory which can be specified in the `sourceDirectory` prop**. It expects to find an `index.js` file that exports a `handler` function within the `authorizerDirectory`.

  By default, Crow expects to find a directory called `src/authorizer` containing the authorizer Lambda source if the `useAuthorizerLambda` prop is `true`. If a different directory within the source directory should be looked at for this code, it should be specified by passing in a string to the `authorizerDirectory` prop. The string passed in should not start with nor end with a slash (`/`). For example, `auth` or `authLambdaSrc` are valid.



  The `authorizerLambdaConfiguration` prop is passed directly to the Lambda functions which will be in charge of your API's authorization. The configuration allowed is exactly the same as the [Lambda Function props](https://docs.aws.amazon.com/cdk/api/v2//docs/aws-cdk-lib.aws_lambda.Function.html).



  The `tokenAuthorizerConfiguration` prop is passed directly to the `APIGateway.TokenAuthorizer` construct which will be in charge of your API's authorization. Anything available in the [class constructor for the `TokenAuthorizer`](https://docs.aws.amazon.com/cdk/api/v2//docs/aws-cdk-lib.aws_apigateway.TokenAuthorizer.html) can be overridden.

  **Note:**

  Be careful with this configuration item as all configuration here takes precedence over Crow defaults. I suggest not using this configuration item unless you are experienced with the AWS CDK, API Gateway, and Lambda.



  By default, Crow does not create an API key associated with the API. If an API key is desired, pass in the `createApiKey` prop as `true`.



  By default, Crow creates log groups for resources it creates and sets the log retention to one week. If a different retention is desired pass in the `logRetention` prop of [enum type `RetentionDays`](https://docs.aws.amazon.com/cdk/api/v2//docs/aws-cdk-lib.aws_logs.RetentionDays.html).



  This props allows for more complex overrides to the API Gateway that fronts your API. The configuration allowed is exactly the same as the [RestApi props](https://docs.aws.amazon.com/cdk/api/v2//docs/aws-cdk-lib.aws_apigateway.RestApi.html).

  **Note:**

  Be careful with this configuration item as all configuration here takes precedence over Crow defaults. I suggest not using this configuration item unless you are experienced with the AWS CDK and API Gateway.

  An example of this prop might look like the following:

  ```python

  from source_map_support.register import
  import aws_cdk as cdk
  import aws_cdk.aws_apigateway as apigateway
  from ...lib.crow_api_stack import CrowApiStack

  dev_environment = {
      "account": "123456789012",
      "region": "us-east-1"
  }

  app = cdk.App()

  CrowApiStack(app, "CrowApiStack",
      env=dev_environment,
      api_gateway_configuration={
          "endpoint_configuration": {
              "types": [apigateway.EndpointType.REGIONAL]
          }
      }
  )
  ```



  This is a simple prop that names the API Gateway. This is how the API will be identified in the AWS console. The value should be a string without spaces and defaults to `crow-api`.



  This props allows for more complex overrides to Lambda functions. The prop is an object with keys corresponding to the API path of a Lambda function and a value corresponding to the configuration that should be applied to the Lambda. The configuration allowed is exactly the same as the [Lambda Function props](https://docs.aws.amazon.com/cdk/api/v2//docs/aws-cdk-lib.aws_lambda.Function.html).

  **Note:**

  Be careful with this configuration item as all configuration here takes precedence over Crow defaults. I suggest not using this configuration item unless you are experienced with the AWS CDK and Lambda.

  An example of this prop might look like the following:

  ```python

  from source_map_support.register import
  import aws_cdk as cdk
  from ...lib.crow_api_stack import CrowApiStack

  dev_environment = {
      "account": "123456789012",
      "region": "us-east-1"
  }

  app = cdk.App()

  CrowApiStack(app, "CrowApiStack",
      env=dev_environment,
      lambda_configurations={
          "/v1/book/get": {
              "timeout": cdk.Duration.seconds(5)
          }
      }
  )
  ```



  This prop is an object with keys corresponding to the API path of a Lambda function and a value corresponding to the configuration that should be applied to the Lambda Integration. The configuration allowed is exactly the same as the [LambdaIntegrationOptions](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.LambdaIntegrationOptions.html).



  This prop helps set up the `Model`s used in `methodConfiguration` above. It is an array of `CrowModelOptions` which are the same as [`MethodOptions`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.ModelOptions.html) except that the `modelName` is required. The `Model`s will receive an ID equal to its `modelName` which is why that prop is required. The `IModel` can then be referenced in `methodConfigurations` using its `modelName`.



  This prop helps set up the `RequestValidator`s used in `methodConfiguration` above. It is an array of `CrowRequestValidatorOptions` which are the same as [`RequestValidatorOptions`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.RequestValidatorOptions.html) except that the `requestValidatorName` is required. The `RequestValidator`s will receive an ID equal to its `requestValidatorName` which is why that prop is required. The `IRequestValidator` can then be referenced in `methodConfigurations` using its `requestValidatorName`.



  This prop allows for more complex overrides to individual methods. The prop is an object with keys corresponding to the API path of a method and a value corresponding to the configuration that should be applied to the method as well as the key `useAuthorizerLambda` which will invoke the authorizer Lambda whenever the method is called. The configuration allowed is almost exactly the same as [`MethodOptions`](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway.MethodOptions.html) plus the `useAuthorizerLambda` boolean.

  The differences between `MethodOptions` and Crow's `CrowMethodConfiguration` (the type for this prop) is that any value referencing `{ [string]: IModel }` (`MethodOptions.requestModels` and `MethodResponse.responseModels`) has been changed to `{ [string]: string }` and similarly `requestValidator` has been changed from `IRequestValidator` to `string`. The strings that are passed should correspond with the `modelName`s or `requestValidatorName`s used in the [`models`](#models) and [`requestValidators`](#requestvalidators) props (see next sections).

  **Note:**

  If `createApiKey` is `true`, then the `apiKeyRequired` parameter will need to be set for the methods needing the API key.

  An example of this prop might look like the following:

  ```python

  from source_map_support.register import
  import aws_cdk as cdk
  from ...lib.crow_api_stack import CrowApiStack

  dev_environment = {
      "account": "123456789012",
      "region": "us-east-1"
  }

  app = cdk.App()

  CrowApiStack(app, "CrowApiStack",
      env=dev_environment,
      models=[{
          "model_name": "authorsPost",
          "schema": {
              "schema": apigateway.JsonSchemaVersion.DRAFT4,
              "title": "/v1/authors/post",
              "type": apigateway.JsonSchemaType.OBJECT,
              "required": ["name"],
              "properties": {
                  "name": {
                      "type": apigateway.JsonSchemaType.STRING
                  }
              }
          }
      }
      ],
      method_configurations={
          "/v1/authors/post": {
              "api_key_required": True,
              "request_models": {
                  "application/json": "authorsPost"
              }
          },
          "/v1/book/get": {
              "use_authorizer_lambda": True
          },
          "/v1/book/post": {
              "api_key_required": True
          }
      }
  )
  ```



  A `CrowApi` construct will give full access to all of the resources it created.



  This is the `apigateway.RestApi` that all of the created Lambda functions sit behind.



  This is the `apigateway.UsagePlan` associated with the API Gateway and pre-created API key if that is enabled.



  This is the `apigateway.IAuthorizer` that is attached to the API Gateway.



  This is the `lambda.Function` that authorizes API Gateway requests.



  If the `sharedDirectory` is populated, this is the `lambda.LayerVersion` created for that code. If the `sharedDirectory` is not populated, then this is `undefined`.



  This is an object with keys being the API paths and the values being the `lambda.Function`s sitting being them. Continuing off of the example file structure from above, the following would be an example of referencing `GET` `/v1/book/chapters`.

  ```python

  from aws_cdk import Stack, StackProps
  from constructs import Construct
  from crow_api import CrowApi, ICrowApiProps

  class YourAppStack(Stack):
      def __init__(self, scope, id, props):
          super().__init__(scope, id, props)

          {
                crowApiProps,
              } = props

          api = CrowApi(self, "api", {
              (SpreadAssignment ...crowApiProps
                crow_api_props)
          })

          lambda_ = api.lambda_functions["/v1/book/chapters/get"]
          lambda_.add_environment("FOO", "bar")
  ```



  This is an object with keys being the `modelName`s and values being the `IModel`s created.



  This is an object with keys being the `requestValidatorName`s and values being the `IRequestValidator`s created.


pkgId: d141f3ea116be496ab16eb8ceaa1242eeb478554a7ee15632d9bc64ddd5cf531
name: python-crowbar-package-manager
arch: src
version: 0.1.16
epoch: 0
release: 1
summary: a local-first tool for managing python dependencies with pip
url: https://pypi.org/project/crowbar-package-manager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowbar-package-manager-0.1.16-1.src.rpm
checksum_type: sha256
description:
  <br>



  Crowbar is a tool for managing your dependencies in Python projects. Inspired by tools like NPM in the JavaScript ecosystem, it installs your dependencies with your project and frees you from the need to think about virtual environments or keep track of your dependencies yourself.

  <br>



  Crowbar is for any Python developer, but it works especially well with someone who uses the vanilla path of dependency management (pip, venv, requirements.txt) and wants to automate some of this workflow.

  It's probably not for you if you're deeply embedded in an alternate ecosystem like Conda.

  <br>



  I'll walk you through the steps of starting a Django project, so you can get a feel for the crowbar mental model.

  First, install crowbar:

  ```
  pip install crowbar-package-manager
  ```

  Create and/or enter your project directory and then use crowbar to install Django:

  ```
  crowbar install django
  ```

  Note: any instance of ```crowbar``` can be replaced with ```cb```

  ```crowbar install <package name>``` uses pip to install your package to a virtual environment folder (named venv by default), records it to requirements.txt, and creates a .gitignore file with venv listed.

  Start a new Django project:

  ```
  crowbar django-admin startproject project_name .
  ```
  Notice that we didn't need to activate a virtual environment - using ```crowbar``` before your command means that it runs using the dependencies in your venv folder automatically.

  Run the Django development server:

  ```
  crowbar manage.py runserver
  ```

  You can also use ```crowbar``` to run a Python file, so in this case you don't put ```python``` before ```manage.py```


  <br>



  Crowbar uese pip and venv under the hood. It essentially runs the same commands that you would, but automates the process.

  It is worth explaining how crowbar finds the nearest environment folder. It does this by looking for an environment folder at the current directory and progressively looking in higher directories until it finds an environment folder or reaches the root directory. The name of the environment folder it looks for can be changed by the user, but defaults to venv.

  The benefit of this search is that you can run crowbar commands from anywhere within your project as long as your dependencies are stored in the main directory of your project.

  There is a potential problem though if you have an environment folder in a directory above your current directory. For example, if you have a venv folder on your desktop and then you create a project on your desktop named my_project, enter that directory and type ```crowbar install pandas```, pandas will be installed in the venv folder on your desktop.

  If you are concerned that this might be a problem for you, you can simply run ```crowbar check env``` to see if crowbar can detect any environment folders at your current directory or above and, if you find any that you want to avoid installing packages to, you can run ```crowbar create env``` to force crowbar to create a new environment folder in your current directory.



  Note: any instance of ```crowbar``` can be replaced with ```cb```


  ```
  crowbar install <package_name> <package_name>
  ```
  -Checks to see if there is an environment folder based on the name you've set (venv is the default) in the current directory or in directories above
  -Creates a virtual environment called venv if it does not exist<br>
  -Installs a package (or packages) from pypi into venv<br>
  -Updates requirements.txt and creates one if it does not exist

  ```
  crowbar uninstall <package_name> <package_name>
  ```
  -Uninstalls a package (or packages) from venv
  -Updates requirements.txt

  ```
  crowbar install
  ```
  -Installs all packages listed in requirements.txt

  ```
  crowbar <file_name>.py
  ```
  -Runs a python file using the contents of the local venv

  ```
  crowbar show name
  ```
  -Lists the current name of the environment folder that crowbar creates (venv is the default)

  ```
  crowbar name <environment name>
  ```
  -Changes the name of the environment folder that crowbar creates (venv is the default)

  ```
  crowbar check env
  ```
  -Checks to see if there is an environment folder based on the name you've set (venv is the default) in the current directory or in directories above

  ```
  crowbar create env
  ```
  -Creates an environment folder in the current directory based on the name you've set (venv is the default)

  ```
  crowbar show gitignore
  ```
  -Indicates whether Crowbar is set to create a .gitignore file when it creates an environment folder (default is to create .gitignore)

  ```
  crowbar gitignore on
  ```
  -Instructs Crowbar to create a .gitignore file when it creates an environment folder and add the name of that folder to the .gitignore file (this is the default)

  ```
  crowbar gitignore off
  ```
  -Instructs Crowbar not to create a .gitignore file when it creates an environment folder

  ```
  crowbar show config
  ```
  -Lists all current configurable settings (environment folder name and gitignore on/off)

  Warning – you may have pip muscle memory which may cause you to accidentally install globally. Use crowbar/cb and not pip if you are not in an active virtual environment.

  <br>



  ```
  crowbar --global install <package_name>
  ```
  ```
  cb -g uninstall <package_name>
  ```
  -installs or uninstalls a package globally

  <br>



  With the crowbar command you can run any commands installed in the virtual environment.

  Example - starting a new Django project:

  ```
  cb django-admin startproject project_name .
  ```

  Running the Django development server:

  ```
  cb manage.py runserver
  ```

  <br>



  Crowbar does not support Conda. Crowbar has plans to support UV eventually.


pkgId: 3c2cd352a4fe7bba4958792e17c5342e86ba0af8aabceffc4a024828e57ef5b5
name: python-crowd-kit
arch: src
version: 1.4.1
epoch: 0
release: 1
summary: Computational Quality Control for Crowdsourcing
url: https://github.com/Toloka/crowd-kit
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowd-kit-1.4.1-1.src.rpm
checksum_type: sha256
description:
  [![Crowd-Kit](https://tlk.s3.yandex.net/crowd-kit/Crowd-Kit-GitHub.png)](https://github.com/Toloka/crowd-kit)

  [![PyPI Version][pypi_badge]][pypi_link]
  [![GitHub Tests][github_tests_badge]][github_tests_link]
  [![Codecov][codecov_badge]][codecov_link]
  [![Documentation][docs_badge]][docs_link]
  [![Paper][paper_badge]][paper_link]

  [pypi_badge]: https://badge.fury.io/py/crowd-kit.svg
  [pypi_link]: https://pypi.python.org/pypi/crowd-kit
  [github_tests_badge]: https://github.com/Toloka/crowd-kit/actions/workflows/tests.yml/badge.svg?branch=main
  [github_tests_link]: https://github.com/Toloka/crowd-kit/actions/workflows/tests.yml
  [codecov_badge]: https://codecov.io/gh/Toloka/crowd-kit/branch/main/graph/badge.svg
  [codecov_link]: https://codecov.io/gh/Toloka/crowd-kit
  [docs_badge]: https://readthedocs.org/projects/crowd-kit/badge/
  [docs_link]: https://crowd-kit.readthedocs.io/
  [paper_badge]: https://joss.theoj.org/papers/10.21105/joss.06227/status.svg
  [paper_link]: https://doi.org/10.21105/joss.06227

  **Crowd-Kit** is a powerful Python library that implements commonly-used aggregation methods for crowdsourced annotation and offers the relevant metrics and datasets. We strive to implement functionality that simplifies working with crowdsourced data.

  Currently, Crowd-Kit contains:

  * implementations of commonly-used aggregation methods for categorical, pairwise, textual, and segmentation responses;
  * metrics of uncertainty, consistency, and agreement with aggregate;
  * loaders for popular crowdsourced datasets.

  Also, the `learning` subpackage contains PyTorch implementations of deep learning from crowds methods and advanced aggregation algorithms.



  To install Crowd-Kit, run the following command: `pip install crowd-kit`. If you also want to use the `learning` subpackage, type `pip install crowd-kit[learning]`.

  If you are interested in contributing to Crowd-Kit, use [uv](https://github.com/astral-sh/uv) to manage the dependencies:

  ```shell
  uv venv
  uv pip install -e '.[dev,docs,learning]'
  uv tool run pre-commit install
  ```

  We use [pytest](https://pytest.org/) for testing and a variety of linters, including [pre-commit](https://pre-commit.com/), [Black](https://github.com/psf/black), [isort](https://github.com/pycqa/isort), [Flake8](https://github.com/pycqa/flake8), [pyupgrade](https://github.com/asottile/pyupgrade), and [nbQA](https://github.com/nbQA-dev/nbQA), to simplify code maintenance.



  This example shows how to use Crowd-Kit for categorical aggregation using the classical Dawid-Skene algorithm.

  First, let us do all the necessary imports.

  ````python
  from crowdkit.aggregation import DawidSkene
  from crowdkit.datasets import load_dataset

  import pandas as pd
  ````

  Then, you need to read your annotations into Pandas DataFrame with columns `task`, `worker`, `label`. Alternatively, you can download an example dataset:

  ````python
  df = pd.read_csv('results.csv')  # should contain columns: task, worker, label

  ````

  Then, you can aggregate the workers' responses using the `fit_predict` method from the **scikit-learn** library:

  ````python
  aggregated_labels = DawidSkene(n_iter=100).fit_predict(df)
  ````

  [More usage examples](https://github.com/Toloka/crowd-kit/tree/main/examples)



  Below is the list of currently implemented methods, including the already available (✅) and in progress (🟡).



  | Method | Status |
  | ------------- | :-------------: |
  | [Majority Vote](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.majority_vote.MajorityVote) | ✅ |
  | [One-coin Dawid-Skene](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.dawid_skene.OneCoinDawidSkene) | ✅ |
  | [Dawid-Skene](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.dawid_skene.DawidSkene) | ✅ |
  | [Gold Majority Vote](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.gold_majority_vote.GoldMajorityVote) | ✅ |
  | [M-MSR](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.m_msr.MMSR) | ✅ |
  | [Wawa](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.wawa.Wawa) | ✅ |
  | [Zero-Based Skill](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.zero_based_skill.ZeroBasedSkill) | ✅ |
  | [GLAD](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.glad.GLAD) | ✅ |
  | [KOS](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.kos.KOS) | ✅ |
  | [MACE](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.classification.mace.MACE) | ✅ |



  |Method|Status|
  |-|:-:|
  |[Binary Relevance](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.multilabel.binary_relevance.BinaryRelevance)|✅|



  | Method | Status |
  | ------------- | :-------------: |
  | [RASA](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.embeddings.rasa.RASA) | ✅ |
  | [HRRASA](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.embeddings.hrrasa.HRRASA) | ✅ |
  | [ROVER](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.texts.rover.ROVER) | ✅ |



  | Method | Status |
  | ------------------ | :------------------: |
  | [Segmentation MV](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.image_segmentation.segmentation_majority_vote.SegmentationMajorityVote) | ✅ |
  | [Segmentation RASA](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.image_segmentation.segmentation_rasa.SegmentationRASA) | ✅ |
  | [Segmentation EM](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.image_segmentation.segmentation_em.SegmentationEM) | ✅ |



  | Method | Status |
  | -------------- | :---------------------: |
  | [Bradley-Terry](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.pairwise.bradley_terry.BradleyTerry) | ✅ |
  | [Noisy Bradley-Terry](https://toloka.ai/docs/crowd-kit/reference/crowdkit.aggregation.pairwise.noisy_bt.NoisyBradleyTerry) | ✅ |



  |Method|Status|
  |-|:-:|
  |[CrowdLayer](https://toloka.ai/docs/crowd-kit/reference/crowdkit.learning.crowd_layer.CrowdLayer)|✅|
  |[CoNAL](https://toloka.ai/docs/crowd-kit/reference/crowdkit.learning.conal.CoNAL)|✅|



  * Ustalov D., Pavlichenko N., Tseitlin B. (2024). [Learning from Crowds with Crowd-Kit](https://doi.org/10.21105/joss.06227). Journal of Open Source Software, 9(96), 6227

  ```bibtex
  @article{CrowdKit,
    author    = {Ustalov, Dmitry and Pavlichenko, Nikita and Tseitlin, Boris},
    title     = {{Learning from Crowds with Crowd-Kit}},
    year      = {2024},
    journal   = {Journal of Open Source Software},
    volume    = {9},
    number    = {96},
    pages     = {6227},
    publisher = {The Open Journal},
    doi       = {10.21105/joss.06227},
    issn      = {2475-9066},
    eprint    = {2109.08584},
    eprinttype = {arxiv},
    eprintclass = {cs.HC},
    language  = {english},
  }
  ```



  Please use [GitHub Issues](https://github.com/Toloka/crowd-kit/issues) to seek support and submit feature requests. We accept contributions to Crowd-Kit via GitHub as according to our guidelines in [CONTRIBUTING.md](CONTRIBUTING.md).



  &copy; Crowd-Kit team authors, 2020&ndash;2024. Licensed under the Apache License, Version 2.0. See LICENSE file for more details.


pkgId: 43f96dbb8b9601b99ff06169ed193a479e3731e7b7f59f4aa2168aad0b71f5c4
name: python-crowdai-api
arch: src
version: 0.1.22
epoch: 0
release: 1
summary: python api for interacting with crowdAI grading infrastructure
url: https://github.com/crowdai/crowdai_api
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowdai-api-0.1.22-1.src.rpm
checksum_type: sha256
description:
  ![build status](https://api.travis-ci.org/crowdAI/crowdai_api.svg?branch=master)

  python client for server side API of the [crowdai.org](https://www.crowdai.org) webapp.

  * Free software: GNU General Public License v3
  * Documentation: https://crowdai-api.readthedocs.io.



  ```bash
  pip install git+https://github.com/crowdAI/crowdai_api.git
  ```

  ```bash
  git clone https://github.com/crowdAI/crowdai_api
  cd crowdai_api
  pip install -r requirements_dev.txt
  pip install -e .
  ```


  ```python
  from crowdai_api import API as CROWDAI_API
  auth_token="<YOUR CROWDAI AUTH TOKEN>"
  api = CROWDAI_API(auth_token)
  ```


  * with `API_KEY`
  ```python
  api.authenticate_participant(EXAMPLE_API_KEY)
  ```
  * with `username`
  ```python
  api_key = api.authenticate_participant_with_username("spMohanty")
  ```

  ```python

  challenge_id = "test_challenge"
  submissions = api.get_all_submissions(challenge_id)
  print(submissions)
  ```

  ```python
  challenge_id = "test_challenge"
  submission = api.create_submission(challenge_id)
  print(submission)










  ```


  ```python
  submission_id = 5262
  challenge_id = "test_challenge"
  submission = api.get_submission(challenge_id, submission_id)
  ```


  Assuming you have a `submission` object by using `api.create_submission` or `api.get_submission`.
  You can update the submission by :

  ```python

  submission.grading_status = "graded"
  submission.score = 0.98
  submission.score_secondary = 0.98
  submission.update()
  print(submission)










  ```


  ```bash

  cp environ.sh.example environ.sh

  source environ.sh
  pytests tests/
  ```


  S.P.Mohanty <sharada.mohanty@epfl.ch>


pkgId: 92e17eb6208197009d4f3c3228ae112c597bbad78d643364938e3a667c8d936b
name: python-crowdin-api-client
arch: src
version: 1.17.0
epoch: 0
release: 1
summary: Python client library for Crowdin API v2
url: https://github.com/crowdin/crowdin-api-client-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowdin-api-client-1.17.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://support.crowdin.com/assets/logos/symbol/png/crowdin-symbol-cWhite.png">
      <source media="(prefers-color-scheme: light)" srcset="https://support.crowdin.com/assets/logos/symbol/png/crowdin-symbol-cDark.png">
      <img width="150" height="150" src="https://support.crowdin.com/assets/logos/symbol/png/crowdin-symbol-cDark.png">
    </picture>
  </p>



  The Crowdin Python client is a lightweight interface to the Crowdin API. It provides common services for making API requests.

  Crowdin API is a full-featured RESTful API that helps you to integrate localization into your development process. The endpoints that we use allow you to easily make calls to retrieve information and to execute actions needed.

  <div align="center">

  [**`API Client Docs`**](https://crowdin.github.io/crowdin-api-client-python/) &nbsp;|&nbsp;
  [**`Crowdin API`**](https://developer.crowdin.com/api/v2/) &nbsp;|&nbsp;
  [**`Crowdin Enterprise API`**](https://developer.crowdin.com/enterprise/api/v2/)

  [![PyPI](https://img.shields.io/pypi/v/crowdin-api-client?cacheSeconds=3600)](https://pypi.org/project/crowdin-api-client/)
  [![Downloads](https://pepy.tech/badge/crowdin-api-client)](https://pepy.tech/project/crowdin-api-client)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/crowdin-api-client?cacheSeconds=3600)](https://pypi.org/project/crowdin-api-client/)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/crowdin/crowdin-api-client-python/python-package.yml?branch=main&logo=github)
  [![codecov](https://codecov.io/gh/crowdin/crowdin-api-client-python/branch/main/graph/badge.svg?token=sOUWIcNjWO)](https://codecov.io/gh/crowdin/crowdin-api-client-python)
  [![GitHub issues](https://img.shields.io/github/issues/crowdin/crowdin-api-client-python?cacheSeconds=3600)](https://github.com/crowdin/crowdin-api-client-python/issues)
  [![License](https://img.shields.io/github/license/crowdin/crowdin-api-client-python?cacheSeconds=3600)](https://github.com/crowdin/crowdin-api-client-python/blob/master/LICENSE)

  </div>



  ```console
  pip install crowdin-api-client
  ```





  ```python
  from crowdin_api import CrowdinClient

  class FirstCrowdinClient(CrowdinClient):
      TOKEN = "__token__"
      PROJECT_ID = 1 # Optional, set project id for all API's
      ORGANIZATION = "organizationName" # Optional, for Crowdin Enterprise only
      TIMEOUT = 60  # Optional, sets http request timeout.
      RETRY_DELAY = 0.1  # Optional, sets the delay between failed requests
      MAX_RETRIES = 5  # Optional, sets the number of retries
      HEADERS = {"Some-Header": ""}  # Optional, sets additional http request headers
      PAGE_SIZE = 25  # Optional, sets default page size
      EXTENDED_REQUEST_PARAMS = {"some-parameters": ""}  # Optional, sets additional parameters for request

  client = FirstCrowdinClient()


  project_response = client.projects.add_project(name="New project", sourceLanguageId="en")


  projects = client.projects.list_projects()


  projects = client.projects.list_projects(offset=10, limit=20)


  projects = client.projects.list_projects(page=2) # offset=25, limit=25
  ```

  Alternatively, you can create an instance of the CrowdinClient class with params like this:

  ```python
  from crowdin_api import CrowdinClient



  client = CrowdinClient(token='__token__')



  ```



  ```python
  from crowdin_api import CrowdinClient

  client = CrowdinClient(token='__token__')

  file_name = '__path_to_the_file__'

  storage = client.storages.add_storage(open(file_name, 'rb'))

  my_file = client.source_files.add_file(__project_id__, storage['data']['id'], file_name)

  print(my_file)
  ```



  It is possible to fetch all records from paginatable methods (where we have limit and offset in arguments).

  ```python
  from crowdin_api import CrowdinClient

  client = CrowdinClient(token='__token__')


  print(client.projects.with_fetch_all().list_projects())


  print(client.projects.with_fetch_all(1000).list_projects())
  ```



  The `EXTENDED_REQUEST_PARAMS` parameter allows you to set additional parameters for requests. For example, you can configure proxies or certificates.

  The Client uses the [requests](https://pypi.org/project/requests/) library to make HTTP requests. You can pass any parameters that `requests` supports:

  ```python
  def request(
      self,
      method,
      url,
      params=None,
      data=None,
      headers=None,
      cookies=None,
      files=None,
      auth=None,
      timeout=None,
      allow_redirects=True,
      proxies=None,
      hooks=None,
      stream=None,
      verify=None,
      cert=None,
      json=None,
  ):
  ```

  For example, you can set a [proxy](https://requests.readthedocs.io/en/latest/api/#requests.Session.proxies):

  ```python
  from crowdin_api import CrowdinClient

  http_proxy = "http://10.10.1.10:3128"
  https_proxy = "https://10.10.1.11:1080"
  ftp_proxy = "ftp://10.10.1.10:3128"

  proxies = {
    "http": http_proxy,
    "https": https_proxy,
    "ftp": ftp_proxy
  }

  class FirstCrowdinClient(CrowdinClient):
      EXTENDED_REQUEST_PARAMS = {"proxies": proxies}
  ```



  If you find any problems or would like to suggest a feature, please read the [How can I contribute](https://github.com/crowdin/crowdin-api-client-python/blob/main/CONTRIBUTING.md#how-can-i-contribute) section in our contributing guidelines.



  If you would like to contribute please read the [Contributing](https://github.com/crowdin/crowdin-api-client-python/blob/main/CONTRIBUTING.md) guidelines.



  <pre>
  The Crowdin Python client is licensed under the MIT License.
  See the LICENSE file distributed with this work for additional
  information regarding copyright ownership.

  Except as contained in the LICENSE file, the name(s) of the above copyright
  holders shall not be used in advertising or otherwise to promote the sale,
  use or other dealings in this Software without prior written authorization.
  </pre>


pkgId: c962bd2d7d4b7997c715c9c839d7259b4e7da63cecd0e2e4ee3001a31b9db8b1
name: python-crowdin-api-client
arch: src
version: 1.19.0
epoch: 0
release: 1
summary: Python client library for Crowdin API v2
url: https://github.com/crowdin/crowdin-api-client-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowdin-api-client-1.19.0-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://support.crowdin.com/assets/logos/symbol/png/crowdin-symbol-cWhite.png">
      <source media="(prefers-color-scheme: light)" srcset="https://support.crowdin.com/assets/logos/symbol/png/crowdin-symbol-cDark.png">
      <img width="150" height="150" src="https://support.crowdin.com/assets/logos/symbol/png/crowdin-symbol-cDark.png">
    </picture>
  </p>



  The Crowdin Python client is a lightweight interface to the Crowdin API. It provides common services for making API requests.

  Crowdin API is a full-featured RESTful API that helps you to integrate localization into your development process. The endpoints that we use allow you to easily make calls to retrieve information and to execute actions needed.

  <div align="center">

  [**`API Client Docs`**](https://crowdin.github.io/crowdin-api-client-python/) &nbsp;|&nbsp;
  [**`Crowdin API`**](https://developer.crowdin.com/api/v2/) &nbsp;|&nbsp;
  [**`Crowdin Enterprise API`**](https://developer.crowdin.com/enterprise/api/v2/)

  [![PyPI](https://img.shields.io/pypi/v/crowdin-api-client?cacheSeconds=3600)](https://pypi.org/project/crowdin-api-client/)
  [![Downloads](https://pepy.tech/badge/crowdin-api-client)](https://pepy.tech/project/crowdin-api-client)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/crowdin-api-client?cacheSeconds=3600)](https://pypi.org/project/crowdin-api-client/)
  ![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/crowdin/crowdin-api-client-python/python-package.yml?branch=main&logo=github)
  [![codecov](https://codecov.io/gh/crowdin/crowdin-api-client-python/branch/main/graph/badge.svg?token=sOUWIcNjWO)](https://codecov.io/gh/crowdin/crowdin-api-client-python)
  [![GitHub issues](https://img.shields.io/github/issues/crowdin/crowdin-api-client-python?cacheSeconds=3600)](https://github.com/crowdin/crowdin-api-client-python/issues)
  [![License](https://img.shields.io/github/license/crowdin/crowdin-api-client-python?cacheSeconds=3600)](https://github.com/crowdin/crowdin-api-client-python/blob/master/LICENSE)

  </div>



  ```console
  pip install crowdin-api-client
  ```





  ```python
  from crowdin_api import CrowdinClient

  class FirstCrowdinClient(CrowdinClient):
      TOKEN = "__token__"
      PROJECT_ID = 1 # Optional, set project id for all API's
      ORGANIZATION = "organizationName" # Optional, for Crowdin Enterprise only
      TIMEOUT = 60  # Optional, sets http request timeout.
      RETRY_DELAY = 0.1  # Optional, sets the delay between failed requests
      MAX_RETRIES = 5  # Optional, sets the number of retries
      HEADERS = {"Some-Header": ""}  # Optional, sets additional http request headers
      PAGE_SIZE = 25  # Optional, sets default page size
      EXTENDED_REQUEST_PARAMS = {"some-parameters": ""}  # Optional, sets additional parameters for request

  client = FirstCrowdinClient()


  project_response = client.projects.add_project(name="New project", sourceLanguageId="en")


  projects = client.projects.list_projects()


  projects = client.projects.list_projects(offset=10, limit=20)


  projects = client.projects.list_projects(page=2) # offset=25, limit=25
  ```

  Alternatively, you can create an instance of the CrowdinClient class with params like this:

  ```python
  from crowdin_api import CrowdinClient



  client = CrowdinClient(token='__token__')



  ```



  ```python
  from crowdin_api import CrowdinClient

  client = CrowdinClient(token='__token__')

  file_name = '__path_to_the_file__'

  storage = client.storages.add_storage(open(file_name, 'rb'))

  my_file = client.source_files.add_file(__project_id__, storage['data']['id'], file_name)

  print(my_file)
  ```



  It is possible to fetch all records from paginatable methods (where we have limit and offset in arguments).

  ```python
  from crowdin_api import CrowdinClient

  client = CrowdinClient(token='__token__')


  print(client.projects.with_fetch_all().list_projects())


  print(client.projects.with_fetch_all(1000).list_projects())
  ```



  An optional `orderBy` parameter is used to apply sorting.

  ```python
  from crowdin_api import CrowdinClient
  from crowdin_api.sorting import Sorting, SortingOrder, SortingRule
  from crowdin_api.api_resources.projects.enums import ListProjectsOrderBy

  client = CrowdinClient(token='__token__')

  sorting = Sorting(
      [
          SortingRule(ListProjectsOrderBy.ID, SortingOrder.ASC),
          SortingRule(ListProjectsOrderBy.NAME),
          SortingRule(ListProjectsOrderBy.CREATED_AT, SortingOrder.DESC),
      ]
  )

  print(client.projects.list_projects(orderBy=sorting))
  ```

  Enum `SortingOrder` is also optional (ascending order applied by default).



  The `EXTENDED_REQUEST_PARAMS` parameter allows you to set additional parameters for requests. For example, you can configure proxies or certificates.

  The Client uses the [requests](https://pypi.org/project/requests/) library to make HTTP requests. You can pass any parameters that `requests` supports:

  ```python
  def request(
      self,
      method,
      url,
      params=None,
      data=None,
      headers=None,
      cookies=None,
      files=None,
      auth=None,
      timeout=None,
      allow_redirects=True,
      proxies=None,
      hooks=None,
      stream=None,
      verify=None,
      cert=None,
      json=None,
  ):
  ```

  For example, you can set a [proxy](https://requests.readthedocs.io/en/latest/api/#requests.Session.proxies):

  ```python
  from crowdin_api import CrowdinClient

  http_proxy = "http://10.10.1.10:3128"
  https_proxy = "https://10.10.1.11:1080"
  ftp_proxy = "ftp://10.10.1.10:3128"

  proxies = {
    "http": http_proxy,
    "https": https_proxy,
    "ftp": ftp_proxy
  }

  class FirstCrowdinClient(CrowdinClient):
      EXTENDED_REQUEST_PARAMS = {"proxies": proxies}
  ```



  This library also provides the possibility to use [GraphQL API](https://developer.crowdin.com/graphql-api/):

  ```python
  from crowdin_api import CrowdinClient

  client = CrowdinClient(
      token='{token}',
      organization='{organization}'
  )

  query = """
  query {
    viewer {
      id
      name
    }
  }
  """


  response = client.graphql(query=query)
  ```



  If you find any problems or would like to suggest a feature, please read the [How can I contribute](https://github.com/crowdin/crowdin-api-client-python/blob/main/CONTRIBUTING.md#how-can-i-contribute) section in our contributing guidelines.



  If you would like to contribute please read the [Contributing](https://github.com/crowdin/crowdin-api-client-python/blob/main/CONTRIBUTING.md) guidelines.



  <pre>
  The Crowdin Python client is licensed under the MIT License.
  See the LICENSE file distributed with this work for additional
  information regarding copyright ownership.

  Except as contained in the LICENSE file, the name(s) of the above copyright
  holders shall not be used in advertising or otherwise to promote the sale,
  use or other dealings in this Software without prior written authorization.
  </pre>


pkgId: 53b6cfad8907637ae28ab434d3a1d58de4e06c240a70f08e6a83cf823fcedd15
name: python-crowdom
arch: src
version: 0.2.0
epoch: 0
release: 1
summary: Crowdom
url: https://pypi.org/project/crowdom/
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowdom-0.2.0-1.src.rpm
checksum_type: sha256
description:
  __Crowdom__ is a tool for simplifying data labeling.

  Write plain Python code and launch data labeling without knowledge of crowdsourcing and underlying platform
  (Crowdom uses [Toloka](https://toloka.ai) as a platform for publishing tasks for workers). Define task you solve and
  load source data with few lines of code, choose quality-cost-speed tradeoff in interactive UI form, launch data
  labeling, study result labeling in Pandas dataframes.

  Crowdom uses [ʎzy](https://github.com/lambdazy/lzy/), cloud workflow runtime, to run data labeling workflow.
  This provides _reliability_ (automatic errors retry, possibility of data labeling relaunch without losing progress) and
  out-of-the-box _data persistence_.



  We recommend you to look first at [image classification](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/image_classification/image_classification.html)
  example, since it demonstrates full data labeling workflow, proposed in Crowdom, with detailed explanations for each step.

  In other [examples](#Examples), you can see how working with data labeling looks like for different types of tasks with
  use of Crowdom.

  To get the benefits of running on ʎzy, see ʎzy setup [example](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/lzy/lzy.ipynb).

  Join our [Telegram chat](https://t.me/+axHOcdjbaFwzYzAy) if you want to learn more about the Crowdom or discuss your
  task with us.



  Tasks in Crowdom are divided into two types:
  - _Classification tasks_, which have a fixed set of labels as output.
  - _Annotation tasks_, for which output has "unlimited" dimension.

  In a typical _classification_ task, worker is proposed to make a choice of one of the pre-determined options.
  _Side-by-side_ (SbS) comparison is a special case of _classification_ task.

  As for _annotation_ task, there may be many potential solutions, and there may be more than one correct one.
  _Speech transcription_, _image annotation_ are examples of annotation tasks.



  The following table contains list of examples, which demonstrates data labeling for different types of tasks, as well
  as other aspects of data labeling workflow.

  Examples are presented as `.ipynb` files, located in this repository, but displayed by [nbviewer](https://nbviewer.org/github/lambdazy/crowdom/tree/main/examples/),
  which do it more precisely than GitHub.

  _Image classification_ and _audio transcript_) examples also have `.html` versions. These examples present full
  labeling workflow, corresponding two _classification_ and _annotation_ types of  tasks respectively. `.html` allows
  to collapse optional sections in notebook to simplify understanding of main steps of workflow,  as well as to display
  interactive widgets contents (for example, to display quality-cost-speed tradeoff interactive form).

  | Example                                                                                                                                                                                                                                                          | Full workflow | Function       | Data types  | Additionally                                                                                                   |
  |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------|----------------|-------------|----------------------------------------------------------------------------------------------------------------|
  | [Image classification](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/image_classification/image_classification.ipynb) [(HTML)](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/image_classification/image_classification.html) | ✅             | Classification | Image       |                                                                                                                |
  | [Audio transcript](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/audio_transcript/audio_transcript.ipynb) [(HTML)](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/audio_transcript/audio_transcript.html)                     | ✅             | Annotation     | Audio, Text |                                                                                                                |
  | [Audio transcripts SbS](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/audio_transcripts_sbs/audio_transcripts_sbs.ipynb)                                                                                                                       |               | SbS            | Audio, Text |                                                                                                                |
  | [Voice recording](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/voice_recording/voice_recording.ipynb)                                                                                                                                         |               | Annotation     | Text, Audio | Media output, checking annotations by the ML model                                                             |
  | [Audio transcript, extended](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/audio_transcript_ex/audio_transcript_ex.ipynb)                                                                                                                      |               | Annotation     | Text, Audio | Custom task UI, custom task duration calculation, first annotations attempts by the ML model                   |
  | [MOS](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/mos/MOS.ipynb)                                                                                                                                                                             |               | Classification | Audio       | [MOS](https://www.microsoft.com/en-us/research/wp-content/uploads/2011/05/0002416.pdf) algorithm usage example |
  | [Audio questions](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/audio_questions/audio_questions.ipynb)                                                                                                                                         |               | Classification | Audio       | Output label set depending on the input data                                                                   |
  | [Experts registration](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/experts_registration/experts_registration.ipynb)                                                                                                                          |               |                |             | Registration of your private expert workforce                                                                  |
  | [Task update](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/task_update/task_update.ipynb)                                                                                                                                                     |               |                |             | Task update (instructions, UI and etc.)                                                                        |
  | [ʎzy usage](https://nbviewer.org/github/lambdazy/crowdom/blob/main/examples/lzy/lzy.ipynb)                                                                                                                                                                       |               |                |             | ʎzy setup, parallel labelings                                                                                  |



  Join our communities if you have questions about Crowdom or want to discuss your data labeling task.

  - [Telegram](https://t.me/+axHOcdjbaFwzYzAy)


pkgId: 17fc7855c4fe0a307bfe4560c41a12f1dd1b486bb6aae2f4e0e6bf9db026becb
name: python-crowdstrike-pulumi
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: A Pulumi package for creating and managing CrowdStrike resources
url: https://crowdstrike.com
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crowdstrike-pulumi-0.0.5-1.src.rpm
checksum_type: sha256
description:
  The CrowdStrike Resource Provider lets you manage [crowdstrike](https://www.pulumi.com/registry/packages/crowdstrike/) resources.



  This package is available for several languages/platforms:



  To use from JavaScript or TypeScript in Node.js, install using either `npm`:

  ```bash
  npm install @crowdstrike/pulumi
  ```

  or `yarn`:

  ```bash
  yarn add @crowdstrike/pulumi
  ```



  To use from Python, install using `pip`:

  ```bash
  pip install crowdstrike_pulumi
  ```



  To use from Go, use `go get` to grab the latest version of the library:

  ```bash
  go get github.com/crowdstrike/pulumi-crowdstrike/sdk/go/...
  ```



  For detailed reference documentation, please visit [the Pulumi registry](https://www.pulumi.com/registry/packages/crowdstrike/api-docs/).


pkgId: a8152eeaa5223fde568517a27fb0be9ff5cd72281a0cf672d022bb999c5ef7de
name: python-crownstone-cloud
arch: src
version: 1.4.11
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Crownstone-Community/crownstone-lib-python-cloud
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crownstone-cloud-1.4.11-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python library to get data from the cloud, and switch Crownstones.



  * Async: using asyncio and aiohttp, optimized for speed.
  * Easy to use: sync all your Crownstone Cloud data with just one command!
  * Structurally sound: find your data with ease!
  * Complete: set the switch state and brightness of your Crownstones remotely!
  * Flexible: Login and get the data for multiple accounts at once!



  * Python 3.8 or higher
  * Aiohttp 3.7.4



  cd to the project folder and run:
  ```console
  $ python setup.py install
  ```



  To install the library execute the following command:
  ```console
  $ python -m venv venv
  ```
  Activate your venv using:
  ```console
  $ source venv/bin/activate
  ```
  Once activated, the venv is used to executed python files, and libraries will be installed in the venv.<br>
  To install this library, cd to the project folder and run:
  ```console
  $ python setup.py install
  ```







  ```python
  from crownstone_cloud import CrownstoneCloud, create_clientsession
  import logging
  import asyncio


  logging.basicConfig(format='s:s', level=logging.DEBUG)


  async def main():
      
      
      websession = create_clientsession()
      
      cloud_user_1 = CrownstoneCloud('email_user_1', 'password_user_1', websession)
      
      await cloud_user_1.async_initialize()

      
      crownstone_lamp = cloud_user_1.get_crownstone('Lamp')
      await crownstone_lamp.async_set_brightness(20)

      
      cloud_user_2 = CrownstoneCloud('email_user_2', 'password_user_2', websession)
      await cloud_user_2.async_initialize()

      
      crownstone_tv = cloud_user_2.get_crownstone('TV')
      await crownstone_tv.async_turn_on()

      
      
      
      
      my_sphere = cloud_user_1.cloud_data.find("my_sphere_name")
      
      await my_sphere.locations.async_update_location_data()
      
      sphere_keys = await my_sphere.async_get_keys()

      
      await websession.close()

  asyncio.run(main())
  ```



  ```python
  from crownstone_cloud import CrownstoneCloud, run_async
  import logging


  logging.basicConfig(format='s:s', level=logging.DEBUG)


  cloud = CrownstoneCloud('email', 'password')


  run_async(cloud.async_initialize())


  crownstone_coffee_machine = cloud.get_crownstone('Coffee machine')
  run_async(crownstone_coffee_machine.async_turn_on())


  run_async(cloud.async_close_session())
  ```



  The Crownstone cloud is initialized with the email and password of a user:
  ```python
  cloud = CrownstoneCloud('email', 'password')
  ```
  If you do not yet have a Crownstone account, go to [My Crownstone](https://my.crownstone.rocks) to set one up.
  The email and password are used to re-login after an access token has expired.

  You can log into multiple accounts by creating more CrownstoneCloud objects. When doing so, it is recommended to use
  only 1 websession for all your requests. Create a websession and append it as parameter to all your CrownstoneCloud
  objects. Take a look at the async example above.
  ```python
  cloud = CrownstoneCloud('email', 'password', websession)
  ```
  To log in and get all your Crownstone from the cloud:
  ```python
  await cloud.async_initialize()
  ```



  The cloud can be displayed with the following structure:
  * User
      * Keys
      * Spheres
          * Locations
          * Crownstones
          * Users




  The user is the to whom the data belongs.<br>
  The user is the one that logs in using email and password.<br>
  By getting a user specific access token after login, the data for that specific user can be requested.



  The keys are user specific.<br>
  They are required to connect to the crownstone bluetooth mesh.<br>
  The most common used keys are the sphere keys. They are located within each individual sphere.<br>



  Spheres are the main data entry. They have rooms (locations), Crownstones and users in them.<br>
  Example spheres:
  * House
  * Office
  * Apartment

  A Sphere has the following fields in the cloud lib:
  * crownstones: Crownstones
  * locations: Locations
  * users: Users
  * keys: Dict (optional, default = None)
  * name: String
  * cloud_id: String
  * unique_id: String
  * present_people: List



  Locations are the rooms in your house or other building.<br>
  For example for a house:
  * Living room
  * Bedroom
  * Garage
  * Bathroom

  A Location has the following fields in the cloud lib:
  * present_people: List
  * name: String
  * cloud_id: String
  * unique_id: String



  Crownstones are smart plugs that can make every device that isn't smart, way smarter!<br>
  Crownstones are located within a sphere.<br>
  Example names of Crownstones:
  * Lamp
  * Charger
  * Television

  A Crownstone has the following fields in the cloud lib:
  * abilities: Dict
  * state: Int (0..100)
  * name: String
  * unique_id: String
  * cloud_id: String
  * type: String
  * sw_version: String



  Users are people who have access to a sphere.<br>
  A user can have 3 roles:
  * Admin
  * Member
  * Guest

  A User has the following fields in the cloud lib:
  * role: String
  * first_name: String
  * last_name: String
  * email: String
  * cloud_id: String
  * email_verified: Bool






  > Login and sync all data for the user from the cloud.


  > Synchronize all data for a user. Use case is to update the local data with new data from the cloud.
  > This function is already called in `async_initialize()`.


  > Get a Crownstone object by name for a user. Raises CrownstoneNotFoundError if it doesn't exist.
  > You can optionally provide a sphere id to match where the Crownstone should be found.


  > Get a Crownstone object by it's id for a user. Raises CrownstoneNotFoundError if it doesn't exist.
  > You can optionally provide a sphere id to match where the Crownstone should be found.


  > Get a Crownstone object by it's uid for a user. Raises CrownstoneNotFoundError if it doesn't exist.
  > You can optionally provide a sphere id to match where the Crownstone should be found.


  > Async function. This will close the websession in requestHandler to cleanup nicely after the program has finished.




  > Async function. Sync the Spheres with the cloud. Calling the function again after init will update the current data.


  > Returns a sphere object if one exists by that name.


  > Return a sphere object if one exists by that id.




  > Async function. Sync the presence of users in the sphere with the cloud.


  > Async function. Returns a dict with the keys of this sphere.
  > The keys can be used for BLE connectivity with the Crownstones.




  > Async function. Sync the Crownstones with the cloud for a sphere.
  > Calling the function again after init will update the current data.


  > Return a Crownstone object if one exists by that name.


  > Return a Crownstone object if one exists by that id.




  > Async function. Send a command to turn a Crownstone on.
  > To make this work make sure to be in the selected sphere and have Bluetooth enabled on your phone.


  > Async function. Send a command to turn a Crownstone off.
  > To make this work make sure to be in the selected sphere and have Bluetooth enabled on your phone.


  > Async function. Send a command to set a Crownstone to a given brightness level.
  > To make this work make sure to be in the selected sphere and have Bluetooth enabled on your phone.
  > The value parameter should be between 0 and 100.




  > Async function. Sync the Locations with the cloud for a sphere. Calling the function again after init will update the current data.


  > Async function. Sync the presence with the cloud. This will replace the current presence with the new presence.


  > Return a location object if one exists by that name.


  > Return a location object if one exists by that id.




  > Async function. Sync the Users with the cloud for a sphere. Calling the function again after init will update the current data.


  > Returns a list of all users with that first name, as duplicate first names can exist.


  > Return a list of all users with that last name, as duplicate last names can exist.


  > Return a location object if one exists by that id.


  The lib can be used synchronously and asynchronously.<br>
  The disadvantage of sync context is that all functions are blocking.
  The program will simply wait until a function is complete. In async context, functions (coroutines) can yield control,
  which means that functions can be "paused" while they are waiting for external data to come in, like data from a server.
  Other functions can then be executed in the meantime. This way the program is always busy.<br>

  All async functions in the library API functions in this library have the prefix **async_**
  Async functions need to be awaited:
  ```Python
  await cloud.async_close_session()
  ```
  All the async functions mentioned above can also be used synchronously.<br>
  Use the `run_async()` function like so:
  ```Python
  from crownstone_cloud import run_async

  run_async(cloud.async_close_session())
  ```
  Make sure to see the examples above!



  To run the tests using tox install tox first by running:
  ```console
  $ pip install tox
  ```
  To execute the tests cd to the project folder and run:
  ```console
  $ tox
  ```
  To see which parts of the code are covered by the tests, a coverage report is generated after the tests have been successful.<br>
  To see the coverage report run:
  ```console
  $ coverage report
  ```
  If you like to get a better overview of the test you can generate a HTML file like so:
  ```console
  $ coverage html
  ```
  To view your html file directly on Linux:
  ```console
  $ ./htmlcov/index.html
  ```
  On Windows simply navigate to the htmlcov folder inside the project folder, and double-click index.html. It will be executed in your selected browser.




  This software is provided under a noncontagious open-source license towards the open-source community. It's available under three open-source licenses:

  * License: LGPL v3+, Apache, MIT

  <p align="center">
    <a href="http://www.gnu.org/licenses/lgpl-3.0">
      <img src="https://img.shields.io/badge/License-LGPL%20v3-blue.svg" alt="License: LGPL v3" />
    </a>
    <a href="https://opensource.org/licenses/MIT">
      <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT" />
    </a>
    <a href="https://opensource.org/licenses/Apache-2.0">
      <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0" />
    </a>
  </p>



  This software can also be provided under a commercial license. If you are not an open-source developer or are not planning to release adaptations to the code under one or multiple of the mentioned licenses, contact us to obtain a commercial license.

  * License: Crownstone commercial license



  For any question contact us at <https://crownstone.rocks/contact/> or on our discord server through <https://crownstone.rocks/forum/>.


pkgId: a586343bb73710de80a0a0ddf54846e757f177518bb9836a870297745483474a
name: python-crownstone-core
arch: src
version: 3.2.1
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/crownstone/crownstone-lib-python-core
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crownstone-core-3.2.1-1.src.rpm
checksum_type: sha256
description:
  This is the core of the python lib. It contains shared classes, definitions and utils. This is not intended for direct use by external
  parties. Take a a look at the specialized libraries for your purpose:


  - https://github.com/crownstone/crownstone-lib-python-uart
  - https://github.com/crownstone/crownstone-lib-python-ble
  - https://github.com/crownstone/crownstone-lib-python-cloud
  - https://github.com/crownstone/crownstone-lib-python-sse

  If you wish to install all crownstone python libraries, take a look at our [tutorial](./docs/TUTORIAL_VENV_SETUP.md).


pkgId: 66d9814db523db1743ec03fb9e2e6f47cc0a30b0d36deb66769e4db12436fbb2
name: python-crownstone-sse
arch: src
version: 2.0.5
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/Crownstone-Community/crownstone-lib-python-sse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crownstone-sse-2.0.5-1.src.rpm
checksum_type: sha256
description:
  Asynchronous Python library that listens to Crownstone SSE events.


  * Async: using asyncio and aiohttp, easy to integrate in existing projects.
  * Multi-functional: Library provides an extra thread wrapper to run the client in sync context.
  * Complete: Fully integrated event bus that can be used to listen to events, and run callbacks.


  * Python 3.8 or higher
  * Aiohttp 3.7


  cd to the project folder and run:
  ```console
  $ python setup.py install
  ```


  To install the library execute the following command:
  ```console
  $ python -m venv venv
  ```
  Activate your venv using:
  ```console
  $ source venv/bin/activate
  ```
  Once activated, the venv is used to executed python files, and libraries will be installed in the venv.<br>
  To install this library, cd to the project folder and run:
  ```console
  $ python setup.py install
  ```





  ```python
  import asyncio
  import logging
  from crownstone_sse import CrownstoneSSEAsync


  logging.basicConfig(format='s :s', level=logging.DEBUG)


  async def main():
      
      
      
      
      
      
      
      
      client = CrownstoneSSEAsync(
          email="example@example.com",
          password="CrownstoneRocks",
          project_name="MyProject"
      )
      
      await process_events(client)
      
      


  async def process_events(sse_client: CrownstoneSSEAsync):
      async with sse_client as client:
          async for event in client:
              
              print(event)

              
              

              
              
              


  try:
      asyncio.run(main())
  except KeyboardInterrupt:
      pass
  finally:
      print("Crownstone SSE client finished. Thanks for your time!")
  ```
  The async client is meant to be used in an existing asyncio project. You can pass an existing `aiohttp.ClientSession`
  object to the client, and schedule the receiving of events in the running event loop by using:
  ```python
  asyncio.create_task()
  ```
  as shown in the example above.



  Crownstone SSE library provides a very complete event bus that can be used to schedule coroutines as well as callbacks.
  Make sure to initiate the event bus within the event loop.
  The eventbus can be initiated like so:
  ```python
  from crownstone_sse import EventBus

  bus = EventBus()
  ```
  Then you can create a coroutine to be executed upon receiving a specific event:
  ```python
  async def async_update_local_switch_state(event: SwitchStateUpdateEvent):
      
      await crownstone.update_state(event.switch_state)

  bus.add_event_listener(EVENT_CROWNSTONE_SWITCH_STATE_UPDATE, async_update_local_switch_state)
  ```
  The usage of the eventbus is optional here. You can also use an existing eventbus in your project.



  ```python
  import logging
  from crownstone_sse import CrownstoneSSE
  from crownstone_sse.events import (
      SwitchStateUpdateEvent,
      SystemEvent,
      PresenceEvent,
      AbilityChangeEvent,
      DataChangeEvent,
  )
  from crownstone_sse import (
      EVENT_ABILITY_CHANGE,
      EVENT_DATA_CHANGE,
      EVENT_PRESENCE,
      EVENT_PRESENCE_ENTER_LOCATION,
      EVENT_SWITCH_STATE_UPDATE,
      EVENT_SWITCH_STATE_UPDATE_CROWNSTONE,
      EVENT_SYSTEM,
      OPERATION_CREATE,
      OPERATION_DELETE,
      OPERATION_UPDATE,
  )


  logging.basicConfig(format='s :s', level=logging.DEBUG)


  def switch_update(event: SwitchStateUpdateEvent):
      if event.sub_type == EVENT_SWITCH_STATE_UPDATE_CROWNSTONE:
          print("Crownstone {} switch state changed to {}".format(event.cloud_id, event.switch_state))


  def notify_stream_start(event: SystemEvent):
      print(event.message)


  def notify_presence_changed(event: PresenceEvent):
      if event.sub_type == EVENT_PRESENCE_ENTER_LOCATION:
          print("User {} has entered location {}".format(event.user_id, event.location_id))


  def notify_ability_changed(event: AbilityChangeEvent):
      print("Ability {} changed to {}".format(event.ability_type, event.ability_enabled))


  def notify_data_changed(event: DataChangeEvent):
      if event.operation == OPERATION_CREATE:
          print("New data is available: {}".format(event.changed_item_name))
      if event.operation == OPERATION_UPDATE:
          print("Name of id {} has been updated to {}".format(event.changed_item_id, event.changed_item_name))
      if event.operation == OPERATION_DELETE:
          print("Data {} has been deleted".format(event.changed_item_name))








  sse_client = CrownstoneSSE(
      email="example@example.com",
      password="CrownstoneRocks",
      project_name="MyProject"
  )


  sse_client.add_event_listener(EVENT_SYSTEM, notify_stream_start)
  sse_client.add_event_listener(EVENT_SWITCH_STATE_UPDATE, switch_update)
  sse_client.add_event_listener(EVENT_PRESENCE, notify_presence_changed)
  sse_client.add_event_listener(EVENT_ABILITY_CHANGE, notify_ability_changed)
  sse_client.add_event_listener(EVENT_DATA_CHANGE, notify_data_changed)



  try:
      sse_client.join()
  except KeyboardInterrupt:
      sse_client.stop()
  ```
  This library can be used in synchronous context, and the example above will likely be the go-to option for most users.
  You can use the Thread next to other synchronous Python code. <br>
  If you want to let the client run forever, you can use:
  ```python
  sse_client.join()
  ```
  As shown above. This will make the main thread wait till the sse_client thread is finished.
  You should however always build in  a way to stop the client, you can do so by stopping on `KeyboardInterrupt`
  as shown above.



  Callbacks are functions that will be executed everytime an event comes in of an specific event type.<br>
  The standard format for a callback is:
  ```python
  def callback(event: EventTypeClass):
      
  ```
  Each event has it's own fields. It is recommended to provide the event type class hint to keep better track of which event it is, and what fields it has. <br>
  For example:
  ```python
  def callback(event: PresenceEvent):
      print(event.user_id)
      print(event.location_id)
  ```
  You can add the listener like so:
  ```python
  unsub = sse_client.add_event_listener(event_type, callback)
  ```
  This returns an unsubscribe function in case you want to remove the listener again. To do that, simply call:
  ```python
  unsub()
  ```



  Currently, there are 7 different event types:
  * System event
  * Command event
  * Data change event
  * Presence event
  * Switch state update event
  * Ability change event
  * Ping event



  A system event is represented as:

  * type
  * sub_type

  * code
  * message



  A switch command event is represented as:

  * type
  * sub_type

  * sphere_id

  * cloud_id
  * unique_id
  * switch_val (as SwitchCommandValue)



  A multi switch command event is represented as:

  * type
  * sub_type

  * sphere_id

  * crownstone_list

  * cloud_id
  * unique_id
  * switch_val (as SwitchCommandValue)



  A data change event is represented as:
  * operation (update | delete | create)

  * type
  * sub_type

  * sphere_id

  * changed_item_id
  * changed_item_name



  A presence event is represented as:

  * type
  * sub_type

  * sphere_id

  * location_id

  * user_id



  A switch state update event is represented as:

  * type
  * sub_type

  * sphere_id

  * cloud_id
  * unique_id
  * switch_state (percentage)



  An ability change event is represented as:

  * type
  * sub_type

  * sphere_id

  * cloud_id
  * unique_id

  * ability_type
  * ability_enabled
  * ability_synced_to_crownstone



  A ping event is represented as:

  * type

  * counter
  * elapsed_time (in seconds)

  The ping event exists to notify the client that the connection is still alive, internally. <br>
  You can however use it to check how long the connection has been alive as well.



  Tests are not available yet for this version. The client has however been live tested on the following:
  1. Logging in with Crownstone credentials.
  2. Establishing a connection to the Crownstone SSE server.
  3. Tested the connection staying alive for longer than 10 minutes (no total timeout).
  4. Tested client reconnection by manually disabling internet, waiting over 35 seconds, and turning it back on.
  5. Tested access token renewal by providing a short TTL on the access token when logging in.
  6. Safely closing the connection and exiting the loop after a manual stop is called, both and running and reconnecting state.





  This software is provided under a noncontagious open-source license towards the open-source community. It's available under three open-source licenses:

  * License: LGPL v3+, Apache, MIT

  <p align="center">
    <a href="http://www.gnu.org/licenses/lgpl-3.0">
      <img src="https://img.shields.io/badge/License-LGPL%20v3-blue.svg" alt="License: LGPL v3" />
    </a>
    <a href="https://opensource.org/licenses/MIT">
      <img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT" />
    </a>
    <a href="https://opensource.org/licenses/Apache-2.0">
      <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0" />
    </a>
  </p>



  This software can also be provided under a commercial license. If you are not an open-source developer or are not planning to release adaptations to the code under one or multiple of the mentioned licenses, contact us to obtain a commercial license.

  * License: Crownstone commercial license



  For any question contact us at <https://crownstone.rocks/contact/> or on our discord server through <https://crownstone.rocks/forum/>.


pkgId: 2ca136ae5c16751c0ce45474ecd056d6e9b2119fab50ace19c15c9094da0ded8
name: python-crucio
arch: src
version: 0.1.94
epoch: 0
release: 1
url: https://github.com/SigmoidAI/crucio
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crucio-0.1.94-1.src.rpm
checksum_type: sha256
summary:
  Crucio is a python sci-kit learn inspired package for class imbalance. It use some classic methods for class balancing taking as parameters a data frame and the target column.

description:
  Crucio is a python sci-kit learn inspired package for class imbalance. It use some classic methods for class balancing taking as parameters a data frame and the target column.

  This version of kydavra has the next methods of feature selection:
  * ADASYN.
  * ICOTE (Immune Centroids Oversampling).
  * MTDF (Mega-Trend Difussion Function).
  * MWMOTE (Majority Weighted Minority Oversampling Technique).
  * SMOTE (Synthetic Minority Oversampling Technique).
  * SMOTENC (Synthetic Minority Over-sampling Technique for Nominal and Continuous).
  * SMOTETOMEK (Synthetic Minority Oversampling Technique + Tomek links for undersampling).
  * SMOTEENN (Synthetic Minority Oversampling Technique + ENN for undersampling).
  * SCUT (SMOTE and Clustered Undersampling Technique).
  * SLS (Safe-Level-Synthetic Minority Over-Sampling TEchnique).
  * TKRKNN (Top-K ReverseKNN).

  All these methods takes the pandas Data Frame and y column to balance on.

  How to use crucio

  To use balancer from crucio you should just import the balancer from crucio in the following framework:
  ```python
  from crucio import SMOTE
  ```

  class names are written above.Next create a object of this algorithm (I will use SMOTE method as an example).
  ```python
  method = SMOTE()
  ```

  To balance the dataset on the target column use the ‘balance’ function, using as parameters the pandas Data Frame and the column that you want to balance. Small tip, balance only the training set, not full one.

  ```python
  new_dataframe = method.balance(df, 'target')
  ```

  Returned value is a new data frame with the target column balanced.

  With love from Sigmoid.

  We are open for feedback. Please send your impression to vladimir.stojoc@gmail.com


pkgId: ea3db036a24b35263f9d457c5c35e749a8c5dcd23032683f264a25903e9572cf
name: python-crud_filters
arch: src
version: 0.3.6
epoch: 0
release: 1
description: UNKNOWN
url: https://github.com/bellhops/django-crud-filters
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crud_filters-0.3.6-1.src.rpm
checksum_type: sha256
summary:
  django-crud-filters works with django-restframework to provide easily configurable role-based filtering for API endpoints.


pkgId: 2ff151c65c795ac60891e70225163e27236ad183444c45a62c9d8c6336b5ba61
name: python-crudhex
arch: src
version: 0.17.4
epoch: 0
release: 1
summary: Java/Spring CRUD code generator
url: https://github.com/salpreh/crudhex
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crudhex-0.17.4-1.src.rpm
checksum_type: sha256
description:
  CLI tool to generate Java CRUD classes from a spec file. The target for this code generation is a Hexagonal architecture.

  Adding CRUD operation in a hexagonal project is quite a pain. You can take shortcuts that can be totally legit in cases of just CRUD operations, but most cases if there is already a rich domain/application layer for other use cases CRUD shortcuts can break the consistency of the project.
  The target of this CLI is to ease ~~my life~~ and try to give a general solution to CRUD generations in Hexagonal architecture. There are some customizations you can make, but some aspects for now are closed to customization for now.


  Project config file is used to know where things should go in the project. Usually contains a path to the sources folder (`src/main/java` in regular maven projects) and packages where things are located within that source folder.
  Here is a basic example:
  ```yaml
  src: src/main/java # General sources for single module apps, default to src/main/java (maven project)
  domain-models-pkg: com.salpreh.baseapi.domain.models # domain models package
  domain-commands-pkg: com.salpreh.baseapi.domain.models.commands # domain commands package
  domain-in-ports-pkg: com.salpreh.baseapi.domain.ports.application # domain ports (in/driving/application)
  domain-out-ports-pkg: com.salpreh.baseapi.domain.ports.infrastructure # domain ports (out/driven/infrastructure)
  domain-use-cases-pkg: com.salpreh.baseapi.domain.services # domain use cases implementation
  domain-exceptions-pkg: com.salpreh.baseapi.domain.exceptions # domain exceptions
  db-adapters-pkg: com.salpreh.baseapi.adapters.infrastructure.db.adapters # db adapters (port implementations)
  db-models-pkg: com.salpreh.baseapi.adapters.infrastructure.db.models # db entities package
  db-repositories-pkg: com.salpreh.baseapi.adapters.infrastructure.db.repositories # db repositories package
  db-mapper-class: com.salpreh.baseapi.adapters.infrastructure.db.mappers.DbMapper # mapper class to map db adapter entities to domain models. Needed if no mapper option specified when running command (optional)
  db-mapper-pkg: com.salpreh.baseapi.adapters.infrastructure.db.mappers # db mapper package.Needed when mapper option specified when running command (optional)
  rest-models-pkg: com.salpreh.baseapi.application.api.models # rest models package
  rest-controllers-pkg: com.salpreh.baseapi.application.api.controllers # rest controllers package
  rest-exception-handler-pkg: com.salpreh.baseapi.application.api.config # rest exception handler package
  rest-mapper-class: com.salpreh.baseapi.application.api.controllers.mappers.ApiMapper # mapper class to map domain models to api models. Needed if no mapper option specified when running command (optional)
  rest-mapper-pkg: com.salpreh.baseapi.application.api.controllers.mappers # api mapper package. Needed when mapper option specified when running command (optional)
  ```
  In case of multimodule project you will have to specify `src` path to each module (domain, rest adapter and db adapter).
  ```yaml

  domain-src: domain/src/main/java # Domain java sources
  db-adapter-src: infrastructure/datasource-adapter/src/main/java # DB adapter java sources
  rest-adapter-src: application/web/src/main/java # Rest adapter java sources

  ```
  More examples of config can be found in (`doc/examples/config`).
  The default name for this config file is `.crudhex-conf.yaml`, located in the root of the project (you can provide the path to config file by cli options, so you can place it anywhere you want)

  This is the file where you specify the crud model. Class name, attributes and some metadata about DB structure (relations, PK field, column name alias, etc).
  An example of spec file:
  ```yaml
  Person: # Model name
    .meta:
      table-name: persons # OPTIONAL: Table name for entity
    id: # Field name
      type: Long
      id: sequence # PK marker. This field will be the primary key for the entity.
                   
    name: String # Field name and type
    birthPlanet: # Field name
      type: Planet
      column: birth_planet # OPTIONAL: Column name alias
      relation: # DB relation meta data in case of FK
        type: many-to-one # Relation type
        join-column: birth_planet_id # Join column for relation
    affiliations:
      type: Faction
      relation:
        type: many-to-many # In case of many-to-many we have a couple of more meta about DB setup
        join-table: person_affiliation
        join-column: person_id
        inverse-join-column: faction_id
    backup:
      type: Person
      relation:
        type: one-to-one
        join-column: backup_id
    backing:
      type: Person
      relation:
        type: one-to-one
        mapped-by: backup # Mapping attribute for non-owning side of relation

  Planet:
    .meta:
      table-name: planets
    id:
      type: Long
      id: # You can specify the generation strategy as map to use additional options. In this case we are giving a sequence name
        type: sequence
        sequence: planet_pk_gen
    name: # Field name and type also can be specified as map to add column name metadata
      type: String
      column: original_name
    affiliation:
      type: Faction
      relation:
        type: many-to-one
        join-column: affiliation_id
    relevantPersons:
      type: Person
      relation:
        type: one-to-many
        mapped-by: birthPlanet
  ```
  Snippet config comments provide an overview of each relevant section in config. I'll dig further in config details in a dedicated section.
  For now, you can find some additional examples in `doc/examples/spec`.

  Package is published in Pypi public repositories. You can use [pip]() (or another convenient python dependency manager) to install the package:
  ```shell
  pip install crudhex
  ```
  Once installed you should be able to use it as CLI tool:
  ```shell
  crudhex --help
  ```

  You can use the `--help` option to see all available options:
  ```shell
  crudhex --help
  ```
  To generate the code you need to locate the shell in the root of the project and run the command:
  ```shell
  crudhex -m mapstruct spec/crudhex.yaml
  ```
  Here we are specifying mapstruct as mapper library and the path to the spec file. By default, will use the config file `.crudhex-conf.yaml` located in the root of the project.
  If you want to use a different config file, you can specify it with the `-c` option:
  ```shell
  crudhex -c .doc/config/cruhex-config.yaml spec/crudhex.yaml
  ```



  First level keys in spec file are the **model names**. Each model name is followed by a map with the model fields/attributes.
  ```yaml
  Person: # Model name
    id: Long # Field name
    name: String # Field name
    surname:  # Field name
      type: String
      column: last_name
    birthPlanet: # Field name with relation data
      type: Planet
      column: birth_planet
      relation:
        type: many-to-one
        join-column: birth_planet_id
  ```
  There is a special key inside the model map called `.meta` that contains metadata about the model.
  ```yaml
  Person: # Model name
    .meta:
      table-name: persons # Table name for entity
    id: Long # Field name
    name: String # Field name

  ```
  Current supported options in meta are:
  - `table-name`: Table name for the entity. If not specified, will use the model name as table name.

  Fields in the model have many options depending on the type of field. The most basic field spec is just the field name and the type:
  ```yaml
  Person: # Model name
    id: Long # Field name
    name: String # Field name
  ```
  This structure can be expanded to specify additional options for the field.
  ```yaml
  Person: # Model name
    name: # Field name
      type: String # Field type
      column: original_name # Column name alias
    id:  # Field name
      type: Long # Field type
      id:
        type: sequence # PK generation strategy
        sequence: person_pk_gen # Sequence name
    birthPlanet: # Field name
      type: Planet # Field type
      column: birth_planet # Column name alias
      relation: # DB relation metadata
        type: many-to-one
        join-column: birth_planet_id
  ```
  Options available are:
  - `type`: Field type. Can contain a primitive, java type, custom class or another model.
  - `column`: Column name alias. If not specified, will use the field name as column name.
  - `id`: Marks the field as Primary key in DB. Also contains metadata for PK generation strategy.
  - `relation`: Contains metadata for DB relations.
  Expanding on `type` options available here is an example with each one of the mentioned options:
  ```yaml
  Person:
    id:
      type: UUID # Java type
      id: auto
    age: int # Primitive type
    birthPlanet:
      type: Planet # Model class
      relation:
        type: many-to-one
        join-column: birth_planet_id
    race: com.salpreh.baseapi.domain.models.RaceType # Custom class
  ```
  For custom classes full package name is required (`race` field in example). For java types all jdk 11 classes are supported, in case you need a not supported type you can use full package name to refer to it. There is a list of supported types in [crudhex/domain/services/data/class_type_data.py](https://github.com/salpreh/crudhex/tree/master/crudhex/domain/services/data/class_type_data.py).
  For regular fields most common option is to use type directly as value (first example), or a map with type and column name alias (second example). We will dig into `id` and `relation` options in the next sections.

  Id fields are marked with the `id` key. This key also contains metadata about the PK generation strategy.
  ```yaml
  Person: # Model name
    id:  # Field name
      type: Long # Field type
      id:
        type: sequence # PK generation strategy
        sequence: person_pk_gen # Sequence name
  Spaceship: # Model name
    code: # Field name
      type: UUID # Field type
      column: ship_code # Column name alias
      id: auto # PK generation strategy
  ```
  PK generation strategies are mapped to JPA generation strategies with lower case. Current supported strategies are:
  - `none`: No generation strategy.
  - `auto`: Auto generation strategy.
  - `sequence`: Sequence generation strategy. Sequence name can be provided.
  - `identity`: Identity generation strategy.

  Relation fields are marked with the `relation` key. This key also contains metadata about the relation.
  ```yaml
  Person:
    birthPlanet: # Field name
      type: Planet # Field type
      column: birth_planet
      relation: # DB relation metadata
        type: many-to-one # Relation type
        join-column: birth_planet_id # Join column for relation
    affiliations:
      type: Faction # Field type
      relation: # DB relation metadata
        type: many-to-many # Relation type
        join-table: person_affiliation # Join table for relation
        join-column: person_id # Join column for relation
        inverse-join-column: faction_id # Inverse join column for relation
    backup: # Field name
      type: Person # Field type
      relation: # DB relation metadata
        type: one-to-one # Relation type
        join-column: backup_id # Join column for relation
  ```
  Options available are:
  - `type`: Relation type. Supported options are:
    - `one-to-one`
    - `one-to-many`
    - `many-to-one`
    - `many-to-many`
  - `join-column`: Join column for relation (owning side).
  - `mapped-by`: Mapped by field for relation (inverse side).
  - `inverse-join-column`: Inverse join column for relation (many-to-many relations).
  - `join-table`: Join table for relation (many-to-many relations).
  All of these options are mapped to JPA annotations and configurations. Explaining when to use each option and what it does is out of the scope of this document.


  - [JPA Bidirectional relations](https://vladmihalcea.com/jpa-hibernate-synchronize-bidirectional-entity-associations/)
  - [JPA many-to-many relations](https://www.jpa-buddy.com/blog/synchronization-methods-for-many-to-many-associations/)
  - [JPA equals/hashCode](https://vladmihalcea.com/how-to-implement-equals-and-hashcode-using-the-jpa-entity-identifier/)
  - [JPA many-to-many collections](https://vladmihalcea.com/the-best-way-to-use-the-manytomany-annotation-with-jpa-and-hibernate/)


pkgId: c2af4abf14cd5520636043a132fe54e91d5d868dfbc6ccecda7c3b88e6aeb403
name: python-crudini
arch: src
version: 0.9.5
epoch: 0
release: 1
summary: A utility for manipulating ini files
url: http://github.com/pixelb/crudini
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crudini-0.9.5-1.src.rpm
checksum_type: sha256
description:
  ```
  crudini --set [OPTION]...   config_file section   [param] [value]
  crudini --get [OPTION]...   config_file [section] [param]
  crudini --del [OPTION]...   config_file section   [param] [list value]
  crudini --merge [OPTION]... config_file [section]

  SECTION can be empty ("") or "DEFAULT" in which case,
  params not in a section, i.e. global parameters are operated on.
  If 'DEFAULT' is used with --set, an explicit [DEFAULT] section is added.

  Multiple --set|--del|--get operations for a config_file can be specified.

  ```

  ```

    --existing[=WHAT]  For --set, --del and --merge, fail if item is missing,
                         where WHAT is 'file', 'section', or 'param',
                         or if WHAT not specified; all specified items.
    --format=FMT       For --get, select the output FMT.
                         Formats are 'sh','ini','lines'
    --ini-options=OPT  Set options for handling ini files.  Options are:
                         'nospace': use format name=value not name = value
                         'ignoreindent': ignore leading whitespace
    --inplace          Lock and write files in place.
                         This is not atomic but has less restrictions
                         than the default replacement method.
    --list             For --set and --del, update a list (set) of values
    --list-sep=STR     Delimit list values with "STR" instead of " ,".
                         An empty STR means any whitespace is a delimiter.
    --output=FILE      Write output to FILE instead. '-' means stdout
    --verbose          Indicate on stderr if changes were made
    --help             Write this help to stdout
    --version          Write version to stdout

  ```

  ```


    crudini --set config_file section parameter value



    crudini --set config_file "" parameter value


    crudini --set --existing config_file section parameter value


    crudini --set config_file section parameter1 value \
            --set config_file section parameter2 value \
            --del config_file section parameter3


    env | crudini --get - '' USER --get - '' SHELL



    crudini --set --list config_file section parameter a_value



    crudini --set --list --list-sep= config_file section parameter a_value


    crudini --del config_file section parameter


    crudini --del config_file section


    crudini --get config_file section parameter


    crudini --get config_file "" parameter


    crudini --get config_file section


    eval "$(crudini --get --format=sh config_file section)"


    echo name="$name" | crudini --merge config_file section


    crudini --merge config_file < another.ini


    diff <(crudini --get --format=lines file1.ini|sort) \
         <(crudini --get --format=lines file2.ini|sort)


    crudini --ini-options=nospace --set config_file ""


    crudini --ini-options=nospace --set config_file section parameter value


    crudini --ini-options=ignoreindent --format=lines --get ~/.gitconfig
  ```


  On windows ensure a python interpreter is installed.
  For example installing from https://www.python.org/downloads/
  will put the py launcher and pip in the PATH.

  Then ensure the iniparse module is installed by
  running the following from a "cmd" prompt:

  ```
  pip install iniparse
  ```

  Then crudini can be invoked by downloading just the crudini.py
  file and running like:

  ```
  py crudini.py --help
  ```

  On Linux systems crudini is generally available from your standard
  package manager, and installing will also ensure the iniparse
  dependency is appropriately installed on your system.
  You can also download and run the single crudini.py file directly
  to use latest version.


pkgId: ad5043c7a4079fde7109331092bd10894485a7fa4ee9e9c71d619943eb38559c
name: python-crudlfap
arch: src
version: 0.10.19
epoch: 0
release: 1
summary: Rich frontend for generic views with Django
url: https://yourlabs.io/oss/crudlfap
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crudlfap-0.10.19-1.src.rpm
checksum_type: sha256
description:
  This should start the example project from ``src/crudlfap_example`` where each
  documented example lives::
      
      pip install --user -e git+https://github.com/yourlabs/crudlfap.git#egg=crudlfap[example]
      cd src/crudlfap
      ./manage.py migrate
      ./manage.py createsuperuser
      ./manage.py runserver


pkgId: 9bc4adac1029b5557c5aeeb99ef9aca38f7bb03dcde1be18a52084700bdce80d
name: python-cruft
arch: src
version: 2.15.0
epoch: 0
release: 1
url: https://pypi.org/project/cruft/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cruft-2.15.0-1.src.rpm
checksum_type: sha256
summary:
  Allows you to maintain all the necessary cruft for packaging and building projects separate from the code you intentionally write. Built on-top of CookieCutter.

description:
  [![cruft - Fight Back Against the Boilerplate Monster!](https://raw.github.com/cruft/cruft/master/art/logo_large.png)](https://cruft.github.io/cruft/)
  _________________

  [![PyPI version](https://badge.fury.io/py/cruft.svg)](http://badge.fury.io/py/cruft)
  [![Conda Version](https://img.shields.io/conda/vn/conda-forge/cruft.svg)](https://anaconda.org/conda-forge/cruft)
  [![Build Status](https://github.com/cruft/cruft/workflows/Run%20tests/badge.svg)](https://github.com/cruft/cruft/actions?query=workflow%3A%22Run+tests%22+branch%3Amaster)
  [![codecov](https://codecov.io/gh/cruft/cruft/branch/master/graph/badge.svg)](https://codecov.io/gh/cruft/cruft)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://timothycrosley.github.io/isort/)
  [![Join the chat at https://gitter.im/cruft/community](https://badges.gitter.im/cruft/community.svg)](https://gitter.im/cruft/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  [![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://pypi.python.org/pypi/cruft/)
  [![Downloads](https://pepy.tech/badge/cruft)](https://pepy.tech/project/cruft)



  [![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/0)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/0)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/1)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/1)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/2)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/2)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/3)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/3)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/4)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/4)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/5)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/5)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/6)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/6)[![](https://sourcerer.io/fame/samj1912/cruft/cruft/images/7)](https://sourcerer.io/fame/samj1912/cruft/cruft/links/7)
  _________________

  [Read Latest Documentation](https://cruft.github.io/cruft/) - [Browse GitHub Code Repository](https://github.com/cruft/cruft/)
  _________________

  **cruft** allows you to maintain all the necessary boilerplate for packaging and building projects separate from the code you intentionally write.
  Fully compatible with existing [Cookiecutter](https://github.com/cookiecutter/cookiecutter) templates.

  Creating new projects from templates using cruft is easy:

  ![Example Usage New Project](https://raw.githubusercontent.com/cruft/cruft/master/art/example.gif)

  And, so is updating them as the template changes overtime:

  ![Example Usage New Project](https://raw.githubusercontent.com/cruft/cruft/master/art/example_update.gif)

  Many project template utilities exist that automate the copying and pasting of code to create new projects. This *seems* great! However, once created, most leave you with that copy-and-pasted code to manage through the life of your project.

  cruft is different. It automates the creation of new projects like the others, but then it also helps you to manage the boilerplate through the life of the project. cruft makes sure your code stays in-sync with the template it came from for you.



  * **Cookiecutter Compatible**: cruft utilizes [Cookiecutter](https://github.com/cookiecutter/cookiecutter) as its template expansion engine. Meaning it retains full compatibility with all existing [Cookiecutter](https://github.com/cookiecutter/cookiecutter) templates.
  * **Template Validation**: cruft can quickly validate whether or not a project is using the latest version of a template using `cruft check`. This check can easily be added to CI pipelines to ensure your projects stay in-sync.
  * **Automatic Template Updates**: cruft automates the process of updating code to match the latest version of a template, making it easy to utilize template improvements across many projects.



  To get started - install `cruft` using a Python package manager:

  `pip3 install cruft`

  OR

  `poetry add cruft`

  OR

  `pipenv install cruft`




  To create a new project using cruft run `cruft create PROJECT_URL` from the command line.

  For example:

          cruft create https://github.com/timothycrosley/cookiecutter-python/

  cruft will then ask you any necessary questions to create your new project. It will use your answers to expand the provided template, and then return the directory it placed the expanded project.
  Behind the scenes, cruft uses [Cookiecutter](https://github.com/cookiecutter/cookiecutter) to do the project expansion. The only difference in the resulting output is a `.cruft.json` file that
  contains the git hash of the template used as well as the template variables specified.



  To update an existing project, that was created using cruft, run `cruft update` in the root of the project.
  If there are any updates, cruft will have you review them before applying. If you accept the changes cruft will apply them to your project
  and update the `.cruft.json` file for you.

  !!! tip
      Sometimes certain files just aren't good fits for updating. Such as test cases or `__init__` files. You can tell cruft to always skip updating these files on a project by generating project with `--skip cruft/__init__.py --skip tests` arguments or manually adding them to a skip section within your `.cruft.json` file:

          {
              "template": "https://github.com/timothycrosley/cookiecutter-python",
              "commit": "8a65a360d51250221193ed0ec5ed292e72b32b0b",
              "skip": [
                  "cruft/__init__.py",
                  "tests"
              ],
              ...
          }

      Or, if you have toml installed, you can add skip files directly to a `tool.cruft` section of your `pyproject.toml` file:

          [tool.cruft]
          skip = ["cruft/__init__.py", "tests"]

      Note that it is possible to use glob patterns for selecting the files to skip:
          {
              "skip": [
                  "**/__init__.py",
                  "tests/*"
              ],
              ...
          }



  `cruft` can also be used to update a project to use new values of template variables; avoiding the need to regenerate
  the project from sratch using `cookiecutter`.

  For example, imagine a project that was initially generated some while ago, and then later on, you want to change the
  values of some of the template variables, e.g. to change `use_some_feature` to `"yes"` or to change `project_name` to
  `"new-project-name"`.

  There are 2 ways this can be done, as described below.



  You can perform the update directly via the command line if you have only a handful of simple variables.

  This will change `use_some_feature` to `"yes"` while leaving all other variables unchanged:
  ```bash
  cruft update --variables-to-update '{ "use_some_feature" : "yes" }'
  ```

  This will change both `use_some_feature` to `"yes"` and `project_name` to `"new-project-name"` (and still leaving all
  other variables unchanged):
  ```bash
  cruft update --variables-to-update '{ "use_some_feature" : "yes", "project_name" : "new-project-name" }'
  ```

  The provided argument must be a valid JSON string (i.e. using double quotes, no trailing comma etc.).



  If you prefer to use and editor or you have many or complex variables, you can also perform the changes via providing an
  updated .cruft.json.

  ```bash

  cp .cruft.json ~/tmp/new-cruft.json


  edit ~/tmp/new-cruft.json



  cruft update --variables-to-update-file ~/tmp/new-cruft.json
  ```



  Checking to see if a project is missing a template update is as easy as running `cruft check`. If the project is out-of-date an error and exit code 1 will be returned.
  `cruft check` can be added to CI pipelines to ensure projects don't unintentionally drift.




  Have an existing project that you created from a template in the past using Cookiecutter directly? You can link it to the template that was used to create it using: `cruft link TEMPLATE_REPOSITORY`.

  For example:

          cruft link https://github.com/timothycrosley/cookiecutter-python/

  You can then specify the last commit of the template the project has been updated to be consistent with, or accept the default of using the latest commit from the template.



  With time, your boilerplate may end up being very different from the actual cookiecutter template. Cruft allows you to quickly see what changed in your local project compared to the template. It is as easy as running `cruft diff`. If any local file differs from the template, the diff will appear in your terminal in a similar fashion to `git diff`.

  The `cruft diff` command optionally accepts an `--exit-code` flag that will make cruft exit with a non-0 code should any diff is found. You can combine this flag with the `skip` section of your `.cruft.json` to make stricter CI checks that ensures any improvement to the template is always submitted upstream.



  If you have many repositories to manage, you can automate the change detection process with GitHub Actions. This example runs every Monday at 2am UTC and creates a new pull request if there are changes detected which a maintainer can accept or reject. It creates two PRs - one to pull in the new files to the repository and one to update the `.cruft.json` file only, which has the effect of rejecting the change from the upstream repository.

  > Since Jan 2022, registries/organisations must explicitly grant the authority to create a pull request. This can be enabled on a per-organisation level, or a per-registry level for personal projects. See [GitHub](https://github.blog/changelog/2022-05-03-github-actions-prevent-github-actions-from-creating-and-approving-pull-requests/) for more details.

  ```yaml

  name: Update repository with Cruft
  permissions:
    contents: write
    pull-requests: write
  on:
    schedule:
      - cron: "0 2 * * 1" # Every Monday at 2am
  jobs:
    update:
      runs-on: ubuntu-latest
      strategy:
        fail-fast: true
        matrix:
          include:
            - add-paths: .
              body: Use this to merge the changes to this repository.
              branch: cruft/update
              commit-message: "chore: accept new Cruft update"
              title: New updates detected with Cruft
            - add-paths: .cruft.json
              body: Use this to reject the changes in this repository.
              branch: cruft/reject
              commit-message: "chore: reject new Cruft update"
              title: Reject new updates detected with Cruft
      steps:
        - uses: actions/checkout@v3

        - uses: actions/setup-python@v4
          with:
            python-version: "3.10"

        - name: Install Cruft
          run: pip3 install cruft

        - name: Check if update is available
          continue-on-error: false
          id: check
          run: |
            CHANGES=0
            if [ -f .cruft.json ]; then
              if ! cruft check; then
                CHANGES=1
              fi
            else
              echo "No .cruft.json file"
            fi

            echo "has_changes=$CHANGES" >> "$GITHUB_OUTPUT"

        - name: Run update if available
          if: steps.check.outputs.has_changes == '1'
          run: |
            git config --global user.email "you@example.com"
            git config --global user.name "GitHub"

            cruft update --skip-apply-ask --refresh-private-variables
            git restore --staged .

        - name: Create pull request
          if: steps.check.outputs.has_changes == '1'
          uses: peter-evans/create-pull-request@v4
          with:
            token: ${{ secrets.GITHUB_TOKEN }}
            add-paths: ${{ matrix.add-paths }}
            commit-message: ${{ matrix.commit-message }}
            branch: ${{ matrix.branch }}
            delete-branch: true
            branch-suffix: timestamp
            title: ${{ matrix.title }}
            body: |
              This is an autogenerated PR. ${{ matrix.body }}

              [Cruft](https://cruft.github.io/cruft/) has detected updates from the Cookiecutter repository.
  ```



  Since I first saw videos of [quickly](https://www.youtube.com/watch?v=9EctXzH2dss) being used to automate Ubuntu application creation, I've had a love/hate relationship with these kinds of tools.
  I've used them for many projects and certainly seen them lead to productivity improvements. However, I've always felt like they were a double-edged sword. Sure, they would automate away the copying and pasting many would do to create projects. However, by doing so,
  they encouraged more code to be copied and pasted! Then, over time, you could easily be left with hundreds of projects that contained copy-and-pasted code with no way to easy way to update them. I created cruft to be a tool that recognized that balance between project creation and maintenance and provided mechanisms to keep built projects up-to-date.

  I hope you too find `cruft` useful!

  ~Timothy Crosley


pkgId: ff1b43a46a3acd433394f7e22e0651040c2d366663b08596e9e9438bc4051bd5
name: python-cruise-control-client
arch: src
version: 1.1.3
epoch: 0
release: 1
summary: A Python client for cruise-control
url: https://github.com/linkedin/cruise-control
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cruise-control-client-1.1.3-1.src.rpm
checksum_type: sha256
description:
  `cruise-control-client` is an API-complete Python client for [`cruise-control`](https://github.com/linkedin/cruise-control).

  It comes with a command-line interface to the client (`cccli`) (see [README](https://github.com/linkedin/cruise-control/tree/master/docs/wiki/Python%20Client)).

  `cruise-control-client` can also be used in Python applications needing programmatic access to `cruise-control`.

rpm_license:
  Copyright 2019 LinkedIn Corp. Licensed under the BSD 2-Clause License (the "License"). See License in the project root for license information.


pkgId: 01d95f52848770716183eaecda74f129cf4e11d03144774d593dd89cd3116eef
name: python-crunpyroll
arch: src
version: 2.4.5
epoch: 0
release: 1
summary: Async API wrapper for Crunchyroll
url: https://github.com/stefanodvx/crunpyroll
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crunpyroll-2.4.5-1.src.rpm
checksum_type: sha256
description:
  - Fully async ([httpx](https://www.python-httpx.org/))
  - Python 3.7+ support
  - Clean and modern code


pkgId: 0d6643291c721da3f51945705e44c8a3d6d6d91e33df4ae03f2125e06e59e086
name: python-crux
arch: src
version: 1.3
epoch: 0
release: 1
summary: Crux Informatics API client library
url: https://github.com/cruxinformatics/crux-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crux-1.3-1.src.rpm
checksum_type: sha256
description:
  A Python library for interacting with the Crux platform.

  The aim of this module is to be a Pythonic way to use the Crux API reliably. It covers client functionality including scanning subscriptions, getting delivery status, and downloading files.

  Python 3.6+ is supported.

  **See [crux-python.cruxinformatics.com](https://crux-python.cruxinformatics.com/) for detailed documentation.**



  Install a recent version of Python, and a Python dependency and virtual environment manager like [pipenv](https://pipenv.readthedocs.io/en/latest/). On macOS run:

  ```bash
  brew install python
  brew install pipenv
  ```

  Install `crux` [from PyPI](https://pypi.org/project/crux/) in a virtual environment, and get a shell in that environment:

  ```bash
  mkdir -p crux_example
  cd crux_example
  pipenv install "crux==1.3"
  pipenv shell
  ```


  Create a file, like example.py, and use the `crux` module:

  ```python
  from crux import Crux

  conn = Crux()
  identity = conn.whoami()
  print("I am", identity.email)
  ```

  Run the script:

  ```bash
  HISTCONTROL=ignoreboth
   export CRUX_API_KEY='YOUR_API_KEY'
  python3 example.py
  ```

  See the [installation](https://crux-python.cruxinformatics.com/en/latest/installation.html) and [authentication](https://crux-python.cruxinformatics.com/en/latest/authentication.html) documentation for details.



  Python 3.7 is required for development, which can be installed with `brew install python`. For heavy development work, every supported version of Python must be installed, see the pyenv documentation below.

  [Pipenv](https://pipenv.readthedocs.io/en/latest/) should be used to manage dependancies during development.

  1. [Install Pipenv](https://pipenv.readthedocs.io/en/latest/install/#installing-pipenv), on macOS run `brew install pipenv`
  2. `git clone https://github.com/cruxinformatics/crux-python.git`
  3. `cd crux-python`
  4. `pipenv install --dev` to install the dependancies
  5. `pipenv shell` to get a shell in the virtual environment



  To be able to run tests against all supported Python versions, you must have all supported Python versions installed. The test runner will look for binaries called `python2.7`, `python3.5`, `python3.6`, etc. There are multiple ways to install Python versions, we'll document using [pyenv](https://github.com/pyenv/pyenv).

  1. `brew install pyenv` to install
  2. Put `eval "$(pyenv init -)"` towards the end of the shell configuration file (~/.bashrc or ~/.bash_profile), because it manipulates `$PATH`, for example:

      ```bash
      echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init -)"\nfi' >> ~/.bashrc
      ```

  3. Open a new Terminal to get an updated shell
  4. Install required/missing Python versions (this assumes you have Python 2.7 already installed, otherwise install it too):

      ```bash
      pyenv install 3.5.6
      pyenv install 3.6.6
      pyenv install 3.7.0
      ```

  5. `pyenv global system 3.5.6 3.6.6 3.7.0` to make all the Python versions available
  6. If you already have pipenv virtual environment, remove it with `pipenv --rm` so it detects the Python versions
  7. `pipenv install --dev` to install all the dependancies
  8. `pipenv shell` to get a shell in the virtual environment



  We use [Nox](https://nox.thea.codes/en/stable/) to automate running tests, and use `make` to automate running some commands. These commands should be run within a shell created with `pipenv shell`.

  ```bash

  make test

  nox


  make lint

  nox -s lint


  make unit

  nox -s unit


   export CRUX_API_KEY="12345"
  export CRUX_API_HOST="https://api.example.com"
  make integration

   export CRUX_API_KEY="12345"
  export CRUX_API_HOST="https://api.example.com"
  nox --s integration


  make format_check

  nox -s format_check


  make

  nox -l


  nox -s unit-3.7


  make format


  make docs
  ```



  Manual testing scripts could be found at `tests/regression`.
  In order to run one, i.e. `client.py`, follow the steps:

  1. copy corresponding `.env.dist` file as `.env` file (if you plan to run `client.py`, copy `client.env.dist` as `client.env`)
  2. fill variables within `.env` file
  3. launch the script (while being in the `tests/regression` folder, execute `python client.py`)


pkgId: 95b803d2ff77c8801833153378a522445fa73cefc66b10d0337400241f045d6b
name: python-crx-hslayers
arch: src
version: 4.0.0
epoch: 0
release: 1
summary: HSLayers-NG integrated into Wagtail CMS with Codered
url: https://github.com/hslayers/crx-hslayers
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crx-hslayers-4.0.0-1.src.rpm
checksum_type: sha256
description:
  Note: Has npm dependency on [HSLayers-NG](https://www.npmjs.com/package/hslayers-ng-app) that gets automatically installed into static files. `python manage.py collectstatic` must be executed for the module to correctly locate the HSLayers bundles.



  1. Install this package from PyPi using folowing command:

  ```
  $ pip install crx-hslayers
  ```

  2. Add 'hslayers' and 'wagtail_crx_block_frontend_assets' to the INSTALLED_APPS list in the settings/base.py

  ```
  INSTALLED_APPS = [
      
      'website',

      
      'coderedcms',
      'bootstrap4',
      ...
      'wagtail_crx_block_frontend_assets',
      'crx_hslayers'
  ]
  ```

  3. Install HSLayers app package from npm

  ```
  cd ./static/hslayers
  npm install
  ```

  4. Use crx_hslayers in any of your Wagtail models and migrate properly

  5. Collect static files from crx-hslayers to your Wagtail site

  ```
  $ python3 manage.py collectstatic
  ```

  6. Restart Wagtail

  7. New HSLayers blocks are added to the CMS
     - HSLayers map
     - Clima map



  Update semantic version of the package

  Run test update without commiting

  ```
  $ bumpver update --patch(--minor|--major) --dry
  ```

  Run update and commit the changes to the repo

  ```
  $ bumpver update --patch(--minor|--major)
  ```



  Delete all previous builds in the dist/\* directory.

  Linux:

  ```
  python3 -m build
  python3 -m pip install --upgrade twine
  python3 -m twine upload dist/*
  ```

  Windows:

  ```
  py -m build
  py -m pip install --upgrade twine
  py -m twine upload dist/*
  ```

  Use `__token__` for the username and API token acquired at pypi.org for password.

  Upload to Test PyPi:

  ```
  python3 -m twine upload --repository testpypi dist/*
  ```


pkgId: 35c2ed581e172f41721cad268e0cd6d6d6c7e962c9baf8e9db78ac000a7962c3
name: python-crx3
arch: src
version: 0.0.3
epoch: 0
release: 1
summary: Chrome extension (crx) packaging & parsing library.
url: https://github.com/liying2008/python-crx3
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crx3-0.0.3-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/crx3)](https://pypi.org/project/crx3/)
  [![PyPI Supported Python Versions](https://img.shields.io/pypi/pyversions/crx3.svg)](https://pypi.python.org/pypi/crx3/)
  [![Downloads](https://static.pepy.tech/badge/crx3)](https://pepy.tech/project/crx3)
  [![GitHub Actions (Tests)](https://github.com/liying2008/python-crx3/actions/workflows/tests.yml/badge.svg)](https://github.com/liying2008/python-crx3/actions/workflows/tests.yml)

  **crx3** is a python library for packaging and parsing crx files.



  `crx3` is available on PyPI:

  ```console
  $ python -m pip install crx3
  ```

  crx3 officially supports Python 3.7+.



  - Create a private key for signing the crx file.

  ```python
  from crx3 import creator

  creator.create_private_key_file('output/example-extension.pem')
  ```

  - Packaging a zip file or extension code directory to a crx file.

  ```python
  from crx3 import creator

  creator.create_crx_file('example/example-extension', 'example/example-extension.pem', 'output/example-extension.crx')
  ```

  - Verify if a file is a valid crx version 3 file.

  ```python
  from crx3 import verifier

  verifier_result, header_info = verifier.verify('example/example-extension.crx')

  assert verifier_result == verifier.VerifierResult.OK_FULL
  assert header_info.crx_id == 'jjomgndeajdmncfenopimafofpnflcfo'
  assert header_info.public_key == 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMI...FkbU7H8sDQIDAQAB'
  ```



  - **Create a crx file.**

  `crx3 create [-pk PRIVATE_KEY_FILE] [-o OUTPUT_FILE] [-v] source`

  ```
  usage: crx3 create [-h] [-pk PRIVATE_KEY_FILE] [-o OUTPUT_FILE] [-v] source

  positional arguments:
    source                zip file or directory to be packed

  options:
    -h, --help            show this help message and exit
    -pk PRIVATE_KEY_FILE, --private-key PRIVATE_KEY_FILE
                          private key file to be used for signing. If not specified, the program automatically creates a new one and saves it to the same directory as the crx file
    -o OUTPUT_FILE, --output OUTPUT_FILE
                          path to the output crx file
    -v, --verbose         print more information
  ```

  - **Verify that a crx file is valid.**

  `crx3 verify [-v] crx_file`

  ```
  usage: crx3 verify [-h] [-v] crx_file
  positional arguments:
    crx_file       crx file

  options:
    -h, --help     show this help message and exit
    -v, --verbose  print more information
  ```


pkgId: 21f7df479a335df347da5d9d174d1df451872fac95381a0220f9c0181978dcdb
name: python-crxsnake
arch: src
version: 1.3.9
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://discord.gg/EEp67FWQDP
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crxsnake-1.3.9-1.src.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: 766ef196853c42f6809bac7a26715e3633fdd8c79a0a71bd597e578f1ed893fb
name: python-cryocanvas
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: A plugin for interactive segmentation of CryoET data using ML embeddings
url: https://github.com/kephale/cryocanvas
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryocanvas-0.0.1-1.src.rpm
checksum_type: sha256
description:
  A tool to support interactive machine learning for cryoET data

  ![cryocanvas screenshot](cover.png)


pkgId: ad672f6dda050490e26ee9453b4ab2adcd1191ee714f1594440871edcbff35d4
name: python-cryodrgn
arch: src
version: 3.4.2
epoch: 0
release: 1
summary: cryoDRGN heterogeneous reconstruction
url: https://github.com/zhonge/cryodrgn
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryodrgn-3.4.2-1.src.rpm
checksum_type: sha256
description:
  ![pypi-downloads](https://img.shields.io/pypi/dm/cryodrgn?style=flat&label=PyPI%20Downloads&logo=pypi&logoColor=%233775A9&labelColor=%23FFF8EC)
  ![stable-release](https://img.shields.io/pypi/v/cryodrgn?style=flat&logo=pypi&logoColor=%233775A9&logoSize=auto&label=stable%20release&labelColor=%23FFF8EC)
  ![beta-release](https://img.shields.io/pypi/v/cryodrgn?pypiBaseUrl=https%3A%2F%2Ftest.pypi.org&style=flat&logo=pypi&logoColor=%233775A9&logoSize=auto&label=beta%20release&labelColor=%23FFF8EC)
  ![grading](https://img.shields.io/codefactor/grade/github/ml-struct-bio/cryodrgn/main?style=flat&logo=codefactor&logoColor=%23F44A6A&logoSize=auto&label=CodeFactor%20Grade&labelColor=%23FFF8EC)
  ![ci-test](https://github.com/ml-struct-bio/cryodrgn/actions/workflows/tests.yml/badge.svg)




  CryoDRGN is a neural network based algorithm for heterogeneous cryo-EM reconstruction. In particular, the method models
  a *continuous* distribution over 3D structures by using a neural network based representation for the volume.




  The latest documentation for cryoDRGN is available in our [user guide](https://ez-lab.gitbook.io/cryodrgn/), including an overview and walkthrough of
  cryoDRGN installation, training and analysis. A brief quick start is provided below.

  For any feedback, questions, or bugs, please file a Github issue or start a Github discussion.



  * [NEW] `cryodrgn plot_classes` for analysis visualizations colored by a given set of class labels
  * implementing [automatic mixed-precision training](https://pytorch.org/docs/stable/amp.html)
    for ab-initio reconstruction for 2-4x speedup
  * support for RELION 3.1 .star files with separate optics tables, np.float16 number formats used in RELION .mrcs outputs
  * `cryodrgn backproject_voxel` produces cryoSPARC-style FSC curve plots with phase-randomization correction of
    automatically generated tight masks
  * `cryodrgn downsample` can create a new .star or .txt image stack from the corresponding stack format instead of
    always writing to an .mrcs stack; now also always puts output files into a folder
  * fixing issues with `cryodrgn filter` such as less intrusive annotation text and `np.array` instead of `list` output
    format and `do_pose_sgd` errors
  * official support for Python 3.11




  The official release of [cryoDRGN-ET](https://www.biorxiv.org/content/10.1101/2023.08.18.553799v1) for heterogeneous subtomogram analysis.

  * [NEW] Heterogeneous reconstruction of subtomograms. See documentation [on gitbook](https://ez-lab.gitbook.io/cryodrgn/)
  * Updated `cryodrgn backproject_voxel` for voxel-based homogeneous reconstruction
  * Major refactor of dataset loading for handling large datasets




  <details><summary>Version 3.3</summary><ul>
    <li>[NEW] <code>cryodrgn direct_traversal</code> to generate interpolations in the conformation latent space
  between two points</li>
    <li>support for .txt files in <code>write_star</code></li>
    <li>adding <code>--datadir</code> to <code>cryodrgn abinit_homo</code> for use with .star files</li>
    <li>fixing various bugs in <code>backproject_voxel</code>, Jupyter demonstration notebooks</li>
    <li>support for TestPyPI beta release deployments via <code>pip</code></li>
  </ul></details>

  <details><summary>Version 3.2</summary><ul>
    <li>[NEW] <code>cryodrgn_utils clean</code> for removing extraneous output files from completed experiments</li>
    <li>[NEW] <code>cryodrgn_utils fsc</code>, <code>cryodrgn_utils fsc_plot</code>,
  <code>cryodrgn_utils gen_mask</code>adapted from existing scripts — for calculating FSCs, plotting them, and
  generating masks for volumes respectively</li>
    <li><code>cryodrgn backproject_voxel</code> now produces half-maps and a half-map FSC</li>
    <li>fixing <code>filter_star</code> to accept tilt series as well</li>
    <li>fixing assorted bugs in e.g. <code>write_star</code>, <code>invert_constrast</code>, and
  <code>train_vae</code> (see release notes)
  </ul></details>

  <details><summary>Version 3.1</summary><ul>
    <li><code>cryodrgn filter</code> interface for interactive filtering of particles as an alternative to the
  cryoDRGN_filter Jupyter notebook</li>
  </ul></details>

  <details><summary>Version 2.3</summary><ul>
    <li>Model configuration files are now saved as human-readable config.yaml files
  (https://github.com/zhonge/cryodrgn/issues/235)</li>
    <li>Fix machine stamp in output .mrc files for better compatibility with downstream tools
  (https://github.com/zhonge/cryodrgn/pull/260)</li>
    <li>Better documentation of help flags in ab initio reconstruction tools
  (https://github.com/zhonge/cryodrgn/issues/258)</li>
    <li>[FIX] By default, window images in <code>cryodrgn abinit_homo</code> (now consistent with other reconstruction
  tools) (https://github.com/zhonge/cryodrgn/issues/258)</li>
    <li>[FIX] Reduce memory usage when using <code>--preprocessed</code>
  and <code>--ind</code> (https://github.com/zhonge/cryodrgn/pull/272)</li>
  </ul></details>

  <details><summary>Version 2.2</summary><ul>
    <li>[NEW] Tools for ab initio homogeneous and heterogeneous reconstruction:

      (cryodrgn) $ cryodrgn abinit_homo -h
      (cryodrgn) $ cryodrgn abinit_het -h
    </li>

    <li>[NEW] Utils function for writing cryoSPARC .cs/.csg files
  [to reimport data into cryoSPARC](https://github.com/zhonge/cryodrgn/issues/150#issuecomment-1465094751):


      (cryodrgn) $ cryodrgn_utils write_cs
    </li>
    <li>[Improved plotting](https://github.com/zhonge/cryodrgn/issues/219) in <code>cryodrgn analyze</code></li>
    <li>Many codebase improvements with open-source software development practices (e.g. continuous integration tests,
  black, flake8, pyright, logging, and PyPi packaging).</li>
  </ul></details>

  <details><summary>Version 1.1.x</summary>
  Updated default parameters for <code>cryodrgn train_vae</code> with modified positional encoding, larger model
  architecture, and accelerated mixed-precision training turned on by default:
  <ul>
    <li>Mixed precision training is now turned on by default (Use <code>--no-amp</code> to revert to single precision
  training)</li>
    <li>Encoder/decoder architecture is now 1024x3 by default (Use <code>--enc-dim 256</code> and <code>--dec-dim
  256</code> to revert)
  </li>
    <li>Gaussian Fourier featurization for faster training and higher resolution density maps (Use <code>--pe-type
  geom_lowf</code>
  to revert)</li>
  </ul></details>

  <details><summary>Version 1.0.x</summary>
  The official version 1.0 release. This version introduces several new tools for analysis of the reconstructed ensembles,
  and adds functionality for calling utility scripts with <code>cryodrgn_utils {command}</code>.
  <ul>
    <li>NEW: <code>cryodrgn analyze_landscape</code> and <code>cryodrgn analyze_landscape_full</code> for automatic
  assignment of classes and conformational landscape visualization. Documentation for this new feature is here:
  https://www.notion.so/cryodrgn-conformational-landscape-analysis-a5af129288d54d1aa95388bdac48235a.</li>
    <li>NEW: Faster training and higher resolution model
  with Gaussian Fourier featurization (Use <code>--pe-type gaussian</code>)</li>
    <li>NEW: <code>cryodrgn_utils {command} -h</code> for standalone utility scripts</li>
    <li>NEW: <code>cryodrgn_utils write_star</code> for converting cryoDRGN particle selections to .star files</li>
    <li>Add pytorch native mixed precision training and fix support for pytorch 1.9+</li>
  </ul></details>

  <details><summary>Version 0.3.4</summary><ul>
      <li>FIX: Bug in write_starfile.py when provided particle stack is chunked (.txt file)</li>
      <li>Support micrograph coordinates and additional column headers to write_starfile.py</li>
      <li>New helper scripts: analyze_convergence.py (<i>in beta testing</i>) contributed by <a href="bmp@mit.
  edu">Barrett
  Powell</a> (thanks!) and make_random_selection.py for splitting up particle stacks for training</li>
  </ul></details>

  <details><summary>Version 0.3.3</summary><ul>
      <li>Faster image preprocessing and smaller memory footprint</li>
      <li>New: <code>cryodrgn preprocess</code> for large datasets (<i>in beta testing</i> - see
  <a href="https://www.notion.so/cryodrgn-preprocess-d84a9d9df8634a6a8bfd32d6b5e737ef">this Notion doc</a> for details)
  </li>
      <li>* Known <a href="https://github.com/zhonge/cryodrgn/issues/66">issue</a> with PyTorch version 1.9+</li>
  </ul></details>

  <details><summary>Version 0.3.2</summary><ul>
      <li>New: cryoDRGN_filtering.ipynb for interactive filtering and selection of images from the dataset</li>
      <li>New: <code>cryodrgn view_config</code></li>
      <li>Minor performance improvements and compatibility fixes</li>
  </ul></details>

  <details><summary>Version 0.3.1</summary><ul>
      <li>New: Script write_starfile.py to convert (filtered) particle selection to a .star file</li>
      <li>More visualizations in <code>cryodrgn analyze</code></li>
  </ul></details>

  <details><summary>Version 0.3.0</summary><ul>
      <li>New: GPU parallelization with flag <code>--multigpu</code></li>
      <li>New: Mode for accelerated mixed precision training with flag <code>--amp</code>, available for NVIDIA
  tensor core GPUs</li>
      <li>Interface update: renamed encoder arguments <code>--qdim</code> and <code>--qlayers</code> to
  <code>--enc-dim</code> and <code>--enc-layers</code>; renamed decoder arguments <code>--pdim</code> and
  <code>--players</code> to <code>--dec-dim</code> and <code>--dec-layers</code></li>
      <li>Argument default changes: flipped the default for <code>--invert-data</code> to True by default, and
  flipped the default for <code>--window</code> to True by default</li>
      <li>Updated training recommendations in below quick start guide</li>
      <li>Updates to cryodrgn analyze: more visualizations, ordering kmeans volumes according to distances in latent
  space (previously random), and more features for particle selection and filtering in the Jupiter notebook</li>
  </ul></details>

  <details><summary>Version 0.2.1</summary><ul>
      <li>New: Parsing of RELION 3.1 files</li>
      <li>Fix: Compatibility with pytorch 1.5</li>
  </ul></details>

  <details><summary>Version 0.2.0</summary><ul>
      <li>New interface and proper python packaging with setup.py. This version has identical functionality and
  argument usage as previous versions, however tools are now available from a common entry point. See:

  ```$ cryodrgn -h```

  </li>
  <li>New analysis pipeline <code>cryodrgn analyze</code></li>
  <li>New latent space traversal scripts with
  <code>cryodrgn graph_traversal</code> and <code>cryodrgn pc_traversal</code>.</li>
  </ul></details>




  `cryodrgn` may be installed via `pip`, and we recommend installing `cryodrgn` in a clean conda environment.

      
      (base) $ conda create --name cryodrgn python=3.9
      (cryodrgn) $ conda activate cryodrgn

      
      (cryodrgn) $ pip install cryodrgn

  You can alternatively install a newer, less stable, development version of `cryodrgn` using our beta release channel:

      (cryodrgn) $ pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ cryodrgn --pre

  More installation instructions are found in the [documentation](https://ez-lab.gitbook.io/cryodrgn/installation).





  First resize your particle images using the `cryodrgn downsample` command:

  <details><summary><code>$ cryodrgn downsample -h</code></summary>

      usage: cryodrgn downsample [-h] -D D -o MRCS [--is-vol] [--chunk CHUNK]
                                 [--datadir DATADIR]
                                 mrcs

      Downsample an image stack or volume by clipping fourier frequencies

      positional arguments:
        mrcs               Input images or volume (.mrc, .mrcs, .star, .cs, or .txt)

      optional arguments:
        -h, --help         show this help message and exit
        -D D               New box size in pixels, must be even
        -o MRCS            Output image stack (.mrcs) or volume (.mrc)
        --is-vol           Flag if input .mrc is a volume
        --chunk CHUNK      Chunksize (in # of images) to split particle stack when
                           saving
        --relion31         Flag for relion3.1 star format
        --datadir DATADIR  Optionally provide path to input .mrcs if loading from a
                           .star or .cs file
        --max-threads MAX_THREADS
                           Maximum number of CPU cores for parallelization (default: 16)
        --ind PKL          Filter image stack by these indices

  </details>

  We recommend first downsampling images to 128x128 since larger images can take much longer to train:

      $ cryodrgn downsample [input particle stack] -D 128 -o particles.128.mrcs

  The maximum recommended image size is D=256, so we also recommend downsampling your images to D=256 if your images
  are larger than 256x256:

      $ cryodrgn downsample [input particle stack] -D 256 -o particles.256.mrcs

  The input file format can be a single `.mrcs` file, a `.txt` file containing paths to multiple `.mrcs` files, a RELION
  `.star` file, or a cryoSPARC `.cs` file. For the latter two options, if the relative paths to the `.mrcs` are broken,
  the argument `--datadir` can be used to supply the path to where the `.mrcs` files are located.

  If there are memory issues with downsampling large particle stacks, add the `--chunk 10000` argument to
  save images as separate `.mrcs` files of 10k images.



  CryoDRGN expects image poses to be stored in a binary pickle format (`.pkl`). Use the `parse_pose_star` or
  `parse_pose_csparc` command to extract the poses from a `.star` file or a `.cs` file, respectively.

  Example usage to parse image poses from a RELION 3.1 starfile:

      $ cryodrgn parse_pose_star particles.star -o pose.pkl

  Example usage to parse image poses from a cryoSPARC homogeneous refinement particles.cs file:

      $ cryodrgn parse_pose_csparc cryosparc_P27_J3_005_particles.cs -o pose.pkl -D 300

  **Note:** The `-D` argument should be the box size of the consensus refinement (and not the downsampled
  images from step 1) so that the units for translation shifts are parsed correctly.



  CryoDRGN expects CTF parameters to be stored in a binary pickle format (`.pkl`).
  Use the `parse_ctf_star` or `parse_ctf_csparc` command to extract the relevant CTF parameters from a `.star` file
  or a `.cs` file, respectively.

  Example usage for a .star file:

      $ cryodrgn parse_ctf_star particles.star -o ctf.pkl

  If the box size and Angstrom/pixel values are not included in the .star file under fields `_rlnImageSize` and
  `_rlnImagePixelSize` respectively, the `-D` and `--Apix` arguments to `parse_ctf_star` should be used instead to
  provide the original parameters of the input file (before any downsampling):

      $ cryodrgn parse_ctf_star particles.star -D 300 --Apix 1.03 -o ctf.pkl

  Example usage for a .cs file:

      $ cryodrgn parse_ctf_csparc cryosparc_P27_J3_005_particles.cs -o ctf.pkl




  Next, test that pose and CTF parameters were parsed correctly using the voxel-based backprojection script.
  The goal is to quickly verify that there are no major problems with the extracted values and that the output structure
  resembles the structure from the consensus reconstruction before training.

  Example usage:

      $ cryodrgn backproject_voxel projections.128.mrcs \
              --poses pose.pkl \
              --ctf ctf.pkl \
              -o backproject.128 \
              --first 10000

  The output structure `backproject.128/backproject.mrc` will not match the consensus reconstruction exactly
  as the `backproject_voxel` command backprojects phase-flipped particles onto the voxel grid, and because here we
  performed backprojection using only the first 10k images in the stack for quicker results.
  If the structure is too noisy, we can try using more images with `--first` or the
  entire stack instead (without `--first`).

  **Note:** If the volume does not resemble your structure, you may need to use the flag `--uninvert-data`.
  This flips the data sign (e.g. light-on-dark or dark-on-light), which may be needed depending on the
  convention used in upstream processing tools.



  When the input images (.mrcs), poses (.pkl), and CTF parameters (.pkl) have been prepared, a cryoDRGN model
  can be trained with following command:

  <details><summary><code>$ cryodrgn train_vae -h</code></summary>

  	usage: cryodrgn train_vae [-h] -o OUTDIR --zdim ZDIM --poses POSES [--ctf pkl]
  	                          [--load WEIGHTS.PKL] [--checkpoint CHECKPOINT]
  	                          [--log-interval LOG_INTERVAL] [-v] [--seed SEED]
  	                          [--ind PKL] [--uninvert-data] [--no-window]
  	                          [--window-r WINDOW_R] [--datadir DATADIR] [--lazy]
  	                          [--max-threads MAX_THREADS]
  	                          [--tilt TILT] [--tilt-deg TILT_DEG] [-n NUM_EPOCHS]
  	                          [-b BATCH_SIZE] [--wd WD] [--lr LR] [--beta BETA]
  	                          [--beta-control BETA_CONTROL] [--norm NORM NORM]
  	                          [--no-amp] [--multigpu] [--do-pose-sgd]
  	                          [--pretrain PRETRAIN] [--emb-type {s2s2,quat}]
  	                          [--pose-lr POSE_LR] [--enc-layers QLAYERS]
  	                          [--enc-dim QDIM]
  	                          [--encode-mode {conv,resid,mlp,tilt}]
  	                          [--enc-mask ENC_MASK] [--use-real]
  	                          [--dec-layers PLAYERS] [--dec-dim PDIM]
  	                          [--pe-type {geom_ft,geom_full,geom_lowf,geom_nohighf,linear_lowf,gaussian,none}]
  	                          [--feat-sigma FEAT_SIGMA] [--pe-dim PE_DIM]
  	                          [--domain {hartley,fourier}]
  	                          [--activation {relu,leaky_relu}]
  	                          particles

  	Train a VAE for heterogeneous reconstruction with known pose

  	positional arguments:
  	  particles             Input particles (.mrcs, .star, .cs, or .txt)

  	optional arguments:
  	  -h, --help            show this help message and exit
  	  -o OUTDIR, --outdir OUTDIR
  	                        Output directory to save model
  	  --zdim ZDIM           Dimension of latent variable
  	  --poses POSES         Image poses (.pkl)
  	  --ctf pkl             CTF parameters (.pkl)
  	  --load WEIGHTS.PKL    Initialize training from a checkpoint
  	  --checkpoint CHECKPOINT
  	                        Checkpointing interval in N_EPOCHS (default: 1)
  	  --log-interval LOG_INTERVAL
  	                        Logging interval in N_IMGS (default: 1000)
  	  -v, --verbose         Increaes verbosity
  	  --seed SEED           Random seed

  	Dataset loading:
  	  --ind PKL             Filter particle stack by these indices
  	  --uninvert-data       Do not invert data sign
  	  --no-window           Turn off real space windowing of dataset
  	  --window-r WINDOW_R   Windowing radius (default: 0.85)
  	  --datadir DATADIR     Path prefix to particle stack if loading relative
  	                        paths from a .star or .cs file
  	  --lazy                Lazy loading if full dataset is too large to fit in
  	                        memory (Should copy dataset to SSD)
  	  --max-threads MAX_THREADS
  	                        Maximum number of CPU cores for FFT parallelization
  	                        (default: 16)

  	Tilt series:
  	  --tilt TILT           Particles (.mrcs)
  	  --tilt-deg TILT_DEG   X-axis tilt offset in degrees (default: 45)

  	Training parameters:
  	  -n NUM_EPOCHS, --num-epochs NUM_EPOCHS
  	                        Number of training epochs (default: 20)
  	  -b BATCH_SIZE, --batch-size BATCH_SIZE
  	                        Minibatch size (default: 8)
  	  --wd WD               Weight decay in Adam optimizer (default: 0)
  	  --lr LR               Learning rate in Adam optimizer (default: 0.0001)
  	  --beta BETA           Choice of beta schedule or a constant for KLD weight
  	                        (default: 1/zdim)
  	  --beta-control BETA_CONTROL
  	                        KL-Controlled VAE gamma. Beta is KL target. (default:
  	                        None)
  	  --norm NORM NORM      Data normalization as shift, 1/scale (default: 0, std
  	                        of dataset)
  	  --no-amp              Do not use mixed-precision training
  	  --multigpu            Parallelize training across all detected GPUs

  	Pose SGD:
  	  --do-pose-sgd         Refine poses with gradient descent
  	  --pretrain PRETRAIN   Number of epochs with fixed poses before pose SGD
  	                        (default: 1)
  	  --emb-type {s2s2,quat}
  	                        SO(3) embedding type for pose SGD (default: quat)
  	  --pose-lr POSE_LR     Learning rate for pose optimizer (default: 0.0003)

  	Encoder Network:
  	  --enc-layers QLAYERS  Number of hidden layers (default: 3)
  	  --enc-dim QDIM        Number of nodes in hidden layers (default: 1024)
  	  --encode-mode {conv,resid,mlp,tilt}
  	                        Type of encoder network (default: resid)
  	  --enc-mask ENC_MASK   Circular mask of image for encoder (default: D/2; -1
  	                        for no mask)
  	  --use-real            Use real space image for encoder (for convolutional
  	                        encoder)

  	Decoder Network:
  	  --dec-layers PLAYERS  Number of hidden layers (default: 3)
  	  --dec-dim PDIM        Number of nodes in hidden layers (default: 1024)
  	  --pe-type {geom_ft,geom_full,geom_lowf,geom_nohighf,linear_lowf,gaussian,none}
  	                        Type of positional encoding (default: gaussian)
  	  --feat-sigma FEAT_SIGMA
  	                        Scale for random Gaussian features
  	  --pe-dim PE_DIM       Num features in positional encoding (default: image D)
  	  --domain {hartley,fourier}
  	                        Decoder representation domain (default: fourier)
  	  --activation {relu,leaky_relu}
  	                        Activation (default: relu)

  </details>

  Many of the parameters of this script have sensible defaults. The required arguments are:

  * an input image stack (`.mrcs` or other listed file types)
  * `--poses`, image poses (`.pkl`) that correspond to the input images
  * `--ctf`, ctf parameters (`.pkl`), unless phase-flipped images are used
  * `--zdim`, the dimension of the latent variable
  * `-o`, a clean output directory for saving results

  Additional parameters which are typically set include:

  * `-n`, Number of epochs to train
  * `--uninvert-data`, Use if particles are dark on light (negative stain format)
  * Architecture parameters with `--enc-layers`, `--enc-dim`, `--dec-layers`, `--dec-dim`
  * `--multigpu` to enable parallelized training across multiple GPUs



  1) It is highly recommended to first train on lower resolution images (e.g. D=128) to sanity check results
  2) and perform any particle filtering.

  Example command to train a cryoDRGN model for 25 epochs on an image dataset `projections.128.mrcs`
  with poses `pose.pkl` and ctf parameters `ctf.pkl`:

      
      $ cryodrgn train_vae projections.128.mrcs \
              --poses pose.pkl \
              --ctf ctf.pkl \
              --zdim 8 -n 25 \
              -o 00_cryodrgn128

  2) After validation, pose optimization, and any necessary particle filtering,
  then train on the full resolution images (up to D=256):

  Example command to train a cryoDRGN model for 25 epochs on an image dataset `projections.256.mrcs`
  with poses `pose.pkl` and ctf parameters `ctf.pkl`:

      
      $ cryodrgn train_vae projections.256.mrcs \
              --poses pose.pkl \
              --ctf ctf.pkl \
              --zdim 8 -n 25 \
              -o 01_cryodrgn256

  The number of epochs `-n` refers to the number of full passes through the dataset for training, and should be modified
  depending on the number of particles in the dataset. For a 100k particle dataset on 1 V100 GPU,
  the above settings required ~12 min/epoch for D=128 images and ~47 min/epoch for D=256 images.

  If you would like to train longer, a training job can be extended with the `--load` argument.
  For example to extend the training of the previous example to 50 epochs:

      $ cryodrgn train_vae projections.256.mrcs \
              --poses pose.pkl \
              --ctf ctf.pkl \
              --zdim 8 -n 50 \
              -o 01_cryodrgn256 \
              --load 01_cryodrgn256/weights.24.pkl # 0-based indexing



  Use cryoDRGN's `--multigpu` flag to enable parallelized training across all detected GPUs on the machine.
  To select specific GPUs for cryoDRGN to run on, use the environmental variable `CUDA_VISIBLE_DEVICES`, e.g.:

      $ cryodrgn train_vae ... # Run on GPU 0
      $ cryodrgn train_vae ... --multigpu # Run on all GPUs on the machine
      $ CUDA_VISIBLE_DEVICES=0,3 cryodrgn train_vae ... --multigpu # Run on GPU 0,3

  We recommend using `--multigpu` for large images, e.g. D=256.
  Note that GPU computation may not be the training bottleneck for smaller images (D=128).
  In this case, `--multigpu` may not speed up training (while taking up additional compute resources).

  With `--multigpu`, the batch size is multiplied by the number of available GPUs to better utilize GPU resources.
  We note that GPU utilization may be further improved by increasing the batch size (e.g. `-b 16`), however,
  faster wall-clock time per epoch does not necessarily lead to faster *model training* since the training dynamics
  are affected (fewer model updates per epoch with larger `-b`),
  and using `--multigpu` may require increasing the total number of epochs.



  Depending on the quality of the consensus reconstruction, image poses may contain errors.
  Image poses may be *locally* refined using the `--do-pose-sgd` flag, however, we recommend reaching out to the
  developers for recommended training settings.



  Once the model has finished training, the output directory will contain a configuration file `config.yaml`,
  neural network weights `weights.pkl`, image poses (if performing pose sgd) `pose.pkl`,
  and the latent embeddings for each image `z.pkl`.
  The latent embeddings are provided in the same order as the input particles.
  To analyze these results, use the `cryodrgn analyze` command to visualize the latent space and generate structures.
  `cryodrgn analyze` will also provide a template jupyter notebook for further interactive visualization and analysis.




  <details><summary><code>$ cryodrgn analyze -h</code></summary>

  	usage: cryodrgn analyze [-h] [--device DEVICE] [-o OUTDIR] [--skip-vol]
  	                        [--skip-umap] [--Apix APIX] [--flip] [--invert]
  	                        [-d DOWNSAMPLE] [--pc PC] [--ksample KSAMPLE]
  	                        workdir epoch

  	Visualize latent space and generate volumes

  	positional arguments:
  	  workdir               Directory with cryoDRGN results
  	  epoch                 Epoch number N to analyze (0-based indexing,
  	                        corresponding to z.N.pkl, weights.N.pkl)

  	optional arguments:
  	  -h, --help            show this help message and exit
  	  --device DEVICE       Optionally specify CUDA device
  	  -o OUTDIR, --outdir OUTDIR
  	                        Output directory for analysis results (default:
  	                        [workdir]/analyze.[epoch])
  	  --skip-vol            Skip generation of volumes
  	  --skip-umap           Skip running UMAP

  	Extra arguments for volume generation:
  	  --Apix APIX           Pixel size to add to .mrc header (default: 1 A/pix)
  	  --flip                Flip handedness of output volumes
  	  --invert              Invert contrast of output volumes
  	  -d DOWNSAMPLE, --downsample DOWNSAMPLE
  	                        Downsample volumes to this box size (pixels)
  	  --pc PC               Number of principal component traversals to generate
  	                        (default: 2)
  	  --ksample KSAMPLE     Number of kmeans samples to generate (default: 20)

  </details>

  This script runs a series of standard analyses:

  * PCA visualization of the latent embeddings
  * UMAP visualization of the latent embeddings
  * Generation of volumes. See note [1].
  * Generation of trajectories along the first and second principal components of the latent embeddings
  * Generation of template jupyter notebooks that may be used for further interactive analyses, visualization, and volume generation

  Example usage to analyze results from the direction `01_cryodrgn256` containing results after 25 epochs of training:

      $ cryodrgn analyze 01_cryodrgn256 24 --Apix 1.31 # 24 for 0-based indexing of epoch numbers

  Notes:

  [1] Volumes are generated after k-means clustering of the latent embeddings with k=20 by default.
  Note that we use k-means clustering here not to identify clusters, but to segment the latent space and
  generate structures from different regions of the latent space.
  The number of structures that are generated may be increased with the option `--ksample`.

  [2] The `cryodrgn analyze` command chains together a series of calls to `cryodrgn eval_vol` and other scripts
  that can be run separately for more flexibility.
  These scripts are located in the `analysis_scripts` directory within the source code.

  [3] In particular, you may find it useful to perform filtering of particles separately from other analyses. This can
  done using our interactive interface available from the command line: `cryodrgn filter 01_cryodrgn256`.

  [4] `--Apix` only needs to be given if it is not present (or not accurate) in the CTF file that was used in training.




  A simple way of generating additional volumes is to increase the number of k-means samples in `cryodrgn analyze`
  by using the flag `--ksample 100` (for 100 structures).
  For additional flexibility, `cryodrgn eval_vol` may be called directly:

  <details><summary><code>$ cryodrgn eval_vol -h</code></summary>

  	usage: cryodrgn eval_vol [-h] -c PKL -o O [--prefix PREFIX] [-v]
  	                         [-z [Z [Z ...]]] [--z-start [Z_START [Z_START ...]]]
  	                         [--z-end [Z_END [Z_END ...]]] [-n N] [--zfile ZFILE]
  	                         [--Apix APIX] [--flip] [-d DOWNSAMPLE]
  	                         [--norm NORM NORM] [-D D] [--enc-layers QLAYERS]
  	                         [--enc-dim QDIM] [--zdim ZDIM]
  	                         [--encode-mode {conv,resid,mlp,tilt}]
  	                         [--dec-layers PLAYERS] [--dec-dim PDIM]
  	                         [--enc-mask ENC_MASK]
  	                         [--pe-type {geom_ft,geom_full,geom_lowf,geom_nohighf,linear_lowf,none}]
  	                         [--pe-dim PE_DIM] [--domain {hartley,fourier}]
  	                         [--l-extent L_EXTENT]
  	                         [--activation {relu,leaky_relu}]
  	                         weights

  	Evaluate the decoder at specified values of z

  	positional arguments:
  	  weights               Model weights

  	optional arguments:
  	  -h, --help             show this help message and exit
  	  -c YAML, --config YAML CryoDRGN config.yaml file
  	  -o O                   Output .mrc or directory
  	  --prefix PREFIX        Prefix when writing out multiple .mrc files (default: vol_)
  	  -v, --verbose          Increase verbosity

  	Specify z values:
  	  -z [Z [Z ...]]        Specify one z-value
  	  --z-start [Z_START [Z_START ...]]
  	                        Specify a starting z-value
  	  --z-end [Z_END [Z_END ...]]
  	                        Specify an ending z-value
  	  -n N                  Number of structures between [z_start, z_end]
  	  --zfile ZFILE         Text file with z-values to evaluate

  	Volume arguments:
  	  --Apix APIX           Pixel size to add to .mrc header (default: 1 A/pix)
  	  --flip                Flip handedness of output volume
  	  -d DOWNSAMPLE, --downsample DOWNSAMPLE
  	                        Downsample volumes to this box size (pixels)

  	Overwrite architecture hyperparameters in config.yaml:
  	  --norm NORM NORM
  	  -D D                  Box size
  	  --enc-layers QLAYERS  Number of hidden layers
  	  --enc-dim QDIM        Number of nodes in hidden layers
  	  --zdim ZDIM           Dimension of latent variable
  	  --encode-mode {conv,resid,mlp,tilt}
  	                        Type of encoder network
  	  --dec-layers PLAYERS  Number of hidden layers
  	  --dec-dim PDIM        Number of nodes in hidden layers
  	  --enc-mask ENC_MASK   Circular mask radius for image encoder
  	  --pe-type {geom_ft,geom_full,geom_lowf,geom_nohighf,linear_lowf,none}
  	                        Type of positional encoding
  	  --pe-dim PE_DIM       Num sinusoid features in positional encoding (default:
  	                        D/2)
  	  --domain {hartley,fourier}
  	  --l-extent L_EXTENT   Coordinate lattice size
  	  --activation {relu,leaky_relu}
  	                        Activation (default: relu)

  </details>

  **Example usage:**

  To generate a volume at a single value of the latent variable:

      $ cryodrgn eval_vol [YOUR_WORKDIR]/weights.pkl --config [YOUR_WORKDIR]/config.yaml -z ZVALUE -o reconstruct.mrc

  The number of inputs for `-z` must match the dimension of your latent variable.

  Or to generate a trajectory of structures from a defined start and ending point,
  use the `--z-start` and `--z-end` arugments:

      $ cryodrgn eval_vol [YOUR_WORKDIR]/weights.pkl --config [YOUR_WORKDIR]/config.yaml -o [WORKDIR]/trajectory \
                          --z-start -3 --z-end 3 -n 20

  This example generates 20 structures at evenly spaced values between z=[-3,3],
  assuming a 1-dimensional latent variable model.

  Finally, a series of structures can be generated using values of z given in a file specified by the arugment `--zfile`:

      $ cryodrgn eval_vol [WORKDIR]/weights.pkl --config [WORKDIR]/config.yaml --zfile zvalues.txt -o [WORKDIR]/trajectory

  The input to `--zfile` is expected to be an array of dimension (N_volumes x zdim), loaded with np.loadtxt.



  Two additional commands can be used in conjunction with `cryodrgn eval_vol` to generate trajectories:

      $ cryodrgn pc_traversal -h
      $ cryodrgn graph_traversal -h

  These scripts produce a text file of z values that can be input to `cryodrgn eval_vol` to generate a series of
  structures that can be visualized as a trajectory in ChimeraX (https://www.cgl.ucsf.edu/chimerax).

  Documentation: https://ez-lab.gitbook.io/cryodrgn/cryodrgn-graph-traversal-for-making-long-trajectories



  NEW in version 1.0: There are two additional tools `cryodrgn analyze_landscape` and `cryodrgn analyze_landscape_full`
  for more comprehensive and automated analyses of cryodrgn results.

  Documentation: https://ez-lab.gitbook.io/cryodrgn/cryodrgn-conformational-landscape-analysis



  To perform *ab initio* heterogeneous reconstruction, use `cryodrgn abinit_het`.
  The arguments are similar to `cryodrgn train_vae`, but the `--poses` argument is not required.

  For homogeneous reconstruction, use `cryodrgn abinit_homo`.

  Documentation: https://ez-lab.gitbook.io/cryodrgn/cryodrgn2-ab-initio-reconstruction



  Available in beta release starting in version 3.x. Documentation for getting started can be found
  in the [user guide](https://ez-lab.gitbook.io/cryodrgn/cryodrgn-et-subtomogram-analysis). Please reach out if you have any questions!



  For a complete description of the method, see:

  * CryoDRGN: reconstruction of heterogeneous cryo-EM structures using neural networks
  Ellen D. Zhong, Tristan Bepler, Bonnie Berger*, Joseph H Davis*
  Nature Methods 2021, https://doi.org/10.1038/s41592-020-01049-4 [pdf](https://ezlab.princeton.edu/assets/pdf/2021_cryodrgn_nature_methods.pdf)

  An earlier version of this work appeared at ICLR 2020:

  * Reconstructing continuous distributions of protein structure from cryo-EM images
  Ellen D. Zhong, Tristan Bepler, Joseph H. Davis*, Bonnie Berger*
  ICLR 2020, Spotlight, https://arxiv.org/abs/1909.05215

  CryoDRGN2's ab initio reconstruction algorithms were published at ICCV:

  * CryoDRGN2: Ab Initio Neural Reconstruction of 3D Protein Structures From Real Cryo-EM Images
  Ellen D. Zhong, Adam Lerer, Joseph H Davis, and Bonnie Berger
  International Conference on Computer Vision (ICCV) 2021, [paper](https://openaccess.thecvf.com/content/ICCV2021/papers/Zhong_CryoDRGN2_Ab_Initio_Neural_Reconstruction_of_3D_Protein_Structures_From_ICCV_2021_paper.pdf)

  A protocols paper that describes the analysis of the EMPIAR-10076 assembling ribosome dataset:

  * Uncovering structural ensembles from single particle cryo-EM data using cryoDRGN
  Laurel Kinman, Barrett Powell, Ellen D. Zhong*, Bonnie Berger*, Joseph H Davis*
  Nature Protocols 2023, https://doi.org/10.1038/s41596-022-00763-x

  Heterogeneous subtomogram averaging:

  * Deep reconstructing generative networks for visualizing dynamic biomolecules inside cells
  Rangan et al.
  bioRxiv 2023, https://www.biorxiv.org/content/10.1101/2023.08.18.553799v1



  Please submit any bug reports, feature requests, or general usage feedback as a github issue or discussion.


pkgId: b2c9cb3214b29a5afbc1b3fb2f5a5e3779606ac07ddfbfd861923cdbee49c899
name: python-cryoemservices
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: Services for CryoEM processing
url: https://pypi.org/project/cryoemservices/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryoemservices-0.5.4-1.src.rpm
checksum_type: sha256
description:
  Services and configuration for cryo-EM pipelines.

  This package consists of a number of services to process cryo-EM micrographs,
  both for single particle analysis and tomography,
  using a range of commonly used cryo-EM processing software.
  These services can be run independently to process data,
  or as part of a wider structure for performing live analysis during microscope collection.
  For live analysis, this package integrates with a package
  for transferring and monitoring collected data,
  [Murfey](https://github.com/DiamondLightSource/python-murfey),
  and a database for storing processing outcomes,
  [ISPyB](https://github.com/DiamondLightSource/ispyb-database).

  To run these services the software executables being called must be installed.
  These do not come with this package.



  The tomography processing pipeline consists of:

  - Motion correction
  - CTF estimation
  - Tomogram alignment
  - Tomogram denoising using [Topaz](http://topaz-em.readthedocs.io)
  - Segmentation using [membrain-seg](https://github.com/teamtomo/membrain-seg)

  The results of this processing can be opened and continued using
  [Relion 5.0](https://relion.readthedocs.io).



  The single particle analysis pipeline produces a project
  that can be opened and continued using
  [CCP-EM doppio](https://www.ccpem.ac.uk/docs/doppio/user_guide.html)
  or [Relion](https://relion.readthedocs.io).

  The processing pipeline consists of:

  - Motion correction
  - CTF estimation
  - Particle picking
  - (Optionally) Ice thickness estimation
  - Particle extraction and rebatching
  - 2D classification using Relion
  - Automated 2D class selection using Relion
  - 3D classification using Relion
  - 3D Refinement and post-processing
  - BFactor estimation by refinement with varying particle count



  The following services are provided for running the pipelines:

  - Utility services:
    - **ClusterSubmission**: Submits zocalo wrappers to an HPC cluster
    - **Dispatcher**: Converts recipes into messages suitable for processing services
    - **Images**: Creates thumbnail images for viewing processing outcomes
    - **ISPyB**: Inserts results into an ISPyB database
    - **NodeCreator**: Creates Relion project files for the services run
  - Processing services:
    - **BFactor**: Performs the setup for 3D refinement with varying particle count
    - **CrYOLO**: Particle picking on micrographs using [crYOLO](https://cryolo.readthedocs.io)
    - **CTFFind**: CTF estimation on micrographs using [CTFFIND4](https://grigoriefflab.umassmed.edu/ctffind4)
    - **DenoiseSlurm**: Tomogram denoising, submitted to a slurm HPC cluster, using [Topaz](http://topaz-em.readthedocs.io)
    - **Extract**: Extracts picked particles from micrographs
    - **ExtractClass**: Extracts particles from a given 3D class
    - **IceBreaker**: Ice thickness estimation with [IceBreaker](https://github.com/DiamondLightSource/python-icebreaker)
    - **MembrainSeg**: Tomogram segmentation, submitted to a slurm HPC cluster, using [membrain-seg](https://github.com/teamtomo/membrain-seg)
    - **MotionCorr**: Motion correction of micrographs using [MotionCor2](http://emcore.ucsf.edu/ucsf-software) or [Relion](https://relion.readthedocs.io), optionally submitted to a slurm HPC cluster
    - **PostProcess**: Post-processing of 3D refinements using [Relion](https://relion.readthedocs.io)
    - **SelectClasses**: Runs automated 2D class selection using [Relion](https://relion.readthedocs.io) and re-batches the particles from these classes
    - **SelectParticles**: Creates files listing batches of extracted particles
    - **TomoAlign**: Tomogram reconstruction from a list of micrographs using [imod](https://bio3d.colorado.edu/imod) and [AreTomo2](https://github.com/czimaginginstitute/AreTomo2)
    - **TomoAlignSlurm**: Tomogram alignment processing submitted to a slurm HPC cluster

  There are also three zocalo wrapper scripts that can be run on an HPC cluster.
  These perform 2D classification, 3D classification and 3D refinement
  using [Relion](https://relion.readthedocs.io).



  The services in this package are run using
  [zocalo](https://github.com/DiamondLightSource/python-zocalo)
  and [python-workflows](https://github.com/DiamondLightSource/python-workflows).
  To start a service run the `zocalo.service` command and specify the service name.
  For example, to start a motion correction service:

  ```bash
  $ zocalo.service -s MotionCorr
  ```

  Once started, these services will initialise and then wait for messages to be sent to them.
  Messages are sent through a message broker,
  currently [RabbitMQ](http://www.rabbitmq.com) is supported using pika transport in `python-workflows`.
  Individual processing stages can be run by sending a dictionary of the parameters,
  but the processing pipelines are designed to run through recipes.

  A recipe is a specication of a series of steps to carry out,
  and how these steps interact with each other.
  Recipes for the current processing pipelines are provided in the `recipes` folder.

  To run a recipe in python a dictionary needs to be provided consisting of
  the recipe name and the parameters expected by the recipe.
  The following snippet shows an example of the setup needed.
  This will send a message to a running **Dispatcher** service which
  prepares the recipe for the processing services.

  ```python
  import workflows.transport.pika_transport as pt

  example_message = {
      "recipes": ["em-tomo-align"],
      "parameters": {
          "path_pattern": "micrograph_*.mrc",
          "pix_size": "1",
          ...
      },
  }

  transport = pt.PikaTransport()
  transport.connect()
  transport.send("processing_recipe", example_message)
  ```

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


pkgId: 532f1e88194b094d0507d2265cc4ccdfeba45282f91ef8ebfd220562100ab8e7
name: python-cryoet-alignment
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Alignment format conversion for cryoET.
url: https://pypi.org/project/cryoet-alignment/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryoet-alignment-0.0.8-1.src.rpm
checksum_type: sha256
description:
  Convert between different alignment formats used in cryo-ET.

  Supported formats:
  - IMOD
  - AreTomo3
  - cryoet-data-portal



  `cryoet-alignment` can be installed using pip:

  ```bash
  pip install cryoet-alignment
  ```





  `cryoet-alignment` provides a simple API to read and write alignment files from different software packages.


  When processing tomography data using IMOD/etomo, files containing relevant alignment information are usually stored
  following the naming convention `basename.xf` (in-plane parameters), `basename.tlt` (tilt angles),
  `basename.xtilt` (x-rotation), `basename.mrc` (unaligned tilt series) and `basename_full_rec.mrc` (tomogram).

  This layout is assumed when reading and writing IMOD alignment files as shown below. Any present `tilt.com` and
  `newst.com` file in the same directory may also be read.

  ```python
  from cryoet_alignment import read
  from cryoet_alignment import write


  imod_alignment = read("/path/to/imod_dir/basename")


  write(imod_alignment, "/path/to/imod_dir/basename")
  ```


  When processing tomography data using AreTomo3, alignment information is stored in a single `.aln` file. This file can be
  read and written as shown below.

  ```python
  from cryoet_alignment import read
  from cryoet_alignment import write


  aretomo3_alignment = read("/path/to/alignment_file.aln")


  write(aretomo3_alignment, "/path/to/alignment_file.aln")
  ```


  Alignment information from the cryoet-data-portal is stored in a JSON file with a schema described here. This file can
  be read and written as shown below.

  ```python
  from cryoet_alignment import read
  from cryoet_alignment import write


  cryoet_data_portal_alignment = read("/path/to/alignment_file.json")


  write(cryoet_data_portal_alignment, "/path/to/alignment_file.json")
  ```



  `cryoet-alignment` provides the ability to convert between different alignment formats. For any conversion, the
  alignment object must be read first using the appropriate `read` function, and then converted to the cryoet-data-portal
  format before converting and writing to the desired format.


  ```python
  from cryoet_alignment import read, write
  from cryoet_alignment.io.cryoet_data_portal import Alignment


  imod_alignment = read("/path/to/imod_dir/basename")


  cdp_alignment = Alignment.from_imod(imod_alignment)


  tilt_series_dim = (4096, 4096, 41)
  write(cdp_alignment.to_aretomo(ts_size=tilt_series_dim), "/path/to/alignment_file.aln")
  ```



  It is also possible to convert directly from the cryoet-data-portal client to IMOD/AreTomo format. This is demonstrated
  below. This requires additional dependencies to be installed using the following command:

  ```bash
  pip install cryoet-alignment[cdp]
  ```

  To convert from the cryoet-data-portal to IMOD, the below code can be used. Briefly, given a tomogram ID, the snippet
  fetches the alignment information from the cryoet-data-portal, reads the tilt series metadata, and converts the alignment
  to IMOD format. The resulting alignment files are written to the specified directory with the portal's run name as
  the base name.

  ```python
  import cryoet_data_portal as cdp
  import zarr
  from cryoet_alignment.io.cryoet_data_portal import Alignment
  from cryoet_alignment import write



  TOMO_ID = 771


  client = cdp.Client()
  tomogram = cdp.Tomogram.get_by_id(client, TOMO_ID)


  cdp_ali = Alignment.from_s3(tomogram.alignment.s3_alignment_metadata)



  tilt_series = tomogram.run.tiltseries[0]
  pixel_size = tilt_series.pixel_spacing
  dim_z, dim_y, dim_x = zarr.open(tilt_series.s3_omezarr_dir)['0'].shape


  imod_ali = cdp_ali.to_imod(ts_size=(dim_x, dim_y, dim_z), ts_spacing=pixel_size)
  write(imod_ali, f"/tmp/test/{tomogram.run.name}")
  ```

rpm_license:
  MIT License  Copyright (c) 2024 Utz Ermel  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: 32ab3cc488bdb4f70d8ab9689238f223d667ce26316c07a4629c9618ce9944f1
name: python-cryoet-data-portal
arch: src
version: 4.0.0
epoch: 0
release: 1
url: https://pypi.org/project/cryoet-data-portal/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryoet-data-portal-4.0.0-1.src.rpm
checksum_type: sha256
summary:
  API Client to facilitate the use of the CryoET Portal. For more information about the API and the project visit https://github.com/chanzuckerberg/cryoet-data-portal/

description:
  The `cryoet_data_portal` package provides a python client to facilitate the use of the Cryo-Electron Tomography Portal. For more information about the API and the project visit the [chanzuckerberg/cryoet-data-portal GitHub repo](https://github.com/chanzuckerberg/cryoet-data-portal/).



  For more help, please file a issue on the repo, or contact us at <cryoetdataportal@chanzuckerberg.com>.

  If you believe you have found a security issue, we would appreciate notification. Please send email to <security@chanzuckerberg.com>.


pkgId: 9f7d22acf3b9bfe7177bc958e2a5c491fa7306391c0ae54b77ea857782667d54
name: python-cryogrid-pytools
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Tools to read in CryoGrid MATLAB data to Python, includes forcing, outputs, DEMs, etc.
url: https://github.com/lukegre/CryoGrid-pyTools
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryogrid-pytools-0.1.0-1.src.rpm
checksum_type: sha256
description:
  Tools to read in CryoGrid MATLAB data to Python, includes forcing, outputs, DEMs, etc.

  Feel free to use, modify, and distribute as you see fit.



  `pip install git+https://github.com/lukegre/CryoGrid-pyTools.git`



  A very basic example is below, but see `demo.ipynb` for more comprehensive examples.
  ```python
  import cryogrid_pytools as cgt

  cgt.read_OUT_regridded_FCI2_file(fname)
  ```


pkgId: 2ff2edc1e5257eca5a68a38fb12c1a01fb5d73d6084e4cc76e6ac01e6cbc58b4
name: python-cryogrid-pytools
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Tools to read in CryoGrid MATLAB data to Python, includes forcing, outputs, DEMs, etc.
url: https://github.com/lukegre/CryoGrid-pyTools
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryogrid-pytools-0.1.5-1.src.rpm
checksum_type: sha256
description:
  Tools to read in CryoGrid MATLAB data to Python, includes forcing, outputs, DEMs, etc.

  Feel free to use, modify, and distribute as you see fit.



  ```bash
  pip install cryogrid_pytools
  ```


  This package can read in
  - CryoGrid output (from `OUT_regridded_FCI2`)
  - simple MATLAB struct files (not `run_info.mat`)
  - ERA5 forcing
  - excel run configuration files (experimental)

  Basic examples are shown below for the first two items, but see `demo.ipynb` for more comprehensive examples.



  Currently, only output files from the calss `OUT_regridded_FCI2` are supported.
  However, the majority of files you'll use follow this format.
  ```python
  import cryogrid_pytools as cgt


  fname = "results_from_RUN_SIMPLE/<project_name>_<YYYYMMDD>.mat"


  dataset = cgt.read_OUT_regridded_FCI2_file(fname)
  ```



  If you're working with RUN_SPATIAL_SPINUP_CLUSTERING, you can read in multiple files at once. The data are returned as an `xarray.Dataset` with the dimensions: [`gridcell`, `depth`, `time`]
  ```python

  fname = "results_from_RUN_SPATIAL_SPINUP_CLUSTERING/project_name_*_*.mat"


  dataset = cgt.read_OUT_regridded_FCI2_clusters(fname, deepest_point=-5)
  ```


  <div style="border: 1px solid; border-radius: 5px; padding: 10px; margin: 10px 0; width: 97.5%; border-color: #0096C7; background-color: rgba(0, 150, 199, 0.1); "><b>TIP</b>: In <code>MATLAB</code>, You need to add the `CryoGrid/source` directory to the MATLAB path before the file can be loaded properly. </div>

  Note that `run_info.mat` cannot be read as it contains special classes that are not supported by `scipy.io.loadmat`.  To save parts of `run_info`, use the following code in MATLAB:

  ```matlab
  run_info_spatial = run_info.SPATIAL.STATVAR
  save "run_info_spatial.mat" run_info_spatial
  ```

  Then, in Python:

  ```python
  fname = 'path_to_file/run_spatial_statvar.mat'
  spatial = cgt.read_mat_struct_as_dataset(fname, index=['Y', 'X'])
  ```


pkgId: 061ae76341d4b43a6356c6452916b6847dad883e5316262b0d2cf5246a908adb
name: python-cryojax
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Cryo-EM image simulation and analysis powered by JAX
url: https://pypi.org/project/cryojax/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryojax-0.3.1-1.src.rpm
checksum_type: sha256
description:
  <h1 align='center'>cryoJAX</h1>

  ![Tests](https://github.com/mjo22/cryojax/actions/workflows/testing.yml/badge.svg)
  ![Lint](https://github.com/mjo22/cryojax/actions/workflows/ruff.yml/badge.svg)

  cryoJAX is a library that provides tools for simulating and analyzing cryo-electron microscopy (cryo-EM) images. It is built on [`jax`](https://jax.readthedocs.io/en/latest/).



  Specifically, cryoJAX aims to provide three things in the cryo-EM image-to-structure pipeline.

  1. *Physical modeling of image formation*
  2. *Statistical modeling of the distributions from which images are drawn*
  3. *Easy-to-use utilities for working with real data*

  With these tools, `cryojax` aims to appeal to two different communities. Experimentalists can use `cryojax` in order to push the boundaries of what they can extract from their data by interfacing with the `jax` scientific computing ecosystem. Additionally, method developers may use `cryojax` as a backend for an algorithmic research project, such as in cryo-EM structure determination. These two aims are possible because `cryojax` is written to be fully interoperable with anything else in the JAX ecosystem.

  Dig a little deeper and you'll find that `cryojax` aims to be a fully extensible modeling language for cryo-EM image formation. It implements a collection of abstract interfaces, which aim to be general enough to support any level of modeling complexity—from simple linear image formation to the most realistic physical models in the field. Best of all, these interfaces are all part of the public API. Users can create their own extensions to `cryojax`, tailored to their specific use-case!



  See the documentation at [https://mjo22.github.io/cryojax/](https://mjo22.github.io/cryojax/). It is a work-in-progress, so thank you for your patience!



  Installing `cryojax` is simple. To start, I recommend creating a new virtual environment. For example, you could do this with `conda`.

  ```bash
  conda create -n cryojax-env -c conda-forge python=3.11
  ```

  Note that `python>=3.10` is required. After creating a new environment, [install JAX](https://github.com/google/jax#installation) with either CPU or GPU support. Then, install `cryojax`. For the latest stable release, install using `pip`.

  ```bash
  python -m pip install cryojax
  ```

  To install the latest commit, you can build the repository directly.

  ```bash
  git clone https://github.com/mjo22/cryojax
  cd cryojax
  python -m pip install .
  ```

  The [`jax-finufft`](https://github.com/dfm/jax-finufft) package is an optional dependency used for non-uniform fast fourier transforms. These are included as an option for computing image projections of real-space voxel-based scattering potential representations. In this case, we recommend first following the `jax_finufft` installation instructions and then installing `cryojax`.



  The following is a basic workflow to simulate an image.

  First, instantiate the spatial potential energy distribution representation and its respective method for computing image projections.

  ```python
  import jax
  import jax.numpy as jnp
  import cryojax.simulator as cxs
  from cryojax.io import read_array_with_spacing_from_mrc


  filename = "example_scattering_potential.mrc"
  real_voxel_grid, voxel_size = read_array_with_spacing_from_mrc(filename)
  potential = cxs.FourierVoxelGridPotential.from_real_voxel_grid(real_voxel_grid, voxel_size)

  pose = cxs.EulerAnglePose(
      offset_x_in_angstroms=5.0,
      offset_y_in_angstroms=-3.0,
      view_phi=20.0,
      view_theta=80.0,
      view_psi=-10.0,
  )

  structural_ensemble = cxs.SingleStructureEnsemble(potential, pose)
  ```

  Here, the 3D scattering potential array is read from `filename` (see the documentation [here](https://mjo22.github.io/cryojax/examples/compute-potential/) for an example of how to generate the potential). Then, the abstraction of the scattering potential is then loaded in fourier-space into a `FourierVoxelGridPotential`, and subsequently the representation of a biological specimen is instantiated, which also includes a pose and conformational heterogeneity. Here, the `SingleStructureEnsemble` class takes a pose but has no heterogeneity.

  Next, build the *scattering theory*. The simplest `scattering_theory` is the `WeakPhaseScatteringTheory`. This represents the usual image formation pipeline in cryo-EM, which forms images by computing projections of the potential and convolving the result with a contrast transfer function.

  ```python
  from cryojax.image import operators as op


  potential_integrator = cxs.FourierSliceExtraction(interpolation_order=1)

  ctf = cxs.ContrastTransferFunction(
      defocus_in_angstroms=9800.0,
      astigmatism_in_angstroms=200.0,
      astigmatism_angle=10.0,
      amplitude_contrast_ratio=0.1
  )
  transfer_theory = cxs.ContrastTransferTheory(ctf, envelope=op.FourierGaussian(b_factor=5.0))

  scattering_theory = cxs.WeakPhaseScatteringTheory(structural_ensemble, potential_integrator, transfer_theory)
  ```

  The `ContrastTransferFunction` has parameters used in CTFFIND4, which take their default values if not
  explicitly configured here. Finally, we can instantiate the `imaging_pipeline`--the highest level of imaging abstraction in `cryojax`--and simulate an image. Here, we choose a `ContrastImagingPipeline`, which simulates image contrast from a linear scattering theory.

  ```python


  instrument_config = cxs.InstrumentConfig(shape=(320, 320), pixel_size=voxel_size, voltage_in_kilovolts=300.0)

  imaging_pipeline = cxs.ContrastImagingPipeline(instrument_config, scattering_theory)

  image_without_noise = imaging_pipeline.render(get_real=True)
  ```

  `cryojax` also defines a library of distributions from which to sample the data. These distributions define the stochastic model from which images are drawn. For example, instantiate an `IndependentGaussianFourierModes` distribution and either sample from it or compute its log-likelihood.

  ```python
  from cryojax.image import rfftn, operators as op
  from cryojax.inference import distributions as dist


  distribution = dist.IndependentGaussianFourierModes(
      imaging_pipeline, variance_function=op.Constant(1.0), is_signal_normalized=True
  )

  key = jax.random.PRNGKey(seed=0)
  image_with_noise = distribution.sample(key)

  observed = rfftn(...)  # for this example, read in observed data and take FFT
  log_likelihood = distribution.log_likelihood(observed)
  ```

  For more advanced image simulation examples and to understand the many features in this library, see the [documentation](https://mjo22.github.io/cryojax/).



  - `cryojax` has been greatly informed by the open-source cryo-EM softwares [`cisTEM`](https://github.com/timothygrant80/cisTEM) and [`BioEM`](https://github.com/bio-phys/BioEM).
  - `cryojax` relies heavily on and has taken great inspiration from [`equinox`](https://github.com/patrick-kidger/equinox/). We think that `equinox` has great design principles and highly recommend learning about it to fully make use of the power of `jax`.

rpm_license:
  GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999  Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  [This is the first released version of the Lesser GPL.  It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.]  Preamble  The licenses for most software are designed to take away your freedom to share and change it.  By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.  This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it.  You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below.  When we speak of free software, we are referring to freedom of use, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things.  To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights.  These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it.  For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you.  You must make sure that they, too, receive or can get the source code.  If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it.  And you must show them these terms so they know their rights.  We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library.  To protect each distributor, we want to make it very clear that there is no warranty for the free library.  Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others.  Finally, software patents pose a constant threat to the existence of any free program.  We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder.  Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license.  Most GNU software, including some libraries, is covered by the ordinary GNU General Public License.  This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License.  We use this license for certain libraries in order to permit linking those libraries into non-free programs.  When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library.  The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom.  The Lesser General Public License permits more lax criteria for linking other code with the library.  We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License.  It also provides other free software developers Less of an advantage over competing non-free programs.  These disadvantages are the reason we use the ordinary General Public License for many libraries.  However, the Lesser license provides advantages in certain special circumstances.  For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard.  To achieve this, non-free programs must be allowed to use the library.  A more frequent case is that a free library does the same job as widely used non-free libraries.  In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License.  In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software.  For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system.  Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library.  The precise terms and conditions for copying, distribution and modification follow.  Pay close attention to the difference between a "work based on the library" and a "work that uses the library".  The former contains code derived from the library, whereas the latter must be combined with the library in order to run.  GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION  0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you".  A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.  The "Library", below, refers to any such software library or work which has been distributed under these terms.  A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language.  (Hereinafter, translation is included without limitation in the term "modification".)  "Source code" for a work means the preferred form of the work for making modifications to it.  For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.  Activities other than copying, distribution and modification are not covered by this License; they are outside its scope.  The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it).  Whether that is true depends on what the Library does and what the program that uses the Library does.  1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.  You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.  2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:  a) The modified work must itself be a software library.  b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.  c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.  d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.  (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application.  Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)  These requirements apply to the modified work as a whole.  If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works.  But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.  Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.  In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.  3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library.  To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License.  (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.)  Do not make any other change in these notices.  Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.  This option is useful when you wish to copy part of the code of the Library into a program that is not a library.  4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.  If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.  5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library".  Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.  However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library".  The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.  When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library.  The threshold for this to be true is not precisely defined by law.  If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work.  (Executables containing this object code plus portions of the Library will still fall under Section 6.)  Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.  6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.  You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License.  You must supply a copy of this License.  If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License.  Also, you must do one of these things:  a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library.  (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)  b) Use a suitable shared library mechanism for linking with the Library.  A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with.  c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.  d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.  e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.  For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it.  However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.  It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system.  Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.  7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:  a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities.  This must be distributed under the terms of the Sections above.  b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.  8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License.  Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License.  However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.  9. You are not required to accept this License, since you have not signed it.  However, nothing else grants you permission to modify or distribute the Library or its derivative works.  These actions are prohibited by law if you do not accept this License.  Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.  10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.  11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all.  For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.  If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.  It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices.  Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.  This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.  12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded.  In such case, this License incorporates the limitation as if written in the body of this License.  13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation.  If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.  14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission.  For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this.  Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.  NO WARRANTY  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Libraries  If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change.  You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).  To apply these terms, attach the following notices to the library.  It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the library's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.  You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA  Also add information on how to contact you by electronic and paper mail.  You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary.  Here is a sample; alter the names:  Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker.  <signature of Ty Coon>, 1 April 1990 Ty Coon, President of Vice  That's all there is to it!


pkgId: e6e7de6e52f335515167e76387c312f577bc0408cc20605c1aaabb0fd6dedd21
name: python-cryoloBM
arch: src
version: 1.6.1
epoch: 0
release: 1
summary: crYOLO boxmanager tools and legacy version of cryolo boxmanager
url: https://pypi.org/project/cryoloBM/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryoloBM-1.6.1-1.src.rpm
checksum_type: sha256
description:
  The crYOLO boxmanger was written to produce annotation data for [crYOLO](http://sphire.mpg.de/wiki/doku.php?id=downloads:cryolo_1), as deep learning based particle picking procedure for cryo electro microscopy.


pkgId: 84c62a1da563dc92fc5010abdac6a2c9b693467642de94bc218d535975cd3ea7
name: python-crypt-tool
arch: src
version: 0.1.3
epoch: 0
release: 1
summary: A versatile and efficient cryptography library implemented in Python
url: https://pypi.org/project/crypt-tool/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-crypt-tool-0.1.3-1.src.rpm
checksum_type: sha256
description:
  `crypt_tool` 提供了一个简单的加密和数据转换工具集，包含以下组件：

  1. `LinearCongruentialGenerator`: 生成伪随机数，用于加密和字符串生成。
  2. `XorCipher`: 基于 XOR 的简单加密解密类。
  3. `BytesBitsConverter`: 将字节转换为位、位转换为字节的工具类。



  ```shell


  python examples/example.py


  python tests/tests.py --verbose
  ```



  ```python
  from crypt_tool import system_random, LCG

  rand = system_random()
  print("A random number:", rand)

  seed = b"a seed"
  rnd = LCG.from_seed(seed)
  print("Random number from seed:", rnd.generate_u8())
  print("Random string:", rnd.generate_random_string(20))
  ```



  ```python
  from crypt_tool import XorCipher

  cipher = XorCipher(b"password1")
  data = bytes([0, 255, 128, 64, 32, 16, 8, 4, 2, 1])
  encoded = cipher.encode(data)
  decoded = cipher.decode(encoded)
  assert data == decoded, "Decoded data does not match original"
  print("Encoding and decoding successful.")
  ```


  ```python
  from crypt_tool import BytesBitsConverter

  converter = BytesBitsConverter()
  bytes_data = bytes([0, 1, 2, 255])

  bits = [
      0, 0, 0, 0, 0, 0, 0, 0,  # 0
      0, 0, 0, 0, 0, 0, 0, 1,  # 1
      0, 0, 0, 0, 0, 0, 1, 0,  # 2
      1, 1, 1, 1, 1, 1, 1, 1,  # 255
  ]

  assert converter.bytes_to_bits(bytes_data) == bits
  assert bytes_data == converter.bits_to_bytes(bits)
  ```


pkgId: e27ba5286a12dae1df520f94be4e3f9fe955540015aa782f906935901ec3a78d
name: python-cryptic-game
arch: src
version: 0.5.4
epoch: 0
release: 1
summary: Microservice handler for cryptic-game
url: https://github.com/cryptic-game/python3-lib
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryptic-game-0.5.4-1.src.rpm
checksum_type: sha256
description:
  The library that is used for microservices of the backend for the Cryptic game that are written in Python.

  PyPI package: https://pypi.org/project/cryptic-game/



  ```bash
  $ pip3 install cryptic-game
  ```



  - Endpoint mapping
  - Automatic input validation
  - Database control with SQLAlchemy
  - Automatic error capturing with Sentry and a logger



  Checkout [example.py](https://github.com/cryptic-game/python3-lib/blob/master/example.py)
  for a quick example on how this library is used.



  Required are all modules in the `requirements.txt` (which will automatically be installed by pip).



  | Variable            | Functionality                                                  |
  |---------------------|----------------------------------------------------------------|
  | MODE                | Available: debug and production                                |
  | SERVER_HOST         | Hostname of the main server                                    |
  | SERVER_PORT         | Microservice communication port of the main server             |
  | DATA_LOCATION       | SQLite database file location                                  |
  | DBMS                | Database management system; Available: mysql and sqlite        |
  | SQLITE_FILE         | Name of the SQLite database file (only used if DBMS is sqlite) |
  | MYSQL_HOSTNAME      | Hostname of the MySQL server                                   |
  | MYSQL_PORT          | Port of the MySQL server                                       |
  | MYSQL_DATABASE      | Name of the MySQL database to use                              |
  | MYSQL_USERNAME      | MySQL username to use                                          |
  | MYSQL_PASSWORD      | The password of the MySQL user                                 |
  | PATH_LOGFILE        | Path where your log-files will be stored to                    |
  | DSN                 | "Data Source Name" of your Sentry instance                     |
  | RELEASE             | The release that will be reported to Sentry                    |




  Your microservice will be supported by the [game-server of cryptic](https://github.com/cryptic-game/server).



  Visit our [wiki](https://github.com/cryptic-game/python3-lib/wiki) for more information.


pkgId: cda6972c77366d30c5d2d22cc804cdf9aed3c787e95c1fb7da86dced4eddf96c
name: python-cryptidy
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: Python high level library for symmetric & asymmetric encryption
url: https://github.com/netinvent/cryptidy
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryptidy-1.2.3-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Percentage of issues still open](http://isitmaintained.com/badge/open/netinvent/cryptidy.svg)](http://isitmaintained.com/project/netinvent/Cryptidy "Percentage of issues still open")
  [![Maintainability](https://api.codeclimate.com/v1/badges/be5d6edea1288951dc07/maintainability)](https://codeclimate.com/github/netinvent/cryptidy/maintainability)
  [![codecov](https://codecov.io/gh/netinvent/cryptidy/branch/master/graph/badge.svg?token=E5D9oVnqj7)](https://codecov.io/gh/netinvent/cryptidy)
  [![linux-tests](https://github.com/netinvent/cryptidy/actions/workflows/linux.yaml/badge.svg)](https://github.com/netinvent/cryptidy/actions/workflows/linux.yaml)
  [![windows-tests](https://github.com/netinvent/cryptidy/actions/workflows/windows.yaml/badge.svg)](https://github.com/netinvent/cryptidy/actions/workflows/windows.yaml)
  [![GitHub Release](https://img.shields.io/github/release/netinvent/cryptidy.svg?label=Latest)](https://github.com/netinvent/cryptidy/releases/latest)

  This library has been written to make encryption / decryption of any python object as simple as possible, while keeping the encryption solution secure.
  It is based on pycryptodomex AES and RSA encrpytion implementations.

  It's main features are:
   - Encrypt any pickable Python object / variable / blob
   - Add an UTC timestamp to the encrypted message
   - Verify that decrypted messages timestamps aren't in the future or too old (for bad RTC clock diags)
   - Allow symmetric encryption (AES-EAX mode)
       - 128, 192 or 256 bits encryption
   - Allow asymmetric encryption (RSA encryption with SHA384 hash algorithm and above AES encryption)
       - 1024, 2048 or 4096 bits RSA encryption with AES-256 session encryption
   - Provide the encypted data as base64 string for maximum portability between platforms and encodings
   - Unload AES key from memory as soon as possible to help prevent memory attacks



  Current cryptidy tests are Python 3.7 and up.
  Nevertheless, cryptidy v1.2.3 still runs on Python 2.7+ ;)


  `pip install cryptidy`




  ```
  from cryptidy import symmetric_encryption

  key = symmetric_encryption.generate_key(32)  # 32 bytes == 256 bits

  some_python_objects = ['foo', 'bar'], 'some long string', 12
  encrypted = symmetric_encryption.encrypt_message(some_python_objects, key)
  timestamp, original_object = symmetric_encryption.decrypt_message(encrypted, key)
  ```



  ```
  from cryptidy import asymmetric_encryption

  priv_key, pub_key = asymmetric_encryption.generate_keys(2048)  # 2048 bits RSA key

  some_python_objects = ['foo', 'bar'], 'some long string', 12
  encrypted = asymmetric_encryption.encrypt_message(some_python_objects, pub_key)
  timestamp, original_object = asymmetric_encryption.decrypt_message(encrypted, priv_key)
  ```


pkgId: 162ff9f616647e08850e5ff002dc3003c877a1428dcdd863d9c2db97fd1634d3
name: python-cryptlex.lexactivator
arch: src
version: 3.30.0
epoch: 0
release: 1
summary: LexActivator API wrapper for Python
url: https://github.com/cryptlex/lexactivator-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-cryptlex.lexactivator-3.30.0-1.src.rpm
checksum_type: sha256
description:
  ![Publish cryptlex.lexactivator package](https://github.com/cryptlex/lexactivator-python/workflows/Publish%20cryptlex.lexactivator%20package/badge.svg)



  Cryptlex lets you license your software apps effortlessly. You can easily generate license keys using the REST API or Dashboard and validate the license keys in your software apps using LexActivator (Cryptlex client library).

  Additionally, you can offer trials, subscriptions, floating licenses and much more.

  **cryptlex.lexactivator** is a Python wrapper for LexActivator licensing library.



      pip install cryptlex.lexactivator

  Then you can include it in your code:

  	from cryptlex.lexactivator import LexActivator, LexStatusCodes, PermissionFlags, LexActivatorException



  Refer to following for documentation:

  https://docs.cryptlex.com/node-locked-licenses/using-lexactivator/using-lexactivator-with-python


