# packages

pkgId: 359b76974f570bec81511b483e57bab1de8dc376ad16fd917e2372d334b64763
name: python-polartoolkit-help
arch: noarch
version: 0.7.1
epoch: 0
release: 1
summary: Development documents and examples for polartoolkit
url: https://github.com/mdtanker/polartoolkit
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-polartoolkit-0.7.1-1.src.rpm
location_href: Packages/python-polartoolkit-help-0.7.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <img src="docs/logo_dark.png" alt="polartoolkit logo" width="200"/>
  </p>
  <h2 align="center">Helpful tools for polar researchers</h2>

  <p align="center">
  <a href="https://polartoolkit.readthedocs.io"><strong>Documentation Link</strong></a>
  </p>

  <!-- SPHINX-START-proj-desc -->

  **PolarToolkit** (formerly known as Antarctic-Plots) is a Python package to make polar (i.e. Antarctic, Arctic, Greenland) research more efficient, reproducible, and accessible.
  The software does this by providing:

  - convenient functions for downloading and pre-processing a wide range of commonly used polar datasets
  - tools for common geospatial tasks (i.e. changing data resolution, subsetting data by geographic regions)
  - code to easily create publication-quality maps, data profiles, and cross-sections
  - a means to interactively explore datasets

  <!-- SPHINX-END-proj-desc -->

  <!-- SPHINX-START-badges -->

  <p align="center">
  <a href="https://mybinder.org/v2/gh/mdtanker/polartoolkit-binder/main?urlpath=git-pull%3Frepo%3Dhttps%253A%252F%252Fgithub.com%252Fmdtanker%252Fpolartoolkit%26urlpath%3Dtree%252Fpolartoolkit%252Fdocs%252Ftutorial%26branch%3Dmain">
   <img src="https://mybinder.org/badge_logo.svg" alt="Binder link"></a>
   </p>

  <p align="center">
  <a href="https://pypi.python.org/pypi/polartoolkit"><img src="https://img.shields.io/pypi/v/polartoolkit?style=flat-square"
  alt="Latest version on PyPI"/></a>
  <a href="https://github.com/conda-forge/polartoolkit-feedstock"><img src="https://img.shields.io/conda/vn/conda-forge/polartoolkit.svg?style=flat-square"alt="Latest version on conda-forge"/></a>
  <a href="https://codecov.io/gh/mdtanker/polartoolkit"><img src="https://img.shields.io/codecov/c/github/mdtanker/polartoolkit/main.svg?style=flat-square" alt="Test coverage status"/></a>
  </p>

  <p align="center">
  <a href="https://pypi.org/project/polartoolkit/"><img src="https://img.shields.io/pypi/pyversions/polartoolkit?style=flat-square" alt="Compatible Python versions."/></a>
  <a href="https://zenodo.org/badge/latestdoi/475677039"><img src="https://zenodo.org/badge/475677039.svg?style=flat-square" alt="Zenodo DOI"/></a>
  <a href='https://readthedocs.org/projects/polartoolkit/'><img src='https://readthedocs.org/projects/polartoolkit/badge/?version=latest&style=flat-square' alt='Documentation Status' /></a>
   </p>

  <!-- SPHINX-END-badges -->

  ![](docs/cover_fig.png)



  <p align="center">
  🚨 **Ready for daily use but still changing.** 🚨
  </p>

  This means that we are still adding a lot of new features and sometimes we make changes to the ones we already have while we try to improve the software based on users' experience, test new ideas, make better design decisions, etc.
  Some of these changes could be **backwards incompatible**.
  Keep that in mind before you update PolarToolkit to a new major version (i.e. from `v1.0.0` to `v2.0.0`) and always check the [Changelog](https://github.com/mdtanker/polartoolkit/blob/main/CHANGELOG.md) for `BREAKING CHANGES` and how to update your code appropriately.

  I welcome any feedback, ideas, or contributions!
  Please contact us on the [GitHub discussions page](https://github.com/mdtanker/polartoolkit/discussions) or submit an [issue on GitHub](https://github.com/mdtanker/polartoolkit/issues) for problems or feature ideas.

  <!-- SPHINX-START-long-desc -->

  The **PolarToolkit** python package provides some basic tools to help in conducting polar research.
  You can use it to download common datasets (i.e. BedMachine, Bedmap2, MODIS Mosaics), create maps and plots specific to Antarctica, Greenland and the Arctic and visualize data with multiple methods.

  Feel free to use, share, modify, and [contribute](https://polartoolkit.readthedocs.io/en/latest/contributing.html) to this project.



  - download commonly used datasets related to Antarctica, Greenland and the Arctic
  - making publication-quality maps and cross-sections
  - interactively explore data and define geographic regions
  - plotting and working with data in projected coordinates (meters) in either EPSG 3031 or 3413, for the South and North hemispheres, respectively
  - mostly focused on regularly gridded (interpolated) datasets, with some support for discrete (un-gridded) data
  - current focus for datasets is related to ice, geophysics, and earth properties since this is where my personal research interests are, but please request or add your own types of data!
  - basic geospatial manipulations (filtering, resampling, reprojecting, masking etc.)



  - downloading niche datasets or those that only cover specific regions
  - downloaded datasets outside of Antarctica, Greenland and the Arctic
  - plotting and working with data in geographic (latitude and longitude) coordinates
  - plots not related to geospatial data
  - a point-and-click GUI for plotting or data exploration -> see
    [Quantarctica](https://www.npolar.no/quantarctica/) or
    [QGreenland](https://qgreenland.org/)
  - complex geospatial processing -> see
    [PyGMT](https://www.pygmt.org/dev/index.html),
    [Verde](https://www.fatiando.org/verde/dev/index.html),
    [Geopandas](https://geopandas.org/en/stable/) or
    [Rasterio](https://rasterio.readthedocs.io/en/stable/)

  <!-- SPHINX-END-long-desc -->


  I welcome all forms of contribution! If you have any questions, comments or suggestions, please open a [discussion](https://github.com/mdtanker/polartoolkit/discussions/new/choose) or [issue (feature request)](https://github.com/mdtanker/polartoolkit/issues/new/choose)!

  Also, please feel free to share how you're using PolarToolkit, I'd love to know.

  Please, read our [Contributor Guide](https://polartoolkit.readthedocs.io/en/latest/contributing.html) to learn how you can contribute to the project.

rpm_license:
  The MIT License (MIT)  Copyright (c) 2022 Matt Tankersley  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: dda128d131e356e87f85e78d6035968f294882740cdc682534599b97550a141a
name: python-policyengine-core-help
arch: noarch
version: 3.16.0
epoch: 0
release: 1
summary: Development documents and examples for policyengine-core
url: https://github.com/policyengine/policyengine-core
rpm_license: https://www.fsf.org/licensing/licenses/agpl-3.0.html
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-policyengine-core-3.16.0-1.src.rpm
location_href: Packages/python-policyengine-core-help-3.16.0-1.noarch.rpm
checksum_type: sha256
description:
  [![codecov](https://codecov.io/gh/PolicyEngine/policyengine-core/branch/master/graph/badge.svg?token=BLoCjCf5Qr)](https://codecov.io/gh/PolicyEngine/policyengine-core)
  [![PyPI version](https://badge.fury.io/py/policyengine-core.svg)](https://badge.fury.io/py/policyengine-core)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

  This package, a fork of [OpenFisca-Core](https://github.com/OpenFisca/OpenFisca-Core), powers PolicyEngine country models and apps.



  Python 3.10 or beyond is required.





  ```
  https://github.com/PolicyEngine/policyengine-core/fork
  ```





  ```
  make install
  ```

  If you are using Windows (not recommended), please install `make` first.
  You can either directly download from [Make for Windows](https://gnuwin32.sourceforge.net/packages/make.htm);
  or install [Chocolatey](https://chocolatey.org/install), and simply install `make` with

  ```
  choco install make
  ```

  (See **Acknowledgements** for credit)





  All of our code changes are made against a GitHub issue. If you're new to the project, go to **Issues** and search for good first issues `label: "good first issue"`. If you see an open issue that no one's opened a PR against, it's all yours! Feel free to make some edits, then open a PR, as described below.



  Keep your fork's `master` branch in sync with the original repo by pulling the original repo's code at times; typically (if the original repo is called "upstream" by Git) this means running `git pull upstream master`, then `git push origin master` to sync the code to your local repo.

  Create branches on your fork off of your master or main branch. Periodically, if you're working on something for a while, you might also run `git rebase master` within your feature branch to sync your code with any new changes.



  You've finished your contribution, but now what? Before opening a PR, we ask contributors to do three things.



  To test your changes against our series of automated tests, run

  ```
  make test
  ```

  We also ask that you add tests for any new features or bug-fixes you add, so we can gradually build up the code coverage. Our tests are written in the Python standard, [Pytest](https://docs.pytest.org/en/7.1.x/getting-started.html), and will be run again against the production environment, as well.



  In addition to the tests, we use [Black](https://github.com/psf/black) to lint our codebase, so before opening a pull request, Step 2 is to lint the code by running

  ```
  make format
  ```

  This will automatically format the code for you; no need to do anything else.



  Finally, we ask contributors to make it clear for our users what changes have been made by contributing to a changelog. This changelog is formatted in YAML and describes the changes you've made to the code. This should follow the below format:

  ```
  - bump: {major, minor, patch}
    changes:
      {added, removed, changed, fixed}:
        - <variable or program>
  ```

  For more info on the syntax, check out the [semantic versioning docs](https://www.semver.org) and [keep a changelog](https://www.keepachangelog.com).

  Write your changelog info into the empty file called `changelog_entry.yaml`. When you open your PR, this will automatically be added to the overall changelog.



  Now you've finished your contribution! Please open a pull request (PR) from your branch to the live `master` branch and request review. At times, it may take some time for the team to review your PR, especially for larger contributions, so please be patient--we will be sure to get to it.

  In the first line of your PR, please make sure to include the following:

  ```
  Fixes {issue_number}
  ```

  This makes it much easier for us to maintain and prune our issue board.

  Please try to be detailed in your PRs about the changes you made and why you made them. You may find yourself looking back at them for reference in the future, or needing insight about someone else's changes. Save yourself a conversation and write it all in the PR!

  Here are some [best practices](https://deepsource.io/blog/git-best-practices/) for using Git.

  When you're ready for review, switch the PR from `Draft` to `Ready for review`.



  Distributed under the AGPL License. See `LICENSE` for more info.



  - Thanks to Othneil Drew for his [README template](https://github.com/othneildrew/Best-README-Template).
  - [Installing make on Windows](https://stackoverflow.com/questions/32127524/how-to-install-and-use-make-in-windows)


pkgId: 6655df8c4801c13c24a4eca8990040ad0b753d589b66894f153dc749aa03605e
name: python-policyengine-help
arch: noarch
version: 2.3.0
epoch: 0
release: 1
summary: Development documents and examples for policyengine
url: https://pypi.org/project/policyengine/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-policyengine-2.3.0-1.src.rpm
location_href: Packages/python-policyengine-help-2.3.0-1.noarch.rpm
checksum_type: sha256
description:
  PolicyEngine's main user-facing Python package, incorporating country packages and integrating data visualization and analytics. Read the documentation [here](https://policyengine.github.io/policyengine/policyengine.py).

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


pkgId: da87bd17fbf3e87ec1ef4c8c05051f83fbf1aef4ac51a10ff8e1d2d6a162aaf0
name: python-pollux-application-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for pollux-application
url: https://tno.nl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pollux-application-0.1.3-1.src.rpm
location_href: Packages/python-pollux-application-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Test workflow status](https://github.com/POLLUX-Digital-Twin/pollux-application/actions/workflows/python_test.yaml/badge.svg)](https://github.com/POLLUX-Digital-Twin/pollux-application/actions/workflows/python_test.yaml)
  [![Lint workflow status](https://github.com/POLLUX-Digital-Twin/pollux-application/actions/workflows/python_lint.yaml/badge.svg)](https://github.com/POLLUX-Digital-Twin/pollux-application/actions/workflows/python_lint.yaml)




  Application repository of the POLLUX Digital Twin




  If you think you found a bug, feel free to open an [issue](https://github.com/POLLUX-Digital-Twin/pollux-application/issues).
  Focused suggestions and requests can also be opened as issues. Before opening a pull request, please start an issue or a discussion on the topic.



  If you want to contribute to the package, please read our [CONTRIBUTING.md](https://github.com/POLLUX-Digital-Twin/pollux-application/blob/main/CONTRIBUTING.md) file.



  This content is released under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.html) License.



  Organization: TNO


pkgId: c042d72977a81a52312441afa1b942379ab01ad2dbc2fbee28458d339d8680d9
name: python-pollux-model-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for pollux-model
url: https://tno.nl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pollux-model-0.1.7-1.src.rpm
location_href: Packages/python-pollux-model-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  [![Test workflow status](https://github.com/pollux-Digital-Twin/pollux-model/actions/workflows/python_test.yaml/badge.svg?branch=main)](https://github.com/pollux-Digital-Twin/pollux-model/actions/workflows/python_test.yaml?query=branch%3Amain)
  [![Lint workflow status](https://github.com/pollux-Digital-Twin/pollux-model/actions/workflows/python_lint.yaml/badge.svg?branch=main)](https://github.com/pollux-Digital-Twin/pollux-model/actions/workflows/python_lint.yaml?query=branch%3Amain)





  This repository is part of the 'POLLUX Digital Twin' project.

  Model library of the POLLUX Digital Twin




  If you think you found a bug, feel free to open an [issue](https://github.com/pollux-digital-twin/pollux-model/issues).
  Focused suggestions and requests can also be opened as issues. Before opening a pull request, please start an issue or a discussion on the topic.



  If you want to contribute to the package, please read our [CONTRIBUTING.md](https://github.com/pollux-digital-twin/pollux-model/blob/main/CONTRIBUTING.md) file.



  This content is released under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.html) License.



  Organization: TNO


pkgId: 560eaf77c6290d1039601dedd00b70a968b1676eb2ee02e4599a2347cfcb6fab
name: python-poly-hammer-utils-help
arch: noarch
version: 0.0.5
epoch: 0
release: 1
summary: Development documents and examples for poly-hammer-utils
url: https://pypi.org/project/poly-hammer-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-poly-hammer-utils-0.0.5-1.src.rpm
location_href: Packages/python-poly-hammer-utils-help-0.0.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Publish](https://github.com/poly-hammer/poly-hammer-utils/actions/workflows/publish.yaml/badge.svg)](https://github.com/poly-hammer/poly-hammer-utils/actions/workflows/publish.yaml)
  ![PyPI - Version](https://img.shields.io/pypi/v/poly-hammer-utils)



  A general purpose package that holds our dev utilities.


pkgId: 952edd36514c40177b2f023650f8c9f425da5126bd94990a2d4d95d82288a204
name: python-polyapi-help
arch: noarch
version: 5.7.0.17
epoch: 0
release: 1
summary: Development documents and examples for polyapi
url: https://www.polymatica.ru
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-polyapi-5.7.0.17-1.src.rpm
location_href: Packages/python-polyapi-help-5.7.0.17-1.noarch.rpm
checksum_type: sha256
description:
  Библиотека предназначенна для работы с Polymatica API.

  Основным модулем бизнес-логики является файл business_scenarios.py, импортировать который можно с помощью команды ``from polymatica import business_scenarios as sc``.

  Модуль предоставляет два класса для работы с Полиматикой - ``BusinessLogic`` и ``GetDataChunk``. Методы этих классов можно посмотреть при помощи стандартной функции ``dir()``.

  Аргументы функций и прочую docstring-документацию модуля и функций можно посмотреть при помощи стандартной функции ``help()``.

  Инициализация нового клиентского подключения: ``client = sc.BusinessLogic(login="your_login", password="your_password", url="polymatica_server_url", **args)``


  как залить на pypi:
  1. python3 -m pip install --upgrade twine
  2. python3 -m pip install --upgrade build
  3. python3 -m build
  4. python3 -m twine upload dist/*
  5. ввести api token


pkgId: 0be855d9f627752d7c4d67d221c62d2cf120b95740259d05a1e6c36c40dbe1b3
name: python-polyapi-python-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for polyapi-python
url: https://github.com/polyapi/polyapi-python
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-polyapi-python-0.3.1-1.src.rpm
location_href: Packages/python-polyapi-python-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  The PolyAPI Python Library lets you use and define PolyAPI functions using Python.





  First install the client.

  We recommend the use of venv so you can have multiple projects each with separate credentials:

  ```bash
  python -m venv myvenv
  source myvenv/bin/activate
  pip install polyapi-python
  ```

  Replace `myvenv` with whatever you'd like your venv to be named!

  For more on Python virtual environments, we recommend this [venv primer](https://realpython.com/python-virtual-environments-a-primer/).

  However, if you only need to use polyapi with a single project, you can do a basic install:

  ```bash
  pip install polyapi-python
  ```



  Now you can run the following to generate your library

  ```bash
  python -m polyapi generate
  ```

  You will be prompted to enter the Poly server url you use and your Poly API key.

  You can also provide the key and url as environment variables (useful for deployment):

  ```
  POLY_API_KEY='your_key'
  POLY_API_BASE_URL='your_server'  # e.g. na1.polyapi.io
  ```



  That's it! Now open up a test file and you can run some code like so:

  ```python
  from polyapi import poly
  print(poly.polyapi.function.api.list(my_server, my_api_key))
  ```




  To add a new server function, please follow the quickstart. Then you can add a server function like so:

  ```bash
  python -m polyapi --context mycontext --description mydesc --server function add <function_name> foo.py
  ```

  The code in `foo.py` should contain a single defined function named the same as your `<function_name>` variable.

  So for example, if you want to add a function named `bar`, your file `foo.py` would look like this:

  ```python
  def bar():
      return "Hello World"
  ```



  In order to see function logs, please first set `logsEnabled` to `true` in Canopy for the function.

  https://na1.polyapi.io/canopy/polyui/collections/server-functions

  Then in your code, get the poly logger and log with it like so:

  ```python
  logger = logging.getLogger("poly")
  def bar():
      logger.warning("I AM THE LOG")
      return "Hello World"
  ```

  Finally, click the "Show Logs" button to see your server function logs in Canopy!




  You can define arbitrarily complex argument and return types using TypedDicts.

  NOTE: you must use `TypedDict` from `typing_extensions`, not from the base `typing` module.

  ```python
  from typing_extensions import TypedDict


  class Foobar(TypedDict):
      count: int


  def bar(n: int) -> Foobar:
      return Foobar(count=n)
  ```



  This library is hosted on Pypi. You can find the latest version on the [pypi polyapi-python](https://pypi.org/project/polyapi-python/) project.




  To upgrade your library to the latest version, pass the upgrade flag.

  ```bash
  pip install polyapi-python --upgrade
  ```



  To upgrade your library to the latest dev version, pass the `--pre` flag.

  ```bash
  pip install polyapi-python --pre --upgrade
  ```



  If you need to change your API key or what server you are pointing to, you can run:

  ```bash
  python -m polyapi setup
  ```



  To run this library's unit tests, please clone the repo then run:

  ```bash
  python -m unittest discover
  ```



  If you run into any issues or want help getting started with this project, please contact support@polyapi.io

rpm_license:
  MIT License  Copyright (c) 2023 PolyAPI Inc.  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: 23a4406859a802008404677af5bdc18c027fcc188a38ad43d2a401140366000a
name: python-pomcorn-help
arch: noarch
version: 0.8.2
epoch: 0
release: 1
summary: Development documents and examples for pomcorn
url: https://pypi.org/project/pomcorn/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pomcorn-0.8.2-1.src.rpm
location_href: Packages/python-pomcorn-help-0.8.2-1.noarch.rpm
checksum_type: sha256
description:
  ![GitHub Workflow Status (with event)](https://img.shields.io/github/actions/workflow/status/saritasa-nest/pomcorn/pre-commit.yml) ![PyPI](https://img.shields.io/pypi/v/pomcorn) ![PyPI - Status](https://img.shields.io/pypi/status/pomcorn) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pomcorn) ![PyPI - License](https://img.shields.io/pypi/l/pomcorn) ![PyPI - Downloads](https://img.shields.io/pypi/dm/pomcorn) [![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://pycqa.github.io/isort/)

  **Pomcorn**, or **Page Object Model corn**, is a Python package that contains base classes to create systems based on [Selenium](https://github.com/SeleniumHQ/selenium#selenium) framework and **Page Object Model** pattern. You can read more about this pattern [here](https://www.selenium.dev/documentation/test_practices/encouraged/page_object_models/). The package can be used to create autotesting systems, parsing scripts and anything that requires
  interaction with the browser.

  The package includes next base classes to create Page Object Model (``POM``) pages:

  ```mermaid
    classDiagram
      WebView <|-- Component
      WebView <|-- Page
      Component <|-- ListComponent
      Component .. Locator
      Page .. Component

      class WebView{
          -webdriver: Webdriver
      }
      class Page{
          +wait_until_loaded()
          +open()
      }
      class Component{
          -page: Page
          -base_locator: Locator
          + wait_until_visible()
      }
      class ListComponent{
          -item_locator: Locator
          +count()
          +all()
          +get_item_by_text()
      }
      class Locator{
        -query: String
      }

  ```

  It also includes [classes to locate elements](https://pomcorn.readthedocs.io/en/latest/locators.html) on the web page and a number of additional [waiting conditions](https://pomcorn.readthedocs.io/en/latest/waits_conditions.html>).



  You can install it by **pip**:

  ```bash
    pip install pomcorn
  ```

  Or **poetry**:

  ```bash
    poetry add pomcorn
  ```



  Link to the documentation: [http://pomcorn.rtfd.io/](http://pomcorn.rtfd.io/).



  You need to [install pomcorn](https://pomcorn.readthedocs.io/en/latest/installation.html) and [Chrome webdriver](https://pomcorn.readthedocs.io/en/latest/installation.html#chrome-driver).

  Below is the code that opens ``PyPI.org``, searches for packages by name and prints names of found packages to the terminal. The script contains all base classes contained in ``pomcorn``: **Page**, **Component**, **ListComponent** and **Element**.

  ```python

    from typing import Self

    from selenium.webdriver import Chrome
    from selenium.webdriver.common.keys import Keys
    from selenium.webdriver.remote.webdriver import WebDriver

    from pomcorn import Component, Element, ListComponent, Page, locators


    
    class PyPIPage(Page):

        APP_ROOT = "https://pypi.org"

        search = Element(locators.IdLocator("search"))

        def check_page_is_loaded(self) -> bool:
            return self.init_element(locators.TagNameLocator("main")).is_displayed


    
    Package = Component[PyPIPage]


    class PackageList(ListComponent[Package, PyPIPage]):

        relative_item_locator = locators.ClassLocator("snippet__name")

        @property
        def names(self) -> list[str]:
            return [package.body.get_text() for package in self.all]


    
    class SearchPage(PyPIPage):

        @classmethod
        def open(cls, webdriver: WebDriver, **kwargs) -> Self:
            pypi_page = super().open(webdriver, **kwargs)
            
            pypi_page.search.fill("")
            pypi_page.search.send_keys(Keys.ENTER)
            return cls(webdriver, **kwargs)

        @property
        def results(self) -> PackageList:
            return PackageList(
                page=self,
                base_locator=locators.PropertyLocator(
                    prop="aria-label",
                    value="Search results",
                ),
            )

        def find(self, query: str) -> PackageList:
            self.search.fill(query)
            self.search.send_keys(Keys.ENTER)
            return self.results


    search_page = SearchPage.open(webdriver=Chrome())
    print(search_page.find("saritasa").names)
    search_page.webdriver.close()
  ```

  For more information about package classes, you can read in [Object Hierarchy](https://pomcorn.readthedocs.io/en/latest/objects_hierarchy.html) and [Developer Interface](https://pomcorn.readthedocs.io/en/latest/developer_interface.html).

  Also you can try our [demo autotests project](https://pomcorn.readthedocs.io/en/latest/demo.html).


pkgId: af17cf1bca348f62af6d1f7ef64ac491e15ae7c85050c77a6ab628a4f10f1c4f
name: python-pome7o-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for pome7o
url: https://pypi.org/project/pome7o/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pome7o-0.2.0-1.src.rpm
location_href: Packages/python-pome7o-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  OmAgent Core is an integral component of the OmAgent project, encompassing the foundational framework for constructing OmAgent. It features a workflow system configurable via configuration files and a recursive general task-solving mechanism, referred to as the DnC Loop, among other elements. This core framework empowers you to create the intelligent agent of your design.



  ```bash
  pip install for_test
  ```


  **[OmAgent: A Multi-modal Agent Framework for Complex Video Understanding](https://github.com/om-ai-lab/OmAgent)**


pkgId: eec778c89b89c95c087352a508f3d872f86491972057eedb1ce2c05da09a3074
name: python-pontos-help
arch: noarch
version: 24.12.2
epoch: 0
release: 1
summary: Development documents and examples for pontos
url: https://github.com/greenbone/pontos/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pontos-24.12.2-1.src.rpm
location_href: Packages/python-pontos-help-24.12.2-1.noarch.rpm
checksum_type: sha256
description:
  ![Greenbone Logo](https://www.greenbone.net/wp-content/uploads/gb_new-logo_horizontal_rgb_small.png)



  [![GitHub releases](https://img.shields.io/github/release/greenbone/pontos.svg)](https://github.com/greenbone/pontos/releases)
  [![PyPI release](https://img.shields.io/pypi/v/pontos.svg)](https://pypi.org/project/pontos/)
  [![code test coverage](https://codecov.io/gh/greenbone/pontos/branch/main/graph/badge.svg)](https://codecov.io/gh/greenbone/pontos)
  [![Build and test](https://github.com/greenbone/pontos/actions/workflows/ci-python.yml/badge.svg)](https://github.com/greenbone/pontos/actions/workflows/ci-python.yml)

  The **pontos** Python package is a collection of utilities, tools, classes and
  functions maintained by [Greenbone].

  Pontos is the German name of the Greek titan [Pontus](https://en.wikipedia.org/wiki/Pontus_(mythology)),
  the titan of the sea.



  - [Documentation](#documentation)
  - [Installation](#installation)
    - [Requirements](#requirements)
    - [Install using pipx](#install-using-pipx)
    - [Install using pip](#install-using-pip)
    - [Install using poetry](#install-using-poetry)
  - [Command Completion](#command-completion)
    - [Setup for bash](#setup-for-bash)
    - [Setup for zsh](#setup-for-zsh)
  - [Development](#development)
  - [Maintainer](#maintainer)
  - [Contributing](#contributing)
  - [License](#license)



  The documentation for pontos can be found at https://greenbone.github.io/pontos/. Please refer to the documentation for more details as this README just gives a short overview.





  Python 3.9 and later is supported.



  You can install the latest stable release of **pontos** from the Python
  Package Index (pypi) using [pipx]

      python3 -m pipx install pontos



  > [!NOTE]
  > The `pip install` command does no longer work out-of-the-box in newer
  > distributions like Ubuntu 23.04 because of [PEP 668](https://peps.python.org/pep-0668).
  > Please use the [installation via pipx](#install-using-pipx) instead.

  You can install the latest stable release of **pontos** from the Python
  Package Index (pypi) using [pip]

      python3 -m pip install --user pontos



  Because **pontos** is a Python library you most likely need a tool to
  handle Python package dependencies and Python environments. Therefore we
  strongly recommend using [poetry].

  You can install the latest stable release of **pontos** and add it as
  a dependency for your current project using [poetry]

      poetry add pontos



  `pontos` comes with support for command line completion in bash and zsh. All
  pontos CLI commands support shell completion. As examples the following sections
  explain how to set up the completion for `pontos-release` with bash and zsh.



  ```bash
  echo "source ~/.pontos-release-complete.bash" >> ~/.bashrc
  pontos-release --print-completion bash > ~/.pontos-release-complete.bash
  ```

  Alternatively, you can use the result of the completion command directly with
  the eval function of your bash shell:

  ```bash
  eval "$(pontos-release --print-completion bash)"
  ```



  ```zsh
  echo 'fpath=("$HOME/.zsh.d" $fpath)' >> ~/.zsh
  mkdir -p ~/.zsh.d/
  pontos-release --print-completion zsh > ~/.zsh.d/_pontos_release
  ```

  Alternatively, you can use the result of the completion command directly with
  the eval function of your zsh shell:

  ```bash
  eval "$(pontos-release --print-completion zsh)"
  ```




  **pontos** uses [poetry] for its own dependency management and build
  process.

  First install poetry via [pipx]

      python3 -m pipx install poetry

  Afterwards run

      poetry install

  in the checkout directory of **pontos** (the directory containing the
  `pyproject.toml` file) to install all dependencies including the packages only
  required for development.

  Afterwards activate the git hooks for auto-formatting and linting via
  [autohooks].

      poetry run autohooks activate

  Validate the activated git hooks by running

      poetry run autohooks check



  This project is maintained by [Greenbone AG][Greenbone]



  Your contributions are highly appreciated. Please
  [create a pull request](https://github.com/greenbone/pontos/pulls)
  on GitHub. Bigger changes need to be discussed with the development team via the
  [issues section at GitHub](https://github.com/greenbone/pontos/issues)
  first.



  Copyright (C) 2020-2024 [Greenbone AG][Greenbone]

  Licensed under the [GNU General Public License v3.0 or later](LICENSE).

  [Greenbone]: https://www.greenbone.net/
  [poetry]: https://python-poetry.org/
  [pip]: https://pip.pypa.io/
  [pipx]: https://pypa.github.io/pipx/
  [autohooks]: https://github.com/greenbone/autohooks


pkgId: 1c45bf97e399d75fef826e4e0aaad89774edb0e37c89694b0f0c688b00e99259
name: python-popidd-io-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for popidd-io
url: https://pypi.org/project/popidd-io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-popidd-io-0.0.2-1.src.rpm
location_href: Packages/python-popidd-io-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This [napari] plugin was generated with [copier] using the [napari-plugin-template].
  <!--
  Don't miss the full getting started guide to set up your new package:
  https://github.com/napari/napari-plugin-template#getting-started
  and review the napari docs for plugin developers:
  https://napari.org/stable/plugins/index.html
  -->

  Setup conda environment
      mamba create -n popidd_io python pip
  Install test version from project base directory
      pip install -e ".[testing]"
  Run dev environment with
      python developing.py
  <!-- You can install `popidd-io` via [pip]:
      pip install popidd-io -->

  This plugin brings support for brightfield and fluorescence images to Napari,
  as well as adding support for polygonal annotations in geoJSON files saved by QuPath.
  Brightfield images are loaded as a single layer, incorporating also resolution
  information if found on the metadata.
  Fluorescence images are separated into channels annotated using the information
  present in the image metadata.
  Support for this latter modality is still ongoing and will improve in the coming weeks.

  Contributions are very welcome. Tests can be run with [tox], please ensure
  the coverage at least stays the same before you submit a pull request.

  Made by Ferran Cardoso Rodriguez with the help of colleagues at the Integrated Pathology Unit.
  Distributed under the terms of the [GNU GPL v3.0] license,
  "popidd-io" is free and open source software

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [copier]: https://copier.readthedocs.io/en/stable/
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [napari-plugin-template]: https://github.com/napari/napari-plugin-template
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/

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


pkgId: 4555031f6fbbf451732e347586839ca24afae6f14378da81462e8325221dcbd2
name: python-population-synthesis-toolkit-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for population-synthesis-toolkit
url: https://pypi.org/project/population-synthesis-toolkit/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-population-synthesis-toolkit-1.0.1-1.src.rpm
location_href: Packages/python-population-synthesis-toolkit-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  PST is a very flexible tool that allows users to perform stellar population synthesis using a variety of SSP models, as well as computing observables quantities such as spectra, photometry or equivalent widths from both synthetic and observational data.


  [![Documentation Status](https://readthedocs.org/projects/population-synthesis-toolkit/badge/?version=latest)](https://population-synthesis-toolkit.readthedocs.io/en/latest/?badge=latest)
  ![Unit tests](https://github.com/paranoya/population-synthesis-toolkit/actions/workflows/testing.yml/badge.svg)



  Check the [documentation page](https://population-synthesis-toolkit.readthedocs.io/en/latest/) for extensive information.



  Follow the instructions at the [installation section](https://population-synthesis-toolkit.readthedocs.io/en/latest/installation.html) in the documentation page for details on installing PST.



  The [tutorials](./tutorials) illustrate the basic functionality of PST through simple example use cases.



  If you want to contribute to the project, feel free to report any [issues](https://github.com/paranoya/population-synthesis-toolkit/issues) you may find and/or fork this repository and open a pull request.

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


pkgId: a5a35747676d47b06c23afa8563cda2a61229752cc38df0846967e45a8b3ee17
name: python-portone-server-sdk-help
arch: noarch
version: 0.9.0
epoch: 0
release: 1
summary: Development documents and examples for portone-server-sdk
url: https://pypi.org/project/portone-server-sdk/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-portone-server-sdk-0.9.0-1.src.rpm
location_href: Packages/python-portone-server-sdk-help-0.9.0-1.noarch.rpm
checksum_type: sha256
description:
  Packages under _portone-io/server-sdk-py_ are primarily distributed under the
  terms of both the [Apache License (Version 2.0)] and the [MIT license]. See
  [COPYRIGHT] for details.
  [MIT license]: LICENSE-MIT
  [Apache License (Version 2.0)]: LICENSE-APACHE
  [COPYRIGHT]: COPYRIGHT


pkgId: 97d97097e22ab9d32631d64a4adbae0b434eb77db5436c4dbc247f7d8268bdde
name: python-posit-sdk-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for posit-sdk
url: https://pypi.org/project/posit-sdk/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-posit-sdk-0.7.0-1.src.rpm
location_href: Packages/python-posit-sdk-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  This package provides a Pythonic interface for developers to work against the public APIs of Posit's professional products. It is intended to be lightweight yet expressive.

  > The Posit SDK is in the very early stages of development, and currently only Posit Connect has any support.



  ```shell
  pip install posit-sdk
  ```



  Establish server information and credentials using the following environment variables or when initializing a client. Then checkout the [Posit Connect Cookbook](https://docs.posit.co/connect/cookbook/) to get started.

  > [!CAUTION]
  > It is important to keep your API key safe and secure. Your API key grants access to your account and allows you to make authenticated requests to the Posit API. Treat your API key like a password and avoid sharing it with others. If you suspect that your API key has been compromised, regenerate a new one immediately to maintain the security of your account.



  ```shell
  export CONNECT_API_KEY="my-secret-api-key"
  export CONNECT_SERVER="https://example.com/"
  ```

  ```python
  from posit.connect import Client

  client = Client()
  ```



  ```shell
  export CONNECT_API_KEY="my-secret-api-key"
  ```

  ```python
  from posit.connect import Client

  Client("https://example.com")
  ```



  ```python
  from posit.connect import Client

  Client("https://example.com", "my-secret-api-key")
  ```



  We welcome contributions to the Posit SDK for Python! If you would like to contribute, see the [CONTRIBUTING](CONTRIBUTING.md) guide for instructions.



  If you encounter any issues or have any questions, please [open an issue](https://github.com/posit-dev/posit-sdk-py/issues). We appreciate your feedback.



  This project is licensed under the [MIT License](LICENSE). Feel free to use, modify, and distribute the code as you see fit.



  We expect all contributors to adhere to the project's [Code of Conduct](CODE_OF_CONDUCT.md) and create a positive and inclusive community.

rpm_license:
  MIT License  Copyright (c) 2024 posit-dev  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: 0cc566f44c8250458a43f980b42e064012dae5f4cd8e503d80196b53231ae713
name: python-postcar-help
arch: noarch
version: 0.0.8
epoch: 0
release: 1
summary: Development documents and examples for postcar
url: https://pypi.org/project/postcar/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-postcar-0.0.8-1.src.rpm
location_href: Packages/python-postcar-help-0.0.8-1.noarch.rpm
checksum_type: sha256
description:
  - [Installation](#installation)
  - [License](#license)

  ```console
  pip install postcar
  ```

  `postcar` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.



  Each migration package needs to be importable.
  Migration modules must be named starting with a four digit sequence number,
  followed by an underscore, and a (short) description.
  Here's a sample structure of a migration directory:
  ```
  migrations
  ├── __init__.py
  ├── 0001_init.py
  ├── 0002_authorization.py
  └── 0003_create_extensions.py
  ```

  The migration modules must contain a class named `Migration`,
  which must inherit from `postcar.Migration`.
  A minimal migration file might look as follows:
  ```python
  import postcar
  class Migration(postcar.Migration):
      def get_forward(self) -> str:
          return """
              create extension pg_trgm;
          """
      def get_rollback(self) -> str:
          return """
              drop extension pg_trgm;
          """
  ```

  The package comes with a minimal CLI.
  See `postcar --help` for available commands.

  > NOTE: this isn't implemented yet, so use the CLI for the time being
  Sample configuration file:
  ```python

  import os
  from postcar import config
  connection = config.ConnectionInfo(
      host="127.0.0.1",
      port=5432,
      dbname="mydb",
      username="postcar",
      password=os.getenv("POSTGRES_PASSWORD"),
  )
  namespace = "_bookkeeping"
  packages = ["myapp.migrations"]
  ```

  The below table is an exhaustive list of the available parameters.
  More detailed descriptions below the table.
  | Name                  | CLI                | Type            | Default      |
  | --------------------- | ------------------ | --------------- | ------------ |
  | —                     | `-c`/`--conf`      | `Optional[str]` | `None`       |
  | `connection.host`     | `-H`/`--host`      | `Optional[str]` | `None`       |
  | `connection.port`     | `-p`/`--port`      | `Optional[int]` | `None`       |
  | `connection.dbname`   | `-D`/`--dbname`    | `Optional[str]` | `None`       |
  | `connection.username` | `-U`/`--user`      | `Optional[str]` | `None`       |
  | `connection.password` | `-P`/`--password`  | `Optional[str]` | `None`       |
  | `namespace`           | `-s`/`--namespace` | `str`           | `"_postcar"` |
  | `packages`            | —                  | `Sequence[str]` | `()`         |

  Connection info parameters, very similar to the Postgres defaults.

  The database schema to use for bookkeeping.

  The migration packages to run migrations for by default.


  For the sake of consistency, and keeping things "simple",
  internal schema migrations are designated by minor versions.
  In short, a bump from `1.2.3` to `1.2.4` must never migrate the internal schema,
  whereas `1.2.3` to `1.3.0` or `2.0.0` may.
  Ultimately, the goal is to enable effortless upgrades between versions,
  without unnecessarily complicated manual intervention.
  Regardless: this is a rather experimental package, at least until version 1.0.0.
  Until then: expect things to break, without any guarantees.

  - [ ] Implement rollback
  - [ ] Migration dependencies
  - [ ] CLI command for generating a new migration skeleton


pkgId: feeb07dcd78dd92de4deaef584e820739813510b984e38f8a413d8c8e3208752
name: python-power-comparison-help
arch: noarch
version: 1.0.8
epoch: 0
release: 1
summary: Development documents and examples for power-comparison
url: https://pypi.org/project/power-comparison/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-power-comparison-1.0.8-1.src.rpm
location_href: Packages/python-power-comparison-help-1.0.8-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="Shows the Power Comparison logo, a balance scale with two lightning bolts hovering above each side." src="https://raw.githubusercontent.com/hdert/Power-Comparison/main/src/power_comparison/img/power_compare.svg">
  </p>
  <p align="center">
      A modern Tkinter based app for comparing power plan prices!
  </p>

  <p align="center">
      <a href="https://pypi.org/project/power-comparison"><img src="https://img.shields.io/pypi/v/power-comparison.svg"></a>
      <a href="https://github.com/hdert/Power-Comparison/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/power-comparison.svg"></a>
  </p>



  -   [Getting Started](#getting-started)
      -   [Installation](#installation)
      -   [Usage](#usage)
  -   [Contributing](#contributing)
      -   [Developing](#developing)
  -   [License](#license)





  Power Comparison is available as [`power-comparison`](https://pypi.org/project/power-comparison/) on PyPI:

  ```sh

  pip install power-comparison


  pipx install power-comparison
  ```



  To run Power Comparison try:

  ```sh
  power-comparison
  ```



  Contributions are welcome and highly appreciated.

  Contributions in the areas of power plan pricing data, and power retailer usage data downloaders would be extremely appreciated.



  Simply install [`hatch`](https://pypi.org/project/hatch) with:

  ```sh
  pip install hatch
  ```

  make your changes, and then try them out with:

  ```sh
  hatch run power-comparison
  ```



  This repository is licensed under the [GPL-3.0 License](https://github.com/hdert/Power-Comparison/blob/main/LICENSE).


pkgId: b31dd3dfad1c5ec7b697580e782d9b699ed2c5961d5331692c6ef3b58c5cb634
name: python-powerchat-cli-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for powerchat-cli
url: https://pypi.org/project/powerchat-cli/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-powerchat-cli-0.1.6-1.src.rpm
location_href: Packages/python-powerchat-cli-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/powerchat-cli.svg)](https://badge.fury.io/py/powerchat-cli)
  ![PyPI downloads](https://img.shields.io/pypi/dm/powerchat-cli)
  ![Python version](https://img.shields.io/badge/python-3.10+-brightgreen)
  ![Operating system](https://img.shields.io/badge/os-linux%20%7c%20macOS%20%7c%20windows-brightgreen)
  ![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)

  ![example chat](https://github.com/quintenroets/chat/blob/main/assets/examples/example.png?raw=true)



  Run
  ```shell
  chat
  ```
  or
  ```shell
  powerchat
  ```

  1. [Setup langchain-ollama](https://dev.to/emmakodes_/how-to-run-llama-31-locally-in-python-using-ollama-langchain-k8k)

  2. Run `pip install powerchat-cli`


pkgId: 991d48c3d09714794af149e36c0c8ed2f531e5ddb188f0c5bc429c23fc156e50
name: python-powermake-help
arch: noarch
version: 1.20.3
epoch: 0
release: 1
summary: Development documents and examples for powermake
url: https://github.com/mactul/powermake
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-powermake-1.20.3-1.src.rpm
location_href: Packages/python-powermake-help-1.20.3-1.noarch.rpm
checksum_type: sha256
description:
  <img alt="ubuntu x64 tests status" src="https://github.com/mactul/powermake/workflows/Run%20tests%20on%20ubuntu%20x64/badge.svg">
  <img alt="windows x64 tests status" src="https://github.com/mactul/powermake/workflows/Run%20tests%20on%20windows%20x64/badge.svg">

  <img alt="macos x64 tests status" src="https://github.com/mactul/powermake/workflows/Run%20tests%20on%20macos%20x64/badge.svg">
  <img alt="macos arm64 tests status" src="https://github.com/mactul/powermake/workflows/Run%20tests%20on%20macos%20arm64/badge.svg">

  - [PowerMake](#powermake)
    - [What is PowerMake?](#what-is-powermake)
    - [Does PowerMake generates a Makefile like CMake ?](#does-powermake-generates-a-makefile-like-cmake-)
    - [For which project is PowerMake suitable?](#for-which-project-is-powermake-suitable)
    - [Advantages of PowerMake](#advantages-of-powermake)
    - [Disadvantages of PowerMake](#disadvantages-of-powermake)
    - [Philosophy](#philosophy)
    - [Installation](#installation)
    - [Install from Pypi: (RECOMMENDED)](#install-from-pypi-recommended)
    - [install from sources: (NOT RECOMMENDED AT ALL)](#install-from-sources-not-recommended-at-all)
    - [Quick Example](#quick-example)
      - [See more examples](#see-more-examples)
    - [Documentation](#documentation)
      - [Command line arguments](#command-line-arguments)
      - [Toolchain detection](#toolchain-detection)
      - [PowerMake flags translation](#powermake-flags-translation)
      - [powermake.run](#powermakerun)
      - [powermake.Config](#powermakeconfig)
        - [Members](#members)
          - [debug](#debug)
          - [rebuild](#rebuild)
          - [nb\_total\_operations](#nb_total_operations)
          - [target\_name](#target_name)
          - [nb\_jobs](#nb_jobs)
          - [compile\_commands\_dir](#compile_commands_dir)
          - [host\_operating\_system](#host_operating_system)
          - [target\_operating\_system](#target_operating_system)
          - [host\_architecture](#host_architecture)
          - [target\_architecture](#target_architecture)
          - [c\_compiler](#c_compiler)
          - [cpp\_compiler](#cpp_compiler)
          - [as\_compiler](#as_compiler)
          - [asm\_compiler](#asm_compiler)
          - [archiver](#archiver)
          - [linker](#linker)
          - [shared\_linker](#shared_linker)
          - [obj\_build\_directory](#obj_build_directory)
          - [lib\_build\_directory](#lib_build_directory)
          - [exe\_build\_directory](#exe_build_directory)
          - [defines](#defines)
          - [additional\_includedirs](#additional_includedirs)
          - [shared\_libs](#shared_libs)
          - [c\_flags](#c_flags)
          - [cpp\_flags](#cpp_flags)
          - [c\_cpp\_flags](#c_cpp_flags)
          - [as\_flags](#as_flags)
          - [asm\_flags](#asm_flags)
          - [c\_cpp\_as\_asm\_flags](#c_cpp_as_asm_flags)
          - [ar\_flags](#ar_flags)
          - [ld\_flags](#ld_flags)
          - [shared\_linker\_flags](#shared_linker_flags)
          - [exported\_headers](#exported_headers)
        - [Methods](#methods)
          - [set\_debug()](#set_debug)
          - [set\_optimization()](#set_optimization)
          - [set\_target\_architecture()](#set_target_architecture)
          - [target\_is\_windows()](#target_is_windows)
          - [target\_is\_linux()](#target_is_linux)
          - [target\_is\_mingw()](#target_is_mingw)
          - [add\_defines()](#add_defines)
          - [remove\_defines()](#remove_defines)
          - [add\_shared\_libs()](#add_shared_libs)
          - [remove\_shared\_libs()](#remove_shared_libs)
          - [add\_includedirs()](#add_includedirs)
          - [remove\_includedirs()](#remove_includedirs)
          - [add\_c\_flags()](#add_c_flags)
          - [remove\_c\_flags()](#remove_c_flags)
          - [add\_cpp\_flags()](#add_cpp_flags)
          - [remove\_cpp\_flags()](#remove_cpp_flags)
          - [add\_c\_cpp\_flags()](#add_c_cpp_flags)
          - [remove\_c\_cpp\_flags()](#remove_c_cpp_flags)
          - [add\_as\_flags()](#add_as_flags)
          - [remove\_as\_flags()](#remove_as_flags)
          - [add\_asm\_flags()](#add_asm_flags)
          - [remove\_asm\_flags()](#remove_asm_flags)
          - [add\_c\_cpp\_as\_asm\_flags()](#add_c_cpp_as_asm_flags)
          - [remove\_c\_cpp\_as\_asm\_flags()](#remove_c_cpp_as_asm_flags)
          - [add\_ar\_flags()](#add_ar_flags)
          - [remove\_ar\_flags()](#remove_ar_flags)
          - [add\_ld\_flags()](#add_ld_flags)
          - [remove\_ld\_flags()](#remove_ld_flags)
          - [add\_shared\_linker\_flags()](#add_shared_linker_flags)
          - [remove\_shared\_linker\_flags()](#remove_shared_linker_flags)
          - [add\_exported\_headers()](#add_exported_headers)
          - [remove\_exported\_headers()](#remove_exported_headers)
          - [copy()](#copy)
          - [empty\_copy()](#empty_copy)
      - [powermake.default\_on\_clean](#powermakedefault_on_clean)
      - [powermake.default\_on\_install](#powermakedefault_on_install)
      - [powermake.get\_files](#powermakeget_files)
      - [powermake.filter\_files](#powermakefilter_files)
      - [powermake.compile\_files](#powermakecompile_files)
      - [powermake.archive\_files](#powermakearchive_files)
      - [powermake.link\_files](#powermakelink_files)
      - [powermake.link\_shared\_lib](#powermakelink_shared_lib)
      - [powermake.delete\_files\_from\_disk](#powermakedelete_files_from_disk)
      - [powermake.run\_another\_powermake](#powermakerun_another_powermake)
      - [powermake.run\_command\_if\_needed](#powermakerun_command_if_needed)
      - [powermake.needs\_update](#powermakeneeds_update)
      - [powermake.run\_command](#powermakerun_command)
      - [powermake.Operation (deprecated)](#powermakeoperation-deprecated)
        - [execute()](#execute)
      - [Having more control than what powermake.run offers](#having-more-control-than-what-powermakerun-offers)
        - [powermake.ArgumentParser](#powermakeargumentparser)
          - [add\_argument()](#add_argument)
          - [parse\_args()](#parse_args)
        - [powermake.generate\_config](#powermakegenerate_config)
        - [powermake.run\_callbacks](#powermakerun_callbacks)
      - [Compatibility with other tools](#compatibility-with-other-tools)
        - [Scan-Build](#scan-build)
        - [LLVM libfuzzer](#llvm-libfuzzer)
        - [GNU Make](#gnu-make)
        - [Visual Studio Code](#visual-studio-code)




  Powermake is a utility that compiles C/C++/AS/ASM code, just like Make, Ninja, cmake, or xmake.

  His goal is to give full power to the user, while being cross-platform and easier to use than Make.

  Powermake extends what is possible to do during the compilation by providing a lot of functions to manipulate your files and a lot of freedom on the way you will implement your makefile.
  Powermake is entirely configurable, but for every behavior you haven't explicitly defined, PowerMake will do most of the job for you by detecting installed toolchains, translating compiler flags, etc...




  Not by default.
  PowerMake does not build on top of make, it replaces make.

  Since PowerMake 1.20.0, Powermake is able to generate a Makefile, but this will never be as powerful as PowerMake, this feature is only used if you really need a GNU Makefile for compatibility with old deployments/tests scripts.




  PowerMake was specifically designed for complex projects that have very complicated compilation steps, with a lot of pre-built tasks that need to be compiled on multiple operating systems with different options.

  However, today, even for a 5 files project on Linux with GCC, PowerMake is more convenient than make because out of the box it provides a debug/release mode with different options and different build directories, it can generates a compile_commands.json file for a better integration with vscode, it detects better than make when files need to be recompiled, it provides default rebuild/clean/install options without any configuration, etc...




  - Cross-Platform:
    - PowerMake can detect the compiler installed on your machine and give you an abstraction of the compiler syntax.
      - This currently works well with GCC/G++/Clang/Clang++/Clang-CL/MSVC/NASM, but other compilers will be added.
    - Because it's written in python it works on almost all machines and you can always write the compilation instructions for your machine and your compiler.

  - Gives you complete control of what you are doing. Nothing is hidden and any behavior can be overwritten.
    - Missing features can always be written in the makefile.

  - Provides good automatic configurations
    - PowerMake have local and global config files, but on top of that, PowerMake is able to automatically find a value that make sense for each field that is not explicitly assigned, you can easily have very basic configurations files (often no config file at all) and it will still work for most systems.

  - Extremely fast:
    - PowerMake is faster than make/xmake and most of the time faster than Ninja when building a project for the first time.
    - There are still some improvements to do to detect that there is nothing to do for a huge codebase because PowerMake doesn't store hidden dependencies (header files). But with less than 2000 files, this step is almost instant.




  - PowerMake is very young so it changes a lot with each version and you may have to write some features by yourself (the whole point of PowerMake is that you can write missing features). In theory retrocompatibilty is kept between versions, but this might not be true if you are using very specific features, especially undocumented ones.

  - Because PowerMake gives you full control, the tool can't know what you are doing during the compilation step. For example, if we want to import dependencies from another PowerMake, the only thing we can do for you is run the PowerMake where it stands and scan its output directory. This works well but has some limitations... Another example of this problem is that PowerMake can't know how many steps will be done during the compilation, so if you want PowerMake to print the percent of compilation elapsed, you have to manually specify the number of steps PowerMake will do.




  All other Make-like utilities that I know parse a file to understand directives from it.

  PowerMake does the opposite. You write a python script, you do whatever you like in this script and you call PowerMake functions to help you compile your code.
  This gives you complete control; you can retrieve files from the web, read and write files, and even train a Neural Network if you want, and at any time you can use Powermake functions to help you in your compilation journey.

  This also mean that the philosophy is completely different than in tool like make.
  When you read a GNU Makefile, you start at the end, the final target and you read each target dependency recursively before executing the task.
  In a GNU Makefile, the order of each target doesn't reflect at all the order of execution.

  Powermake is read as a script. the order of each instruction has a capital importance. The first step is read, if it needs to be executed, it's executed, then the next step is read, etc...
  - The main advantage of this approach is that it's extremely easy to write and read the makefile, it's just a good old script that executes from top to bottom. You can also do loops, functions, etc... everything python offers, which is way more powerful than the make approach.
  - The main disadvantage of this approach is that steps during the makefile can't automatically be parallelized. [powermake.compile_files](#powermakecompile_files) offers a good parallelization that counteracts this problem, but you have to compile most of your files in this function for this parallelization to have an effect. The worse thing you can do is loop over each one of your file and call this function for one file at a time.




  > [!WARNING]
  > In this documentation, the command `python` refers to python >= python 3.7.
  > On old systems, `python` and `pip` can refer to python 2.7, in this case, use `python3` and `pip3`.




  ```sh
  pip install -U powermake
  ```
  Don't hesitate to run this command regularly to benefit from new features and bug fixes.




  Version installed from sources might be untested and might not work at all.

  ```sh

  pip install -U build twine
  git clone https://github.com/mactul/powermake
  cd powermake
  sed -i "s/{{VERSION_PLACEHOLDER}}/0.0.0/g" pyproject.toml
  rm -rf ./dist/
  python -m build
  pip install -U dist/powermake-*-py3-none-any.whl --force-reinstall
  ```




  This example compiles all `.c` and `.cpp` files that are recursively in the same folder as the python script and generate an executable named `program_test`

  > [!WARNING]
  > PowerMake calculates all paths from its location, not the location where it is run.
  > For example, `python ./folder/makefile.py` will do the same as `cd ./folder && python ./makefile.py`

  > [!NOTE]
  > In this documentation, we often assume that your makefile is named `makefile.py`, it makes things easier to explain. Of course, you can name your makefile the name you like the most.

  ```py
  import powermake


  def on_build(config: powermake.Config):

      files = powermake.get_files("**/*.c", "**/*.cpp")

      objects = powermake.compile_files(config, files)

      print(powermake.link_files(config, objects))


  powermake.run("program_test", build_callback=on_build)
  ```







  > [!NOTE]
  > This documentation is not complete, if you struggle to do something, do not hesitate to ask a question in the [discussions section](https://github.com/mactul/powermake/discussions/categories/q-a), it may be that the feature you search for is undocumented.




  To benefit from the command line parser, you have to use the [powermake.run](#powermakerun) function.

  If no arguments are passed through the command line, the default behavior is to trigger the build callback.
  You can also write `python makefile.py build`, `python makefile.py clean`, `python makefile.py install [install_location]` or `python makefile.py test` to trigger one of the four different callbacks.

  There is also the `python makefile.py config` command, which doesn't trigger a callback but enters into an interactive mode for editing a configuration file.

  Alternatively, you can also use the option `-b` or `--build`, `-c` or `--clean`, `-i` or `--install`, `-t` or `--test` and `-f` or `--config`.
  This alternative has a great advantage: you can combine multiple tasks. For example, running `python makefile.py -btci` will first trigger the clean callback, then the build callback, the install callback and finally the test callback.

  > [!IMPORTANT]
  > The order will always be config -> clean -> build -> install -> test.

  You can also replace the `-b` argument with `-r` (using `-br` does the same as `-r`) and this will force the makefile to recompile everything, without trying to figure out which file needs to be recompiled.

  There are many more options you can add such as `-d` (`--debug`), `-q` (`--quiet`), `-v` (`--verbose`), etc...

  All these options can be listed by running `python makefile.py -h` or if you haven't created a makefile yet, by directly calling the module `python -m powermake -h` or just `powermake -h` if the pip installation is in your path.

  > [!IMPORTANT]
  > While `python makefile.py install` and `python makefile.py --install` takes the `install_location` as an optional argument, this argument has been disabled with the `-i` option, because writing `-bic` would have triggered the install callback with the location `c`




  PowerMake infers the various toolchain programs to be used using everything it knows.
  Most of the time, just setting up the C compiler configuration (or the C++ compiler or the linker, etc...) will be sufficient for PowerMake to determinate the whole toolchain.

  > [!NOTE]
  > Only the unspecified fields are inferred, the field explicitly assigned in the json configuration (see [powermake.Config](#powermakeconfig)) are left unchanged. The only exception is when CC, CXX or LD env variables are specified (see below)

  The environment variables CC, CXX and LD can be used to overwrite the C compiler, C++ compiler and linker tools path.
  For example, the command below will compile using the afl-\* toolchain. The C++ compiler and the linker are inferred from the C compiler (but only if they are not specified in the json configuration).
  ```sh
  CC=afl-gcc python makefile.py -rvd
  ```

  This is especially useful to quickly compile with a different toolchain. For example if you want to exceptionally compile an executable for Windows using Linux:
  ```sh
  CC=x86_64-w64-mingw32-gcc python makefile.py -rvd
  ```




  When this is possible, PowerMake tries to translate C/C++/AS/ASM/LD flags.

  Most flags are unknown to PowerMake, in this case they are simply transmitted to the compiler and it's your job to ensure the compatibility with the different targets through the use of if/else blocks.

  However, the most common flags are automatically translated by PowerMake.
  Their is also some flags that PowerMake defines that doesn't exist in any compiler, these are set of useful flags for a situation.

  Here is the list of flags translated by PowerMake:
  > [!NOTE]
  > Only compiler flags are listed, they are also translated for the linker but most of the time this ends up being just the removal of the flag.


  | PowerMake Flag |  Description                   |
  | :------------: | :----------------------------: |
  | -w             | Inhibit all warning messages.  |
  | -Werror        | Make all warnings into errors. |
  | -Wall          | Activate warnings about all constructs that are unlikely to be intended. |
  | -Wextra        | Enable flags that are likely to catch bugs even though they may warn on perfectly valid code. |
  | -Wpedantic     | Warn when the code isn't ISO (typically when C/C++ extension are used). |
  | -pedantic      | Same a -Wpedantic |
  | -Wswitch       | Warn when a switch on an enum lacks a case (enabled by -Wall) |
  | -Wswitch-enum  | Like -Wswitch but warns even if their is a default case |
  | -fanalyzer     | When supported by the compiler, run the code into a static analyzer to detect some bugs. |
  | -Weverything   | Enable as most warning as possible, even the noisy and irrelevant ones. |
  | -Wsecurity     | Enable all warnings that have a little chance to catch a security issue. |
  | -O0            | Disable all optimizations. |
  | -Og            | Enable optimizations that don't interfere with the debugger. This is better than -O0 for debugging because some warnings and analysis require some optimization. |
  | -O1            | Enable optimization but try to mitigate compile time. |
  | -O             | Same as -O1. |
  | -O2            | Performs nearly all supported optimizations. |
  | -O3            | Optimize aggressively for speed. |
  | -Ofast         | Enable all -O3 optimizations + some some optimization that can brake the program. |
  | -Os            | Optimize for size. |
  | -Oz            | Optimize aggressively for size rather than speed. |
  | -fomit-frame-pointer | Omit the frame pointer in functions that don’t need one. |
  | -m32           | If supported, switch to x86 architecture (you should prefer using [config.set_target_architecture](#set_target_architecture)). |
  | -m64           | If supported, switch to x64 architecture (you should prefer using [config.set_target_architecture](#set_target_architecture)). |
  | -march=native  | Generate a program optimized for CPUs that have the same capabilities of the host. |
  | -mtune=native  | Optimize a program for the specific CPU of the host, even if this program will run slower or not at all on any other machine. |
  | -mmx           | Enable mmx vectorization. |
  | -msse          | Enable sse vectorization. |
  | -msse2         | Enable sse2 vectorization. |
  | -msse3         | Enable sse3 vectorization. |
  | -mavx          | Enable avx vectorization. |
  | -mavx2         | Enable avx2 vectorization. |
  | -g             | Compile with debug symbols. |
  | -fPIC          | Position Independent Code, required when compiling objects that will be bundled in a shared library. |
  | -fsecurity=1   | Enable all flags that can mitigate security issues with negligible impact on performance. Warnings included. |
  | -fsecurity=2   | Enable all flags that can mitigate security issues. |
  | -fsecurity     | same as -fsecurity=2. |
  | -ffuzzer       | Enable the address sanitizer and the fuzzer. |



  ```py
  powermake.run(target_name: str, *, build_callback: callable, clean_callback: callable = default_on_clean, install_callback: callable = default_on_install, test_callback: callable = default_on_test, args_parsed: argparse.Namespace = None)
  ```
  It's the entry point of most programs.
  This function parses the command line and generates a [powermake.Config](#powermakeconfig) object, containing all the information required for the compilation, from the compiler path to the level of verbosity to use.

  Then, depending on the command line arguments, this function will call the clean callback, the build callback, the install callback, or all of them.

  The `target_name` is a string that will be stored in the config and which will be used for auto-naming. You should set this to the name of your executable or the name of your library.

  The `build_callback` and the `clean_callback` only take 1 argument: The [powermake.Config](#powermakeconfig) object generated.

  Example:
  ```py
  import powermake


  def on_build(config: powermake.Config):
      print("The build callback was called !")
      print(f"Compiling the project {config.target_name}...")

  def on_clean(config: powermake.Config):
      print("The clean callback was called !")
      print(f"Erasing the project {config.target_name}...")


  powermake.run("my_project", build_callback=on_build, clean_callback=on_clean)
  ```

  The `install_callback` takes 2 arguments: The [powermake.Config](#powermakeconfig) object and a string `location` that can be `None` if the user hasn't specified anything on the command line.

  > [!TIP]
  > It's often a very good idea to use the `install_callback` as a "pre-install script" and then call `powermake.default_on_install`.
  >
  > Example:
  > ```py
  > import powermake
  >
  >
  > def on_build(config: powermake.Config):
  >     print("The build callback was called !")
  >     print(f"Compiling the lib {config.target_name}...")
  >
  > def on_install(config: powermake.Config, location: str):
  >     if location is None:
  >         # No location is explicitly provided so we change the default for our convenience.
  >         location = "/usr/local/"
  >
  >     # This ensures that the file "my_lib.h" will be exported into /usr/local/include/my_lib/my_lib.h
  >     # The .so or .a that corresponds will be copied into /usr/local/lib/my_lib.so
  >     config.add_exported_headers("my_lib.h", subfolder="my_lib")
  >
  >     powermake.default_on_install(config, location)
  >
  >
  > powermake.run("my_lib", build_callback=on_build, clean_callback=on_clean)
  > ```

  The `args_parsed` argument should be left to None in most cases, to understand his purpose, see [powermake.ArgumentsParser.parse_args](#parse_args)



  This is the most important object of this library.
  It contains everything you need for your compilation journey. For example, it stores the C compiler alongside the path to the build folder.

  Most of the time, this object is created by [powermake.run](#powermakerun) and you don't need to worry about the constructor of this object (which is a bit messy...).

  But one thing you have to know is that the construction of this object involves 4 steps:
  - step 1: It checks the value of the CC and CXX environment variables and if they are set, it sets the path of the C compiler and the C++ compiler with these variables. This makes sure that powermake is compatible with clang `scan-build` utility.
  - step 2: It loads the local config file, by default stored at `./powermake_config.json` just next to the `makefile.py` (or whatever name your makefile has)
  - step 3: It completes the local config with the global config, by default, stored in your home, at `~/.powermake/powermake_config.json` (If you create an env variable named `POWERMAKE_CONFIG`, you can override this location.).
  - step 4: For all fields that are left empty, powermake will try to create a default value from your platform information.

  In theory, after the end of these 4 steps, all members of the `powermake.Config` object should be set.
  In rare cases, if powermake was enabled to detect a default compiler, the `c_compiler`, `cpp_compiler`, `archiver`, and `linker` members can be None.
  In this situation, it's your responsibility to give them a value before the call to the `powermake.compile_files` function.


  If you haven't, we recommend you try compiling your code without setting any `powermake_config.json`. In most cases, the automatic detection of your environment does a good job of finding your compiler/system/etc...

  We provide a tool to interactively set your configuration file, you use it either by running `python -m powermake` or `python makefile.py config`, but this tool cannot configure everything, so we provide here an example of a `powermake_config.json`.
  Here, everything is set, but **you should set the bare minimum**, especially, you shouldn't set the "host_architecture", it's way better to let the script find it.
  Please note that this example is incoherent, but it shows as many options as possible.

  ```json
  {
      "nb_jobs": 8,
      "compile_commands_dir": ".vscode/",
      "host_operating_system": "Linux",
      "target_operating_system": "Windows",
      "host_architecture": "x64",
      "target_architecture": "x86",

      "c_compiler": {
          "type": "gcc",
          "path": "/usr/bin/gcc"
      },
      "cpp_compiler": {
          "type": "clang++"
      },
      "as_compiler": {
        "type": "gcc",
        "path": "/usr/bin/gcc"
      },
      "asm_compiler": {
        "type": "nasm",
        "path": "/usr/bin/nasm"
      },
      "archiver": {
          "type": "ar",
          "path": "/usr/bin/ar"
      },
      "linker": {
          "type": "gnu",
          "path": "/usr/bin/cc"
      },
      "shared_linker": {
          "type": "g++",
          "path": "/usr/bin/g++"
      },

      "obj_build_directory": "./build/objects/",
      "lib_build_directory": "./build/lib/",
      "exe_build_directory": "./build/bin/",

      "defines": ["WIN32", "DEBUG"],
      "additional_includedirs": ["/usr/local/include", "../my_lib/"],
      "shared_libs": ["mariadb", "ssl", "crypto"],
      "c_flags": ["-fanalyzer", "-O3"],
      "cpp_flags": ["-g", "-O0"],
      "c_cpp_flags": ["-Wswitch"],
      "as_flags": [],
      "asm_flags": ["-s"],
      "c_cpp_as_asm_flags": ["-Wall", "-Wextra"],
      "ar_flags": [],
      "ld_flags": ["-static", "-no-pie"],
      "shared_linker_flags": ["-fPIE"],

      "exported_headers": ["my_lib.h", ["my_lib_linux.h", "my_lib/linux"], ["my_lib/windows.h", "my_lib/windows"]]
  }
  ```




  All fields that can be set in the `powermake_config.json` have the same name in the `powermake.Config` object, so we have grouped them below.

  Most of the `powermake.Config` members can be set in the json configuration but there are 4 exceptions: `config.debug`, `config.rebuild`, `config.nb_total_operations` and `config.target_name`.


  ```py
  config.debug: bool
  ```
  This member is `True` if the the makefile is ran in debug mode (with the flag -d or the flag --debug).
  Changing this at runtime will not do anything useful, please use [powermake.set_debug](#set_debug).

  > [!IMPORTANT]
  > This member is one of the 4 exceptions that can't be set in the json configuration.



  ```py
  config.rebuild: bool
  ```
  This member is `True` if the the makefile is ran in rebuild mode (with the flag -r or the flag --rebuild).
  If you change its value at runtime, the following steps will change their behavior.

  > [!IMPORTANT]
  > This member is one of the 4 exceptions that can't be set in the json configuration.



  ```py
  config.nb_total_operations: int
  ```
  This member is always 0 after the creation of a new powermake.Config object, if you set a value > 0, if PowerMake is not in quiet mode, it will display a percent of the compilation elapsed at each step, calculated based on the value of this member.

  For example, if you compile `len(files)` files and you then link all these files, you should set:
  ```py
  config.nb_total_operations = len(files) + 1
  ```

  > [!IMPORTANT]
  > This member is one of the 4 exceptions that can't be set in the json configuration.



  ```py
  config.target_name: str
  ```

  The name registered by [powermake.run](#powermakerun). It's used to determine the default name of executables and libraries.

  > [!IMPORTANT]
  > This member is one of the 4 exceptions that can't be set in the json configuration.



  ```py
  config.nb_jobs: int
  ```

  This number determines how many threads the compilation should be parallelized.
  If non-set or set to zero, this number is chosen according to the number of CPU cores you have.

  Set this to 1 to disable multithreading.

  This can be overwritten by the command-line.



  ```py
  config.compile_commands_dir: str | None
  ```
  If this is set, [powermake.compile_files](#powermakecompile_files) will generate a `compile_commands.json` in the directory specified by this parameter.



  ```py
  config.host_operating_system: str
  ```
  A string representing the name of your operating system.

  > [!TIP]
  > It's not recommended to set this in the json file, the autodetection should do a better job.



  ```py
  config.target_operating_system: str
  ```

  A string representing the name of the operating system for which the executable is for.
  It's used to determine the subfolder of the build folder and for the functions `target_is_linux`, `target_is_windows`, etc...

  On Linux, if you set this to "Windows" (or anything that starts win "win"), it will enable mingw as the default toolchain.

  - You can write this in the json configuration, but only if you are doing cross-compilation, on the other hand, you should let powermake retrieve this value.
  > [!WARNING]
  > Note that if you change this value in the script after the config is loaded, [obj_build_directory](#obj_build_directory), [lib_build_directory](#lib_build_directory) and [exe_build_directory](#exe_build_directory) will not be updated.



  ```py
  config.host_architecture: str
  ```
  A string representing the architecture of your system, which can be "amd64", "x64", "x86", "i386", etc...
  If you need an easier string to work with, use `config.host_simplified_architecture` which can only be "x86", "x64", "arm32" or "arm64".

  > [!TIP]
  > It's not recommended to set this in the json file, the autodetection should do a better job.



  ```py
  config.target_architecture: str
  ```
  A string representing the architecture of the executable, which can be "amd64", "x64", "x86", "i386", etc...
  If you need an easier string to work with, use `config.target_simplified_architecture` which can only be "x86", "x64", "arm32" or "arm64".
  It's used to determine the subfolder of the build folder and to set the compiler architecture (if possible).

  - You can write this in the json configuration, but only if you are doing cross-compilation, on the other hand, you should let powermake retrieve this value.
  > [!WARNING]
  > Note that if you change this value in the script after the config is loaded, the environment will not be reloaded and the compiler will keep the previous architecture, use [config.set_target_architecture](#set_target_architecture) to reload the environment.



  ```py
  config.c_compiler: powermake.compilers.Compiler
  ```

  This one is different in the json config and the loaded config.

  In the json config, it's defined as an object with 2 fields, like this:
  ```json
  "c_compiler": {
      "type": "gcc",
      "path": "/usr/bin/gcc"
  },
  ```
  If the `"path"` field is omitted, the compiler corresponding to the type is searched in the path. For example if `"type"` is `"msvc"`, the compiler "cl.exe" is searched in the path.

  If the `"type"` field is omitted, his value is determined based on the name of the executable and the rest of the toolchain.


  - The `"type"` field can have the value `"gnu"`, `"gcc"`, `"clang"`, `"mingw"`, `"msvc"` or `"clang-cl"`.
    It determines the syntax that should be used. For example, if you are using afl-gcc, the syntax of the compiler is the same as the `gcc` syntax.
    For mingw on Windows, our compiler should be set like this:
    ```json
    "c_compiler" {
        "type": "gcc",
        "path": "C:\\msys64\\ucrt64\\bin\\gcc.exe"
    }
    ```
  > [!NOTE]
  > For mingw on Windows, you should simply set  `C:\msys64\ucrt64\bin` in your PATH and powermake will be able to find it automatically

  - The `"path"` field indicates where is the executable of the compiler. Note that PATH searching is always applied, so `"gcc"` work as well as `"/usr/bin/gcc"`
    For using i386-elf-gcc on Linux, your compiler can be set like this:
    ```json
    "c_compiler" {
        "type": "gcc",
        "path": "i386-elf-gcc"
    }
    ```

  When the `powermake.Config` object is loaded, the `c_compiler` member is no longer a `dict`, it's a virtual class that inherits from `powermake.compilers.Compiler` and which can generate compile commands. see [documentation is coming]


  ```py
  config.cpp_compiler: powermake.compilers.Compiler
  ```

  The cpp_compiler behave exactly like the [c_compiler](#c_compiler) but the possible types are:
  - `gnu++`
  - `g++`
  - `clang++`
  - `msvc`
  - `mingw++`

  You can also use one of the [c_compiler](#c_compiler) types, but in this case you **must** add a path, or the compilers will not be C++ compilers.



  ```py
  config.as_compiler: powermake.compilers.Compiler
  ```

  This compiler is used to compile GNU Assembly (.s and .S files)

  The as_compiler behave exactly like the [c_compiler](#c_compiler) but the possible types are:
  - `gnu`
  - `gcc`
  - `clang`
  - `mingw`

  You can also use one of the [asm_compiler](#asm_compiler) types if you have to compile a .s or .S file with `nasm` or something like that.



  ```py
  config.asm_compiler: powermake.compilers.Compiler
  ```

  This compiler is used to compile .asm files (generally Intel asm)

  The asm_compiler behave exactly like the [c_compiler](#c_compiler) but the only type currently supported is:
  - `nasm`

  You can also use one of the [as_compiler](#as_compiler) types if you have to compile a .asm file with a GNU assembler.



  ```py
  config.archiver: powermake.archivers.Archiver
  ```
  The archiver is the program used to create a static library.

  The configuration in the json behave exactly like the [c_compiler](#c_compiler) but the possible types are:
  - `gnu`
  - `ar`
  - `llvm-ar`
  - `msvc`
  - `mingw`

  Once loaded, the `config.archiver` is a virtual class that inherits from `powermake.archivers.Archiver`.



  ```py
  config.linker: powermake.linkers.Linker
  ```

  The configuration in the json behave exactly like the [c_compiler](#c_compiler) but the possible types are:
  - `gnu`
  - `gnu++`
  - `gcc`
  - `g++`
  - `clang`
  - `clang++`
  - `ld`
  - `msvc`
  - `mingw`
  - `mingw++`

  Once loaded, the `config.linker` is a virtual class that inherits from `powermake.linkers.Linker`.



  ```py
  config.shared_linker: powermake.shared_linkers.SharedLinker
  ```

  The configuration in the json behaves exactly like [config.linker](#linker) but is used to link shared libraries.

  Once loaded, the `config.shared_linker` is a virtual class that inherits from `powermake.shared_linkers.SharedLinker`.



  ```py
  config.obj_build_directory: str
  ```

  This is the directory in which all .o (or equivalent) will be stored.

  > [!TIP]
  > It's not recommended to set this in the json file, the automatic path generation should do a better job, ensuring that debug/release, windows/Linux, or x86/x64 doesn't have any conflict.



  ```py
  config.lib_build_directory: str
  ```

  This is the directory in which all .a, .so, .lib, .dll, etc... will be stored.

  > [!TIP]
  > It's not recommended to set this in the json file, the automatic path generation should do a better job, ensuring that debug/release, windows/Linux, or x86/x64 doesn't have any conflict.



  ```py
  config.exe_build_directory: str
  ```

  This is the directory in which the linked executable will be stored.

  > [!TIP]
  > It's not recommended to set this in the json file, the automatic path generation should do a better job, ensuring that debug/release, windows/Linux, or x86/x64 doesn't have any conflict.



  ```py
  config.defines: list[str]
  ```

  This is a list of some defines that will be used during the compilation process.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these defines directly in the makefile with [config.add_defines](#add_defines), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.additional_includedirs: list[str]
  ```

  This is a list of additional includedirs that will be used during the compilation process.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these includedirs directly in the makefile with [config.add_includedirs](#add_includedirs), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.shared_libs: list[str]
  ```

  This is a list of shared libraries that will be used for the link.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these shared libs directly in the makefile with [config.add_shared_libs](#add_shared_libs), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.c_flags: list[str]
  ```

  A list of flags that will be passed to the C compiler (not the C++ compiler).

  If in the powermake known flags list, these flags are translated for the specific compiler.
  If not, they are simply passed to the compiler.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_c_flags](#add_c_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.cpp_flags: list[str]
  ```

  A list of flags that will be passed to the C++ compiler (not the C compiler).

  If in the powermake known flags list, these flags are translated for the specific compiler.
  If not, they are simply passed to the compiler.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_cpp_flags](#add_cpp_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.c_cpp_flags: list[str]
  ```

  A list of flags that will be passed to the C compiler AND the C++ compiler.

  If in the powermake known flags list, these flags are translated for the specific compiler.
  If not, they are simply passed to the compiler.

  In the `powermake.Config` object, this list doesn't correspond to a real list, it's just a property. You can read the value of `config.c_cpp_flags`, it's just the concatenation of `c_flags` and `cpp_flags`, but you can't edit this property, you have to use [config.add_c_cpp_flags](#add_c_cpp_flags) and [config.remove_c_cpp_flags](#remove_c_cpp_flags)

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_c_cpp_flags](#add_c_cpp_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.as_flags: list[str]
  ```

  A list of flags that will be passed to the GNU assembly compiler.

  If in the powermake known flags list, these flags are translated for the specific compiler.
  If not, they are simply passed to the compiler.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_as_flags](#add_as_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.asm_flags: list[str]
  ```

  A list of flags that will be passed to the Intel ASM compiler.

  If in the powermake known flags list, these flags are translated for the specific compiler.
  If not, they are simply passed to the compiler.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_asm_flags](#add_asm_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.c_cpp_as_asm_flags: list[str]
  ```

  A list of flags that will be passed to the C AND the C++ compiler AND the AS compiler AND the ASM compiler.

  This behaves exactly like [config.c_cpp_flags](#c_cpp_flags), with the same limitations.



  ```py
  config.ar_flags: list[str]
  ```

  A list of flags that will be passed to the archiver.

  If in the powermake known flags list, these flags are translated for the specific archiver.
  If not, they are simply passed to the archiver.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_ar_flags](#add_ar_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.ld_flags: list[str]
  ```

  A list of flags that will be passed to the linker.

  If in the powermake known flags list, these flags are translated for the specific linker.
  If not, they are simply passed to the linker.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these flags directly in the makefile with [config.add_ld_flags](#add_ld_flags), if needed, in a conditional statement like `if config.target_is_windows():`



  ```py
  config.shared_linker_flags: list[str]
  ```

  A list of flags that will be passed to the linker when linking a shared library.

  This behaves exactly like [config.ld_flags](#c_cpp_flags), with the same limitations.



  ```py
  config.exported_headers: list[str | tuple[str, str | None]]
  ```

  This is a list of .h and .hpp that need to be exported in a `include` folder during the installation process.

  This list can directly contain strings, in this case, the file is exported at the root of the `include` folder.
  This list can also contain 2 elements lists. The first element is the file to export and the second element is the subfolder of the `include` folder in which the file should be exported.

  - This list is merged from the local and global config
  > [!TIP]
  > It's not recommended to set this in the json file, it makes much more sense to add these headers directly in the makefile with [config.add_exported_headers](#add_exported_headers), if needed, in a conditional statement like `if config.target_is_windows():`





  These are all the methods you can call from the `powermake.Config` object.
  You can access all members to read them, but you should use these methods if possible to set them, to ensure that everything stays coherent.



  ```py
  config.set_debug(debug: bool = True, reset_optimization: bool = False)
  ```

  If `debug` is True, set everything to be in debug mode. It replaces the `NDEBUG` defined by `DEBUG`, adds the `-g` flag and if possible modifies the output dir to change from a release folder to a debug folder.

  If `debug` is False, set everything to be in release mode. (does the opposite of what's explained above)

  If `reset_optimization` is set to True, then a `debug` to True will put the optimization to `-O0` and a `debug` to False will put the optimization to `-O3`

  > [!NOTE]
  > If possible you should prefer using the command-line instead of this function.



  ```py
  config.set_optimization(opt_flag: str)
  ```

  Remove all optimization flags set and add the `opt_flag`



  ```py
  config.set_target_architecture(architecture: str) -> None:
  ```

  Reset the target architecture to the one specified.
  This will reload compilers to produce code for the good architecture.


  ```py
  config.target_is_windows()
  ```

  Returns `True` if the target operating system is Windows.
  This uses the [config.target_operating_system](#target_operating_system) member.



  ```py
  config.target_is_linux()
  ```

  Returns `True` if the target operating system is Linux.
  This uses the [config.target_operating_system](#target_operating_system) member.



  ```py
  config.target_is_mingw()
  ```

  Returns `True` if the target operating system is MinGW
  This uses the [config.target_operating_system](#target_operating_system) member and the [config.c_compiler](#c_compiler) member.



  ```py
  config.add_defines(*defines: str)
  ```

  Add new defines to [config.defines](#defines) if they do not exist.
  This method is variadic so you can put as many defines as you want.
  The list order is preserved.



  ```py
  config.remove_defines(*defines: str)
  ```

  Remove defines from [config.defines](#defines) if they exists.
  This method is variadic so you can put as many defines as you want.



  ```py
  config.add_shared_libs(*shared_libs: str)
  ```

  Add shared libraries to [config.shared_libs](#shared_libs) if they do not exist.
  This method is variadic so you can put as many libs as you want.
  The list order is preserved.



  ```py
  config.remove_shared_libs(*shared_libs: str)
  ```

  Remove shared libraries from [config.shared_libs](#shared_libs) if they exists.
  This method is variadic so you can put as many libs as you want.



  ```py
  config.add_includedirs(*includedirs: str)
  ```

  Add additional includedirs to [config.additional_includedirs](#additional_includedirs) if they do not exist.
  This method is variadic so you can put as many includedirs as you want.
  The list order is preserved.



  ```py
  config.remove_includedirs(*includedirs: str)
  ```

  Remove additional includedirs from [config.additional_includedirs](#additional_includedirs) if they exists.
  This method is variadic so you can put as many includedirs as you want.
  The list order is preserved.



  ```py
  config.add_c_flags(*c_flags: str)
  ```

  Add flags to [config.c_flags](#c_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_c_flags(*c_flags: str)
  ```

  Remove flags from [config.c_flags](#c_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_cpp_flags(*cpp_flags: str)
  ```

  Add flags to [config.cpp_flags](#cpp_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_cpp_flags(*cpp_flags: str)
  ```

  Remove flags from [config.cpp_flags](#cpp_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_c_cpp_flags(*c_cpp_flags: str)
  ```

  Add flags to [config.c_cpp_flags](#c_cpp_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_c_cpp_flags(*c_cpp_flags: str)
  ```

  Remove flags from [config.c_cpp_flags](#c_cpp_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_as_flags(*as_flags: str)
  ```

  Add flags to [config.as_flags](#as_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_as_flags(*as_flags: str)
  ```

  Remove flags from [config.as_flags](#as_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_asm_flags(*asm_flags: str)
  ```

  Add flags to [config.asm_flags](#asm_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_asm_flags(*asm_flags: str)
  ```

  Remove flags from [config.asm_flags](#asm_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_c_cpp_as_asm_flags(*c_cpp_as_asm_flags: str)
  ```

  Add flags to [config.c_cpp_as_asm_flags](#c_cpp_as_asm_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_c_cpp_as_asm_flags(*c_cpp_as_asm_flags: str)
  ```

  Remove flags from [config.c_cpp_as_asm_flags](#c_cpp_as_asm_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_ar_flags(*ar_flags: str)
  ```

  Add flags to [config.ar_flags](#ar_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_ar_flags(*ar_flags: str)
  ```

  Remove flags from [config.ar_flags](#ar_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_ld_flags(*ld_flags: str)
  ```

  Add flags to [config.ld_flags](#ld_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_ld_flags(*ld_flags: str)
  ```

  Remove flags from [config.ld_flags](#ld_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_shared_linker_flags(*shared_linker_flags: str)
  ```

  Add flags to [config.shared_linker_flags](#shared_linker_flags) if they do not exist.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.remove_shared_linker_flags(*shared_linker_flags: str)
  ```

  Remove flags from [config.shared_linker_flags](#shared_linker_flags) if they exists.
  This method is variadic so you can put as many flags as you want.
  The list order is preserved.



  ```py
  config.add_exported_headers(*exported_headers: str, subfolder: str = None)
  ```

  Add exported headers to [config.exported_headers](#exported_headers) if they do not exist.
  This method is variadic so you can put as many headers as you want.
  The list order is preserved.

  By default, there is no subfolder, but we recommend you use `config.target_name` for the `subfolder` argument.



  ```py
  config.remove_exported_headers(*exported_headers: str, subfolder: str = None)
  ```

  Remove exported headers from [config.exported_headers](#exported_headers) if they exists.
  This method is variadic so you can put as many headers as you want.
  The list order is preserved.



  ```py
  config.copy()
  ```

  Returns a new config object which is a deepcopy of the config. It should be used to compile different set of files with different parameters.



  ```py
  config.empty_copy(local_config: str = None) -> powermake.Config
  ```

  Generate a new fresh config object without anything inside. By default, even the local config file isn't loaded.
  It can be very helpful if you have a local config file specifying a cross compiler but you want to have the default compiler at some point during the compilation step.



  ```py
  powermake.default_on_clean(config: powermake.Config)
  ```

  This is the default callback used by [powermake.run](#powermakerun) if the `clean_callback` is unspecified but you can use it whenever you want.

  It cleans the obj, lib, and exe build directories of the `config`



  ```py
  powermake.default_on_install(config: Config, location: str)
  ```

  This is the default callback used by [powermake.run](#powermakerun) if the `install_callback` is unspecified but you can use it whenever you want.
  If you overwrite the `install_callback` (which is the normal way of adding exported headers), you should call this function inside your defined callback to have a coherent installation. See the example in [powermake.run](#powermakerun)

  Each library compiled is copied and put in a directory named `lib`.
  Each header in [config.exported_headers](#exported_headers) is copied and put in a directory named `include`.
  Each executable compiled is copied and put in a directory named `bin`.

  The final structure is as follows:
  ```
  location
      |_ include
          |_ eventual_subfolders
              |_ my_lib.h
      |_ lib
          |_ my_lib.a
      |_ bin
          |_ my_program
  ```

  If `location` is None, the default is `./install/`.



  ```py
  powermake.get_files(*patterns: str) -> set
  ```

  Returns a set of filepaths that matches at least one of the patterns.

  Authorized patterns are:
  - `*` to match a filename, for example `"foo/*.c"` will match `"foo/test.c"` but not `"foo/bar/test.c"`
  - `**/` to match recursive directories, for example, `"foo/**/test.c"` will match  `"foo/test.c"` and `"foo/bar/test.c"`.
  > [!IMPORTANT]
  > `"**.c"` will not match `"foo/test.c"`, you have to write `"**/*.c"` for that.

  This function is variadic.



  ```py
  powermake.filter_files(files: set, *patterns: str) -> set
  ```

  From a given set of filepaths, remove every file that matches at least one of the patterns.
  Returns a new filepaths set, filtered.

  Authorized patterns are:
  - `*` to match a filename, for example `"foo/*.c"` will match `"foo/test.c"` but not `"foo/bar/test.c"`
  - `**/` to match recursive directories, for example, `"foo/**/test.c"` will match  `"foo/test.c"` and `"foo/bar/test.c"`.
  > [!IMPORTANT]
  > `"**.c"` will not match `"foo/test.c"`, you have to write `"**/*.c"` for that.

  This function is variadic.



  ```py
  powermake.compile_files(config: powermake.Config, files: set, force: bool = None) -> set
  ```

  This function is a wrapper of lower-level powermake functions.

  From a set or a list of `.c`, `.cpp`, `.cc`, `.C`, `.s`, `.S` and `.asm` filepaths and a [powermake.Config](#powermakeconfig) object, runs the compilation of each file in parallel, with the appropriate compiler and options found in `config`.

  - If `force` is True, all files are recompiled, even if they are up to date.
  - If `force` is False, only the files that are not up to date are recompiled
  - If `force` is None (default), the value of `config.rebuild` is used.

  Returns a set of `.o` (or compiler equivalent) filepaths for the next step.
  If `files` is a list, the function returns a list with the order preserved.



  ```py
  powermake.archive_files(config: powermake.Config, object_files: set, archive_name: str = None, force: bool = None) -> str
  ```

  This function is a wrapper of lower-level powermake functions.

  From a set of `.o` (or compiler equivalent) filepaths, maybe the one returned by [powermake.compile_files](#powermakecompile_files) and a [powermake.Config](#powermakeconfig) object, runs the command to create a static library with the appropriate archiver and options in `config`.

  - if `archive_name` is None, the `config.target_name` is concatenated with the prefix `"lib"` so if `config.target_name` is `"XXX"`, the name will be `"libXXX"` and then the extension given by the type of archiver is added.
  - if `archiver_name` is not None, only the extension is added, if you want to use this parameter and you want your lib to be `"libXXX"`, you have to explicitly write `"libXXX"`.

  - If `force` is True, the archive is re-created, even if it's up to date.
  - If `force` is False, the archive is created only if not up to date.
  - If `force` is None (default), the value of `config.rebuild` is used.

  Returns the path of the static library generated.



  ```py
  powermake.link_files(config: powermake.Config, object_files: set, archives: list = [], executable_name: str = None, force: bool = None) -> str
  ```

  This function is a wrapper of lower-level powermake functions.

  From a set of `.o` (or compiler equivalent) filepaths, maybe the one returned by [powermake.compile_files](#powermakecompile_files) and a [powermake.Config](#powermakeconfig) object, it runs the command to create a n executable with the appropriate linker and options in `config`.

  - if `executable_name` is None, the `config.target_name` is used with the extension given by the type of linker.
  - if `executable_name` is not None, his value is concatenated with the extension.

  - If `force` is True, the executable is re-created, even if it's up to date.
  - If `force` is False, the executable is created only if not up to date.
  - If `force` is None (default), the value of `config.rebuild` is used.

  Returns the path of the executable generated.



  ```py
  powermake.link_shared_lib(config: Config, object_files: set, archives: list = [], lib_name: str = None, force: bool = None) -> str
  ```

  This function is a wrapper of lower-level powermake functions.

  From a set of `.o` (or compiler equivalent) filepaths, maybe the one returned by [powermake.compile_files](#powermakecompile_files) and a [powermake.Config](#powermakeconfig) object, runs the command to create a shared library with the appropriate shared linker and options in `config`.

  - if `lib_name` is None, the `config.target_name` is concatenated with the prefix `"lib"` so if `config.target_name` is `"XXX"`, the name will be `"libXXX"` and then the extension given by the type of shared linker is added.
  - if `lib_name` is not None, only the extension is added, if you want to use this parameter and you want your lib to be `"libXXX"`, you have to explicitly write `"libXXX"`.

  - If `force` is True, the lib is re-created, even if it's up to date.
  - If `force` is False, the lib is created only if not up to date.
  - If `force` is None (default), the value of `config.rebuild` is used.

  Returns the path of the shared library generated.

  > [!TIP]
  > Don't forget to compile the `object_files` with the flag `-fPIC`.



  ```py
  powermake.delete_files_from_disk(*filepaths: str)
  ```

  Remove each filepath and skip if it doesn't exist.

  This function is variadic.



  ```py
  powermake.run_another_powermake(config: powermake.Config, path: str, debug: bool = None, rebuild: bool = None, verbosity: int = None, nb_jobs: int = None) -> list
  ```

  Run a powermake from another directory and return a list of paths to all libraries generated.

  If the parameters `debug`, `rebuild`, `verbosity`, and `nb_jobs` are left to None, the values in `config` are used.
  These parameters are passed to the other powermake.



  ```py
  run_command_if_needed(config: powermake.Config, outputfile: str, dependencies: Iterable[str], command: list[str] | str, shell: bool = False, force: bool | None = None, **kwargs: Any) -> str
  ```

  Run a command generating a file only if this file needs to be re-generated.

  Raise a RuntimeError if the command fails.

  `outputfile` is the file generated by the command and `dependencies` is an iterable of every file that if changed should trigger the run of the command.

  - If `shell` is `False`:
    - `command` should be a list like `argv`. The first element should be an executable and each following element will be distinct parameters.
    This list is then directly passed to `subprocess.run`

  - If `shell` is `False`:
    - `command` should be a string representing the shell command.


  - If `force` is True, the command is run anyway.
  - If `force` is False, the command is only run if `outputfile` is up to date with its dependencies.
  - If `force` is None (default), the value of `config.rebuild` is used.

  `**kwargs` is passed to `powermake.run`



  ```py
  powermake.needs_update(outputfile: str, dependencies: set, additional_includedirs: list) -> bool
  ```

  > [!NOTE]
  > This function is low-level.

  Returns whether or not `outputfile` is up to date with all his dependencies.
  If `dependencies` include C/C++ files and headers, all headers these files include recursively will be added as hidden dependencies.

  The `additional_includedirs` list is required to discover hidden dependencies. You must set this to the additional includedirs used during the compilation of `outputfile`. You can use [config.additional_includedirs](#additional_includedirs) if needed.



  ```py
  run_command(config: powermake.Config, command: list[str] | str, shell: bool = False, target: str | None = None, output_filter: Callable[[bytes], bytes] | None = None, **kwargs) -> int
  ```

  > [!NOTE]
  > This function is low-level.

  Run a command regardless of what it does and if it's needed.

  Returns the exit code of the command.

  If `shell` is `False`:
  - `command` should be a list like `argv`. The first element should be an executable and each following element will be distinct parameters.
    This list is then directly passed to `subprocess.run`

  If `shell` is `False`:
  - `command` should be a string representing the shell command.

  `target` is currently only been used to print the name of the file generated, but in the future, it might be used to generate a Makefile.

  `output_filter` is a callback that can be used to edit the output of the command before it's printed to the screen. Warning, the output of the command is in bytes with no encoding determined. Let this to `None` to just print the output of the command.

  `**kwargs` is passed to `powermake.run`



  ```py
  powermake.Operation(outputfile: str, dependencies: set, config: Config, command: list)
  ```

  > [!NOTE]
  > This object is low-level.

  This is a simple object to execute a command only if needed.
  It can be used to easily parallelize multiple commands.
  > [!TIP]
  > You can use [powermake.compile_files](#powermakecompile_files) which does that for you, but only for C/C++/AS/ASM files.

  > [!WARNING]
  > Directly using powermake.Operation is deprecated

  The command should be a list like `argv`. The first element should be an executable and each following element will be distinct parameters.
  This list is then directly passed to `subprocess.run`


  ```py
  operation.execute(force: bool = False) -> str
  ```

  Run the `command` if `outputfile` is not up to date.

  If `force` is True, the command is run in any case.




  > [!NOTE]
  > This section is advanced.


  ```py
  powermake.ArgumentParser(prog: str = None, description: str = None, **kwargs)
  ```

  This object is a superset of [argparse.ArgumentParser](https://docs.python.org/3/library/argparse.html), you can read the documentation of argparse, it works exactly the same.
  > [!CAUTION]
  > **Use this object and never argparse.ArgumentParser directly** or you will break some powermake features. Obviously the usual command line options will be broken but you will also break other features like the [powermake.run_another_powermake](#powermakerun_another_powermake) function. This object ensure that none of this is broken.



  See the [argparse documentation](https://docs.python.org/3/library/argparse.html) to understand how to add an argument


  ```py
  parser.parse_args()
  ```

  Returns a namespace containing each value parsed from the command line.
  This namespace can be used to take decisions and should then be passed to [powermake.run](#powermakerun) or [powermake.generate_config](#powermakegenerate_config).
  Example:
  ```py
  import powermake

  def on_build(config: powermake.Config):
      ...

  parser = powermake.ArgumentParser()
  parser.add_argument("--foo")

  args_parsed = parser.parse_args()

  print(args_parsed.foo)

  powermake.run("program_test", build_callback=on_build, args_parsed=args_parsed)
  ```



  ```py
  powermake.generate_config(target_name: str, args_parsed: argparse.Namespace = None)
  ```

  This function behave like the first part of [powermake.run](#powermakerun), it generate a config object according to the command line. The difference with [powermake.run](#powermakerun) is that it stop at this point and returns the config generated.
  It can be helpful if you want a global instance of the config.

  In most cases you should let `args_parsed` to None, and this function will automatically parse the command line.

  > [!CAUTION]
  > You have to call `powermake.run_callback` after the call of this function (but you can obviously do something between these 2 functions)



  ```py
  run_callbacks(config: Config, *, build_callback: callable, clean_callback: callable = default_on_clean, install_callback: callable = default_on_install, test_callback: callable = default_on_test)
  ```

  This function only make sense after a call of [powermake.generate_config](#powermakegenerate_config).
  It takes a newly generated config and run each callback according to the command line.

  > [!CAUTION]
  > If neither this function nor powermake.run is used, the powermake.run_another_powermake function will be partially broken

  Example:
  ```py
  import powermake

  def on_build(config: powermake.Config):
      ...

  config = powermake.generate_config("program_test")

  powermake.run_callbacks(config, build_callback=on_build)
  ```






  Powermake is compatible with clang [scan-build](https://clang.llvm.org/docs/analyzer/user-docs/CommandLineUsage.html#scan-build) utility.
  You can run `scan-build python makefile.py -rd` to compile your code with a static analysis.
  Just remember that scan-build needs your program to be compiled in debug mode, hence the `-d` flag.

  We recommend you try compiling your code with different static analyzers to catch as many problems as possible.
  We especially recommend gcc and the `-fanalyzer` option, it's one of the most powerful analyzer we know and PowerMake will ensure that this flag will be removed if unsupported.




  Powermake helps you compile with [LLVM libfuzzer](https://llvm.org/docs/LibFuzzer.html).

  You can add the `-ffuzzer` argument to your compiler and your linker with [config.add_c_cpp_flags](#add_c_cpp_flags) and [config.add_ld_flags](#add_ld_flags).

  If you are using clang or MSVC, this will enable the address sanitizer and fuzzer.
  Otherwise, the argument is ignored.




  Since PowerMake 1.20.0, PowerMake is able to generate a GNU Makefile
  You just have to run:
  ```sh
  python makefile.py -m
  ```
  This will rebuild the powermake (here in release mode) and will generate a GNU Makefile.
  If you want your makefile to be in debug mode, and with a certain toolchain, or with whatever custom argument just run your PowerMake like you would do and add the -m flag.
  ```sh
  CC=x86_64-w64-mingw32-gcc python makefile.py -md
  ```

  > [!WARNING]
  > PowerMake tries its best to generate a valid Makefile, however, because of the [PowerMake philosophy](#philosophy), PowerMake can't know exactly what you are doing in your Makefile, every function that is not provided by PowerMake can't be translated in the Makefile.
  > To get a good Makefile, you should never use the `subprocess` module but instead use [powermake.run_command](#powermakerun_command) or [powermake.run_command_if_needed](#powermakerun_command_if_needed).
  >
  > If you are doing conditions and loops, it's not a problem at all, but you will not see any condition in the generated Makefile, what's in the Makefile depends on the commands actually generated during the initial PowerMake compilation. (That's why the -m flag also enable the -r flag, to be sure that every command is ran.)




  VSCode uses 3 important json files:
  - `compile_commands.json`: Used to know how each file is compiled, which defines and includedirs are used, etc... Can be generated by PowerMake.
  - `tasks.json`: Used to define how to compile the project. In our case, we want to run powermake in this file
  - `launch.json`: Used to launch the debugger

  The `compile_commands.json` can easily be generated by powermake with the option `-o` (`--compile-commands-dir`).
  ```sh
  python makefile.py -o .vscode
  ```
  However, we suggest you to just generate this whenever you compile your code with vscode, by putting the `-o` in the tasks.json like explained below.

  Here is an example of a functional `.vscode/tasks.json`:
  ```json
  {
      "tasks": [
          {
              "type": "cppbuild",
              "label": "powermake_compile",
              "command": "python",
              "args": [
                  "makefile.py",
                  "-rvd",  /* We rebuild each time so the warnings doesn't disappear, we build in debug mode and in verbose to verify if the good commands are ran. */
                  "-o",
                  "${workspaceFolder}/.vscode",  /* We regenerate a new compile_commands.json each time to keep track of new files and modifications in the PowerMake */
                  "--retransmit-colors"  /* This is because the vscode task terminal is not a shell but still supports colors, so we have to tell PowerMake to not remove them */
              ],
              "options": {
                  "cwd": "${workspaceFolder}"  /* Where to run `python makefile.py ...` */
              }
          },
          {
              /* This is fully optional, this task can be mapped to a shortcut (for example F6) so we can test the compilation of a single file */
              "type": "cppbuild",
              "label": "compile_single_file",
              "command": "python",
              "args": [
                  "makefile.py",
                  "-r",
                  "-s",
                  "${file}",
                  "--retransmit-colors"
              ],
              "options": {
                  "cwd": "${workspaceFolder}"
              }
          },
      ],
      "version": "2.0.0"
  }
  ```
  > [!NOTE]
  > You need the Microsoft C/C++ Extension Pack for this to work


  Here is an example of a functional `.vscode/launch.json`:
  ```json
  {
      "configurations": [
          {
              "name": "PowerMake Debug",
              "type": "cppdbg",
              "preLaunchTask": "powermake_compile",
              "request": "launch",
              "program": "${workspaceFolder}/build/Linux/x64/debug/bin/YOUR_PROGRAM",  /* Replace this path by the path of your program compiled */
              "args": [],  /* If your program requires arguments, put them here */
              "cwd": "${workspaceFolder}"
          }
      ]
  }
  ```
  > [!NOTE]
  > You need the Microsoft C/C++ Extension Pack for this to work


  **documentation in progress...**


pkgId: 323c9e41d546b0b410eeee2618e07e78b79fb539770852a9f26702f5fbe7e27b
name: python-powertrain-build-help
arch: noarch
version: 1.1.3
epoch: 0
release: 1
summary: Development documents and examples for powertrain-build
url: https://opendev.org/volvocars/powertrain-build
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-powertrain-build-1.1.3-1.src.rpm
location_href: Packages/python-powertrain-build-help-1.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A Continuous Integration (CI) build system, testing all configurations where a TargetLink model is used.



  - powertrain-build is fast.
    - More parallelization of jobs in the CI system makes it faster.
    - Code generation is moved to the developer's PC.
    - Code generation is done once for all projects using pre-processor directives.
    - C code reviews are now possible in Gerrit.
  - powertrain-build adds signal consistency checks.
  - Unit tests of the build system are introduced.
    - Its quality is assured.
  - powertrain-build creates new variable classes with unique code decorations.
    - Post-processing C code is not necessary.
    - ASIL-classed variables get declared at the source.
    - Memory can be optimized at compilation through short addressing different variable classes.
    - The same models can be used in more than two different suppliers, for instance, SPA2's Core System Platform (CSP).
    - powertrain-build fixes incorrect handling of NVM variables.



  - `docs/`: This directory holds all the extra documentation about the project.
  - `playbooks/`: Directory where we keep Ansible playbooks that are executed in the jobs we use in this project.
  - `powertrain_build/`: Main directory of the project. All the application source code is kept here.
    - `interface/`
    - `lib/`
    - `zone_controller/`
    - `templates/`: Template `.html` files.
    - `matlab_scripts/`: Collection of m-scripts which can be used for generating powertrain-build compatible source code from Simulink models.
  - `roles/`: Directory where we keep Ansible roles that are executed in the jobs we use in this project.
  - `test_data/`: Directory where we keep test data for the unit tests.
  - `tests/`: Directory where we keep the unit tests for our application source code. The tests are structured in a similar way to what we have inside the `powertrain_build/` directory. Tests for the `interface`, `lib`, and `zone_controller` modules are split into `tests/interface/`, `tests/lib/`, and `tests/zone_controller/`, respectively. Other tests are kept inside the `tests/powertrain_build/` directory.
  - `zuul.d/`: Directory where we keep our Zuul jobs.



  See [powertrain-build introduction](./docs/powertrain_build_introduction.md)



  We would love to see you contribute to this project. No matter if it is fixing a bug, adding some tests, improving documentation, or implementing new features. See our [contribution guidelines](./CONTRIBUTING.md) so you can have a better understanding of the whole process.



  We are trying to create a healthy community that thrives on the desire to improve, learn, and share knowledge. See our [code of conduct guidelines](./CODE_OF_CONDUCT.md) to check our behavioral rules on this project.


pkgId: 9e594666217cf50482ff77894fae1fd2035be13ae6bb84f56398d1cb22591fa1
name: python-pp-database-manager-help
arch: noarch
version: 2.6.1
epoch: 0
release: 1
summary: Development documents and examples for pp-database-manager
url: https://pypi.org/project/pp-database-manager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pp-database-manager-2.6.1-1.src.rpm
location_href: Packages/python-pp-database-manager-help-2.6.1-1.noarch.rpm
checksum_type: sha256
description:
  The `database_manager` package is a custom Python library designed to streamline database interactions for the Pristine Pathway project. It provides a unified interface for working with both Supabase and Pocketbase, the two database systems used across the Teacher's Panel, Student's Panel, and Leaderboard applications.
  **Key Features:**
  *   **Abstraction:** Simplifies database operations by providing easy-to-use methods for common tasks like fetching, updating, and inserting data.
  *   **Centralized Logic:** Encapsulates all database-related code in a single package, promoting consistency and maintainability.
  *   **Dual Database Support:** Seamlessly handles interactions with both Supabase (for core data and real-time features) and Pocketbase (for handling potentially larger datasets).
  *   **Authentication:** Manages authentication with both Supabase and Pocketbase.
  *   **Caching:** Implements caching for frequently accessed data (like grade data) to improve performance.
  *   **Error Handling:** Includes robust error handling to gracefully manage database connection issues and other potential problems.
  *   **Published on PyPI:** Available as a reusable package on the Python Package Index (PyPI) named `pp-database-manager`, making it easy to install and use across different projects.


pkgId: db3994019650ab20dfbba296b1c3de67856505bfcdfad5369256346cbd73fcc3
name: python-ppgames-help
arch: noarch
version: 0.1.6
epoch: 0
release: 1
summary: Development documents and examples for ppgames
url: https://github.com/pythonpavan04/ppgames
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ppgames-0.1.6-1.src.rpm
location_href: Packages/python-ppgames-help-0.1.6-1.noarch.rpm
checksum_type: sha256
description:
  `ppgames` is a simple text-based game where the user tries to match their batting score with the computer's bowling score. The game continues until the user matches the score.



  To install `ppgames`, use `pip`:

  ```bash
  pip install ppgames


pkgId: f95a8686d4e7feaff723cf11a18c2e3e82b1deaa24e3941bf15ff7aebcb58902
name: python-ppmac-macro-substitution-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for ppmac-macro-substitution
url: https://pypi.org/project/ppmac-macro-substitution/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ppmac-macro-substitution-1.0.0-1.src.rpm
location_href: Packages/python-ppmac-macro-substitution-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![CI](https://github.com/DiamondLightSource/ppmac-macro-substitution/actions/workflows/ci.yml/badge.svg)](https://github.com/DiamondLightSource/ppmac-macro-substitution/actions/workflows/ci.yml)
  [![Coverage](https://codecov.io/gh/DiamondLightSource/ppmac-macro-substitution/branch/main/graph/badge.svg)](https://codecov.io/gh/DiamondLightSource/ppmac-macro-substitution)
  [![PyPI](https://img.shields.io/pypi/v/ppmac-macro-substitution.svg)](https://pypi.org/project/ppmac-macro-substitution)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)



  A script that substitutes macros in template files.

  Gets substitutes and template files (stored in template_source_folder),
  uses them to generate files (primarily kinematics).

  The generated files are put in destination_folder which defaults to
  configure/coord_substitution.

  Naming convention for generated kinematics:
  ```
      cs_<coordinate_system_number>_<name_of_template_file>
  ```
  and for other files:
  ```
      tmp_<name_of_template_file>
  ```

  Source          | <https://github.com/DiamondLightSource/ppmac-macro-substitution>
  :---:           | :---:
  PyPI            | `pip install ppmac-macro-substitution`
  Releases        | <https://github.com/DiamondLightSource/ppmac-macro-substitution/releases>

  To print the version of the script you can do:

  ```python
  from ppmac_macro_substitution import __version__

  print(f"Hello ppmac_macro_substitution {__version__}")
  ```
  An example substitution file for 3 jack kinematic template:

  ```
  from ppmac_macro_substitution import generate

  substitutes = {}
  substitutes["$(COORD)"] = "4"
  substitutes["$(J1)"] = "1"
  substitutes["$(J1X)"] = "20"
  substitutes["$(J1Z)"] = "10"
  substitutes["$(J2)"] = "2"
  substitutes["$(J2X)"] = "12"
  substitutes["$(J2Z)"] = "13"
  substitutes["$(J3)"] = "3"
  substitutes["$(J3X)"] = "15"
  substitutes["$(J3Z)"] = "16"
  substitutes["$(MD)"] = "10"
  substitutes["$(MCX)"] = "100"
  substitutes["$(MCZ)"] = "2"

  kinematic_template_files = ["inv_3jack.kin", "fwd_3jack.kin"]

  generate(
      substitutes,
      kinematic_template_files,
  )
  ```

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


pkgId: 86490338f772ee7bc015393b529393e11d792de650c1a74d268d6743cb5f9f1f
name: python-pprint-problems-help
arch: noarch
version: 0.1.16
epoch: 0
release: 1
summary: Development documents and examples for pprint-problems
url: https://github.com/qemqemqem/pprint_problems
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pprint-problems-0.1.16-1.src.rpm
location_href: Packages/python-pprint-problems-help-0.1.16-1.noarch.rpm
checksum_type: sha256
description:
  Used to print entries from jsonl files, developed with LLM evals in mind.



  ```pipx install pprint_problems```



  This is still a work in progress. If you have any suggestions or improvements, please feel free to open an issue or a pull request, or contact the author directly.



  Here are some recommended ways to use this script:

  ```
  See this list of commands and more documentation:
      pprint_problems --help

  1. Search for particular problems:
      pprint_problems problems.jsonl -r --search "keyword" -b

  2. Load a local file:
      pprint_problems test_problems.jsonl --randomize -n 1 --parts code tests

  3. Load a local file with "cat":
      cat problems.jsonl | grep "search_term" | pprint_problems -n 1 -p code

  4. Load and randomize problems:
      pprint_problems -r -n 1 problems.jsonl

  5. Use some arguments to only load a subset:
      pprint_problems my_problems.jsonl --n 3 --width 100 --line-numbers --randomize

  6. Print out the structure:
      pprint_problems --structure test_data.jsonl

  7. Print out the raw JSON:
      pprint_problems --n 1 --raw problems.jsonl

  8. Manually filter problems with y/n on the keyboard:
      pprint_problems problems.jsonl --manual-filter -p code broken_diff

  9. Use the most recently modified file in a directory:
      pprint_problems --dir_most_recent my_jsonl_files/ --structure

  10. Graph the distribution of a particular key:
      pprint_problems mydata.jsonl --graph --parts vocab_size

  11. Print stats, similarly to graphing:
      pprint_problems mydata.jsonl --stats --parts vocab_size

  12. Print the structure, along with stats about the ranges of values:
      pprint_problems mydata.jsonl --structure --ranges

  13. Print out only parts of a certain type:
      pprint_problems mydata.jsonl --types str numeric bool
  ```





  Show the `problem["doc_id"]` and `problem["doc"]["question"]` for 3 random items:

  ```bash
  pprint_problems results/samples.jsonl -n 3 -r -p doc_id doc/question
  ```

  ```bash
  Found 132 problems
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                  Problem 71                                   ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                       doc_id
  71

                                    doc/question
  ∀x ∃y {D(n())S(j()),~D(j())T(j())D(f(y,x))} ∃a {D(a*)}
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                  Problem 92                                   ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                       doc_id
  92

                                    doc/question
  {Box(Brown())Box(Yellow())}^{Box(Yellow())}
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                  Problem 110                                  ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                       doc_id
  110

                                    doc/question
  ∃a ∀x {Q(x*)P(a)} ∀x ∃b {Q(x*)R(b)}^{Q(x*)}
  ```



  Search for items with the word "marble" anywhere in them:

  ```bash
  pprint_problems questions.jsonl -r -n 3 --search marble -p question answers/etr
  ```

  ```bash
  Found 60 problems
  After searching, found 12 problems
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                  Problem 50                                   ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                      question
  There is a box in which there is at least a red marble, or else there is a green
  marble and there is a blue marble, but not all three marbles. Is the probability
  of the following situation 33% There is a green marble and there is a blue
  marble.

                                     answers/etr
  yes
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                  Problem 15                                   ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                      question
  There is a box in which there is a grey marble and either a white marble or else
  a mauve marble, but not all three marbles are in the box. Given the preceding
  assertion, is the probability of the following situation 50% In the box there is
  a grey marble and there is a mauve marble.

                                     answers/etr
  yes
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                  Problem 52                                   ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                      question
  There is a box in which there is a grey marble, or else a white marble, or else a
  mauve marble, but no more than one marble. Given the preceding assertion, is the
  probability of the following situation 0% In the box there is a grey marble and
  there is a mauve marble.

                                     answers/etr
  yes
  ```



  Show the string and boolean parts of 1 random item:

  ```bash
  pprint_problems datasets/etr_for_lm_eval.jsonl --types str bool -n 1 -r
  ```

  ```bash
  Found 4 problems
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                                   Problem 2                                   ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

                                      question
  Consider the following premises:

   1 If either voidite is electrically insulating and fluxium is not plasma-like,
     or fluxium is plasma-like, or voidite is electrically insulating and fluxium
     is plasma-like, then fluxium is not plasma-like.
   2 If aurorium is electrically insulating, then either aurorium is electrically
     insulating, or aurorium is not electrically insulating.

  Can you conclude that fluxium is not plasma-like?

                     scoring_guide/classically_valid_conclusion
  true

                 scoring_guide/question_conclusion_is_etr_conclusion
  false
  ```



  Here's an example of how to use this program to print out the structure of a dataset:

  ```bash
  pprint_problems questions.jsonl --structure
  ```

  ```bash
  Found 60 problems
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃                          JSON Structure (problem 0)                           ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
  {
      "question": str (215 characters)
      "answers": dict (2 items)
      {
          "etr": str (3 characters)
          "classical": str (2 characters)
      }
  }
  ```

  You can also show some details about the contents of the dataset with the `--ranges` flag:

  ```bash
  pprint_problems questions.jsonl --ranges
  ```

  ```bash
  Found 60 problems
  ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
  ┃         JSON Structure (problem 0), with Data Ranges from 60 Samples          ┃
  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
  {
      "question": str (215 characters) (60 distinct values, length: 38 to 738)
      "answers": dict (2 items)
      {
          "etr": str (3 characters) (10% no, 90% yes)
          "classical": str (2 characters) (63% no, 37% yes)
      }
  }
  ```



  This project is licensed under the terms of the MIT license.


pkgId: 6356838cbecb40a1e7a2e41dfa3dce3f499c3b4bd558f2949b1d111d8c3560b9
name: python-ppxf-sew-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for ppxf-sew
url: https://pypi.org/project/ppxf-sew/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ppxf-sew-0.2.1-1.src.rpm
location_href: Packages/python-ppxf-sew-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  This ``pPXF-SEW`` package contains a Python implementation of the stellar
  population Synthesis based on ``Equivalent Widths spectrum`` (``SEW``)
  method and the Penalized PiXel-Fitting (``pPXF``) method. It uses
  full-spectrum fitting with SED to extract stellar and gas kinematics,
  the stellar population, as well as the dust attenuation curve of stars
  and galaxies, without a prior attenuation curve. The kinematics are derived
  from the ``pPXF`` method, while the stellar population and attenuation curve
  are derived from the ``SEW`` method.
  The ``SEW`` method was described in Lu (2025) (in prep.).
  The ``pPXF`` method was originally described in `Cappellari & Emsellem (2004)
  <https://ui.adsabs.harvard.edu/abs/2004PASP..116..138C>`_
  and was substantially upgraded in subsequent years, particularly in
  `Cappellari (2017) <https://ui.adsabs.harvard.edu/abs/2017MNRAS.466..798C>`_.


pkgId: b30f50a61451ae7063cb1a9085663e07f358594c41f31e3e8b4edbe895cc457a
name: python-pqapi-help
arch: noarch
version: 7.0.8
epoch: 0
release: 1
summary: Development documents and examples for pqapi
url: https://pypi.org/project/pqapi/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pqapi-7.0.8-1.src.rpm
location_href: Packages/python-pqapi-help-7.0.8-1.noarch.rpm
checksum_type: sha256
description:
  Python client for interacting with the PaperQA server



  Python 3.11+ is required for this package

  ```sh
  pip install pqapi
  ```



  Make sure to set the environment variable `PQA_API_KEY` to your API token:

  ```sh
  export PQA_API_KEY=pqa-...
  ```

  API keys generally have a rate limit associated with them that is based on queries per day. These are based on a rolling window, rather than resetting at a specific time. You will receive 429s if you have exceeded your rate limit on submission.





  The simplest way to use the API is with synchronous queries:

  ```python
  import pqapi

  response = pqapi.agent_query("Are COVID-19 vaccines effective?")

  print(response.answer)
  ```



  You can also make asynchronous queries:

  ```python
  import pqapi

  response = await pqapi.async_agent_query(query)
  ```

  These still require an open connection though, so do not accumulate too many of them. Each query takes between 1 and 5 minutes generally.





  For running multiple long-running queries efficiently, use the job submission API:

  ```python
  import asyncio
  import pqapi


  queries = [
      'What is the elastic modulus of gold?',
      'What is the elastic modulus of silver?',
      'What is the elastic modulus of copper?'
  ]


  jobs = [pqapi.submit_agent_job(query=q) for q in queries]


  results = asyncio.run(pqapi.gather_pqa_results_via_polling(
      [job['metadata']['query_id'] for job in jobs]
  ))
  ```

  The results will include:

  - `question`: Your original query text
  - `request`: Serialized settings used in your query
  - `response`: Serialized `pqapi.AnswerResponse` object



  You can use predefined templates that you develop and save on paperqa.app:

  ```python

  response = pqapi.agent_query(
      'The melting point of gold is 1000F.',
      named_template='check for contradiction'
  )


  contradictions = [
      {
          'query': 'Gold can be transmuted into platinum.',
          'named_template': 'check for contradiction'
      },
  ]
  contradiction_jobs = [pqapi.submit_agent_job(**c) for c in contradictions]
  results = asyncio.run(pqapi.gather_pqa_results_via_polling(
      [job['metadata']['query_id'] for job in contradiction_jobs]
  ))
  ```



  The response object contains detailed information about your query:

  - Sources used
  - Cost information
  - Other metadata

  Access the main specific answer text with:

  ```python
  print(response.answer)
  ```

rpm_license:
  MIT License  Copyright (c) 2023 Future House  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: be1ee676d0022854e09ccee82b454475ceacd3116bac4abd64ccd474715458b9
name: python-pr-ctica-1-hack4u
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Una práctica de biblioteca donde consultar cursos de hack4u.
url: https://hack4u.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pr-ctica-1-hack4u-0.1.0-1.src.rpm
location_href: Packages/python-pr-ctica-1-hack4u-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Una biblioteca en Python para consultar cursos de Hack4u.



  - Introducción a Linux [15 horas]
  - Personalización de entornos [3 horas]
  - Introducción al hacking [53 horas]
  - Python Ofensivo [35 horas]



  Instala el paquete usando `pip3`:

  ```python3
  pip3 install hack4u
  ```





  ```python
  from hacku import listar_cursos

  for curso in listar_cursos():
      print(curso)
  ```



  ```python
  from hacku import buscar_curso_por_nombre

  curso = buscar_curso_port_nombre("Introducción a Linux")
  print(curso)
  ```



  ```python3
  from hack4u.utils import duracion_total

  print(f"Duración total: {duracion_total()} horas")
  ```


pkgId: 4d2b1051ff98568332368960ae70fecf8172dff966c8d65cce4a18b06529a9f6
name: python-practiso-sdk-help
arch: noarch
version: 0.2.3
epoch: 0
release: 1
summary: Development documents and examples for practiso-sdk
url: https://github.com/zhufucdev/practiso_sdk
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-practiso-sdk-0.2.3-1.src.rpm
location_href: Packages/python-practiso-sdk-help-0.2.3-1.noarch.rpm
checksum_type: sha256
description:
  > - [x] Check out [Practiso](https://github.com/zhufucdev/Practiso), a local intelligent study utility.

  To create Practiso archive for importing, use this Python SDK to

  - create questions programmatically,
  - parse other formats like Excel sheets or RTF documents,
  - use generative AI to categorize the questions.



  Questions are composed of several frames, either representing its content
  or the answerable sections. Following is a possible question model and its
  Practiso rendering.

  ```python
  from practiso_sdk import archive

  archive.Text('This is Cat Walker')
  archive.Image(filename='cat_walker.jpg', width=479, height=200, alt_text="People's favour cat DJ")
  archive.Options([
      archive.OptionItem(archive.Text('pretty cool'), is_key=True)
  ])
  ```
  ![frames](assets/frames.png)


  Your categories will be the primary factor on which Practiso decides how to
  recommend new questions or combinations. In Practiso, categorization is described in
  dimensions, what knowledge point a question is related to and how much so,
  so that the system can comprehend them in a hyper dimension line space.



  Generative AI can be utilized to make decisions on how much a category a
  question falls into.

  ```python
  import os

  import practiso_sdk

  agent = practiso_sdk.google.ai.GeminiAgent(api_key=os.environ['GEMINI_API_KEY'])
  dimensions = await agent.get_dimensions(quiz)
  print(dimensions)
  ```


pkgId: 633600120aa54bd8fdca317a9e16e8b7155b960130e40cec91b804adc9fe50d7
name: python-praetorian-cli-help
arch: noarch
version: 1.5.5
epoch: 0
release: 1
summary: Development documents and examples for praetorian-cli
url: https://github.com/praetorian-inc/praetorian-cli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-praetorian-cli-1.5.5-1.src.rpm
location_href: Packages/python-praetorian-cli-help-1.5.5-1.noarch.rpm
checksum_type: sha256
description:
  [![Python Version](https://img.shields.io/badge/Python-v3.9+-blue)](https://www.python.org/)
  [![pip Version](https://img.shields.io/badge/pip-v23.0+-blue)](https://pypi.org/project/praetorian-cli/)
  [![License](https://img.shields.io/badge/License-MIT-007EC6.svg)](LICENSE)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20covenant-2.1-007EC6.svg)](CODE_OF_CONDUCT.md)
  [![Open Source Libraries](https://img.shields.io/badge/Open--source-%F0%9F%92%9A-28a745)](https://opensource.org/)
  [![Contributions Welcome](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg?style=flat)](https://github.com/praetorian-inc/chariot-ui/issues)

  :link: [Chariot Platform](https://chariot.praetorian.com)
  :book: [Documentation](https://docs.praetorian.com)
  :bookmark: [PyPI](https://pypi.org/project/praetorian-cli/)



  - [Description](#description)
  - [Getting started](#getting-started)
      - [Prerequisites](#prerequisites)
      - [Installation](#installation)
      - [Signing up](#signing-up-and-configuration)
  - [Using the CLI](#using-the-cli)
  - [Using scripts](#using-scripts)
  - [Developers](#developers)
  - [Contributing](#contributing)
  - [Support](#support)
  - [License](#license)



  Praetorian CLI and SDK are open-source tools for interacting with our products and services. Currently, they support
  access to [Chariot](https://www.praetorian.com/proactive-cybersecurity-technology/), our
  offensive security platform.
  <br> The SDK exposes the full set of APIs that the Chariot UI uses.
  <br> The CLI is a fully-featured companion to the Chariot UI.





  - Python v3.9 or above
  - pip v23.0 or above



  Install the Python package using this command:

  ```zsh
  pip install praetorian-cli
  ```



  1. Register for an account for [Chariot](http://chariot.praetorian.com) using the instructions
     in [our documentation](https://docs.praetorian.com/hc/en-us/articles/25784233986587-Account-Setup-and-Initial-Seeding).
  2. Run `praetorian configure` and follow the prompts.
  3. It creates `~/.praetorian/keychain.ini`, which should read like this:

  ```
  [United States]
  name = chariot
  client_id = 795dnnr45so7m17cppta0b295o
  api = https://d0qcl2e18h.execute-api.us-east-2.amazonaws.com/chariot
  username = lara.lynch@acme.com
  password = 8epu9bQ2kqb8qwd.GR
  ```

  For more advanced configuration options, as well as SSO. See
  [the documentation on configuration](https://github.com/praetorian-inc/praetorian-cli/blob/main/docs/configure.md).



  The CLI is a command and option utility for access to the full suite of Chariot API. See documentation for commands
  using the `help` option:

  ```zsh
  praetorian chariot --help
  ```

  As an example, run the following command to retrieve the list of all assets in your account:

  ```zsh
  praetorian chariot list assets
  ```

  To get detailed information about a specific asset, run:

  ```zsh
  praetorian chariot get asset <ASSET_KEY>
  ```



  The CLI has a scripting engine for implementing more complex workflows. They add end-to-end
  functions as commands grouped under `script`. To see a list of them:

  ```zsh
  praetorian chariot script --help
  ```

  For example the following command is used to ingest scan results from Nessus XML export files:

  ```zsh
  praetorian chariot script nessus-xml
  ```

  You can find the list of scripts that comes with the CLI in
  [this directory](https://github.com/praetorian-inc/praetorian-cli/tree/main/praetorian_cli/scripts/commands)



  In addition to scripts that are packaged with the CLI, you can point CLI to directories
  with scripts to further extend the CLI with those scripts. Set the `PRAETORIAN_SCRIPTS_PATH`
  environment to point to directories where you store additional extension scripts.



  Both CLI and SDK is open-source in this repository. The SDK is installed along with the `praetorian-cli`
  package. You can extend Chariot by creating scripts using the SDK.



  Integrate the SDK into your own Python application with the following steps:

  1. Include the dependency ``praetorian-cli`` in your project.
  2. Import the Chariot class ``from praetorian_cli.sdk.chariot import Chariot``.
  3. Import the Keychain class ``from praetorian_cli.sdk.keychain import Keychain``.
  4. Call any function of the Chariot class, which expose the full backend API. See example below:

  ```python
  from praetorian_cli.sdk.chariot import Chariot
  from praetorian_cli.sdk.keychain import Keychain

  chariot = Chariot(Keychain())
  chariot.add('asset', dict(name='example.com', dns='example.com'))
  ```

  The best place to explore the SDK is the code of the CLI, especially
  [the handlers of the CLI](https://github.com/praetorian-inc/praetorian-cli/tree/main/praetorian_cli/handlers)

  You can inspect the handler code to see how each CLI command is implemented with the SDK.



  If you want to take advantage of the scaffolding of the CLI, you can write fully fledged functions using
  the scripting engine. For developing scripts, you can refer to
  this [readme file](https://github.com/praetorian-inc/praetorian-cli/blob/main/docs/script-development.md).



  We welcome contributions from the community, from scripts, to the core CLI and SDK. To contribute, fork this
  repository and following the
  [GitHub instructions](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project)
  to create pull requests.

  By contributing, you agree to our [Code of Conduct](CODE_OF_CONDUCT.md).



  If you have any questions or need support, please open an issue
  [here](https://github.com/praetorian-inc/chariot-ui/issues) or reach out via
  [support@praetorian.com](mailto:support@praetorian.com).



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


pkgId: 5415153f5a1c2222513d9682597363de4bdfc36fd527d4c2016132e6695dd7d8
name: python-pragma-sdk-help
arch: noarch
version: 2.4.8
epoch: 0
release: 1
summary: Development documents and examples for pragma-sdk
url: https://pragma.build
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pragma-sdk-2.4.8-1.src.rpm
location_href: Packages/python-pragma-sdk-help-2.4.8-1.noarch.rpm
checksum_type: sha256
description:
  Main repository containing our SDK code.

  For more information, please check the documentation:

  https://pragma-docs.readthedocs.io/en/latest/index.html


pkgId: cfc2006b5ab232685465ab97cc6af8161131937fd789b4ea7550b5286c93a604
name: python-pre-commit-update-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for pre-commit-update
url: https://gitlab.com/vojko.pribudic.foss/pre-commit-update
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pre-commit-update-0.6.1-1.src.rpm
location_href: Packages/python-pre-commit-update-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center"><h1>pre-commit-update</h1>

  _One hook to manage them all..._

  [![Ko-Fi](https://img.shields.io/badge/Buy_me_a_coffee-F16061?style=for-the-badge&logo=ko-fi&logoColor=white)](https://ko-fi.com/dmanthing)

  ![PyPI - Version](https://img.shields.io/pypi/v/pre-commit-update)
  ![PePy - Downloads](https://pepy.tech/badge/pre-commit-update)
  ![Gitlab Pipeline Status](https://img.shields.io/gitlab/pipeline-status/vojko.pribudic.foss%2Fpre-commit-update?branch=main&label=pipeline)
  ![GitLab Issues](https://img.shields.io/gitlab/issues/open/vojko.pribudic.foss%2Fpre-commit-update)
  ![GitLab Last Commit](https://img.shields.io/gitlab/last-commit/vojko.pribudic.foss%2Fpre-commit-update)
  ![Coverage](https://img.shields.io/gitlab/coverage/vojko.pribudic.foss/pre-commit-update/main?job_name=tests)
  ![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/pre-commit-update)
  ![Python - Formatter](https://img.shields.io/badge/code%20style-black-black)
  ![PyPI - License](https://img.shields.io/pypi/l/pre-commit-update?color=%23333333)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pre-commit-update)
  ![Codacy grade](https://app.codacy.com/project/badge/Grade/e727532ea95341b18ffd963e77605c2b)

  **pre-commit-update** is a simple CLI tool and a pre-commit hook to check and update pre-commit hooks.
  </div>

  ![Example](https://gitlab.com/vojko.pribudic.foss/pre-commit-update/-/raw/main/assets/pre-commit-update.gif)



  1. [ Reasoning ](#1-reasoning)
  2. [ Features ](#2-features)
  3. [ Installation ](#3-installation)
  4. [ Usage ](#4-usage)
      1. [ Pipeline usage example ](#1-pipeline-usage-example)
         1. [ GitLab job ](#a-gitlab-job)
      2. [ pre-commit hook usage example ](#2-pre-commit-hook-usage-example)
  5. [ Configuration ](#5-configuration)
  6. [ F.A.Q ](#6-faq)
      1. [ New version of pre-commit-update has a bug, what should I do? ](#1-new-version-of-pre-commit-update-has-a-bug-what-should-i-do)
      2. [ There are certain icons in the output messages, what do they mean? ](#2-there-are-certain-icons-in-the-output-messages-what-do-they-mean)




  `pre-commit` is a nice little tool that helps you polish your code before releasing it into the wild.
  It is fairly easy to use. A single `pre-commit-config.yaml` file can hold multiple hooks (checks) that will go through
  your code or repository and do certain checks. The problem is that the file is static and once you pin your hook versions
  after a while they get outdated.

  `pre-commit-update` was created because there is no easy way to update your hooks by using
  `pre-commit autoupdate` as it is not versatile enough.




  |                        Feature                         | pre-commit-update |            pre-commit autoupdate            |
  |:------------------------------------------------------:|:-----------------:|:-------------------------------------------:|
  |   Has dry run (checks for updates, does not update)    |        Yes        |                     No                      |
  |              Can use stable versions only              |        Yes        |                     No                      |
  |         Can exclude repo(s) from update check          |        Yes        | Workaround (updates only specified repo(s)) |
  | Can keep repo(s) (checks for updates, does not update) |        Yes        |                     No                      |
  |           Can update by hash instead of tag            |        Yes        |                     Yes                     |
  |          Can define custom tag prefix schema           |        Yes        |                     No                      |
  |            Can be used as a pre-commit hook            |        Yes        |                     No                      |
  |         Can be configured in `pyproject.toml`          |        Yes        |                     No                      |




  `pre-commit-update` is available on [PyPI](https://pypi.org/project/pre-commit-update/):
  ```console
  $ python -m pip install pre-commit-update
  ```

  **NOTE:** Please make sure that `git` is installed.




  `pre-commit-update` can be used as below:

  ```console
  $ pre-commit-update [OPTIONS]
  ```

  ```console
    Option:                                       Short description:

    -d, --dry-run / -nd, --no-dry-run             Checks for the new versions without updating
                                                  if enabled  [default: nd]

    -a, --all-versions / -na, --no-all-versions   Includes the alpha/beta versions when
                                                  updating if enabled  [default: na]

    -v, --verbose / -nv, --no-verbose             Displays the complete update output if
                                                  enabled  [default: nv]

    -w, --warnings / -nw, --no-warnings           Displays warning messages if enabled  [default: w]

    -p, --preview / -np, --no-preview             Previews the cli option values by the
                                                  overwriting order if enabled (disables the
                                                  actual cli work!)  [default: np]

    -j, --jobs INTEGER                            Maximum number of worker threads to be used
                                                  for processing

    -e, --exclude REPO_URL_TRIM                   Exclude specific repo(s) by the
                                                  REPO_URL_TRIM - use '*' as a wildcard

    -k, --keep REPO_URL_TRIM                      Keep the version of specific repo(s) by the
                                                  REPO_URL_TRIM (still checks for the new
                                                  versions) - use '*' as a wildcard

    -b, --bleeding-edge REPO_URL_TRIM             Get the latest version or commit of specific
                                                  repo(s) by the REPO_URL_TRIM - use '*' as a
                                                  wildcard

    -t, --tag-prefix <REPO_URL_TRIM TEXT>...      Set the custom tag prefix for the specific
                                                  repo(s) by combining REPO_URL_TRIM with tag
                                                  prefix value

    -V, --version                                 Show the version and exit.

    -h, --help                                    Show this message and exit.
  ```

  Below you can find more detailed explanations of how each option works.

  Some of the options (`--exclude`, `--keep` and `--bleeding-edge`) use `REPO_URL_TRIM` as an argument.

  Example of the `REPO_URL_TRIM`: `https://github.com/ambv/black` -> `black` (you will only pass `black` as a parameter to the
  `--exclude`, `--keep` or `--bleeding-edge` option)


  - `-d, --dry-run / -nd, --no-dry-run` - If enabled, updates will be fetched, but they won't be applied. Useful if you are only
  curious about potential changes that would occur.


  - `-a, --all-versions / -na, --no-all-versions` - If enabled, all version tags will be checked. This may include alpha, beta
  or release candidate versions. Keep in mind that this option is not the same as `-b, --bleeding-edge`!


  - `-v, --verbose / -nv, --no-verbose` - If enabled, every detail will be printed out once the process completes. This
  does not display warnings if they are disabled (`-nw, --no-warnings`)!


  - `-w, --warnings / -nw, --no-warnings` - If enabled, various validation warnings will be displayed (mostly configuration issues)


  - `-p, --preview / -np, --no-preview` - This option excludes all other options if enabled! It is used in order to display the
  configuration priorities/overwrites between default configuration, `pyproject.toml` configuration and options passed directly
  to the cli. It also displays the final configuration and what was changed.


  - `-j, --jobs` - This option sets the maximum number of worker jobs (threads). If left blank, value used will equal to your `cpu_count + 4`


  - `-e, --exclude` - This option, if used, excludes the complete repo (along with all the hooks) from update check. That means that the given
  repo url (for the given `REPO_URL_TRIM`) will be completely skipped. You can exclude multiple repos by repeating the option multiple times
  (example: `--exclude black --exclude isort`). You can also use a wildcard `*` (example: `--exclude '*'`) in order to exclude every single repo
  from the update process. This is useful when, for example, your python version is not up-to-date, and you need time to upgrade your code before
  updating your hooks to their latest versions.

      **NOTE** - Using a wildcard with the `--exclude` option disables the `--keep` and `--bleeding-edge` options


  - `-k, --keep` - This option, if used, keeps the current repo version/hash (along with all the hooks). That means that the given
  repo url (for the given `REPO_URL_TRIM`) will fetch available updates and display them, but no update will take place. You can keep multiple
  repos by repeating the option multiple times (example: `--keep black --keep isort`). You can also use a wildcard `*` (example: `--keep '*'`)
  in order to keep every single repo pinned to the current version while also checking for updates.

      **NOTE** - Using a wildcard with the `--keep` option disables the `--exclude` option


  - `-b, --bleeding-edge` - This option, if used, gets the latest repo version/hash (whatever is more recent). That means that the given
  repo url (for the given `REPO_URL_TRIM`) will be updated to the latest tagged version **OR** latest commit, depending on which one is more recent. This
  also means that `--bleeding-edge` option **ignores** the `--all-versions` option - it will always fetch the latest update - stable or not.
  You can set multiple repos as `--bleeding-edge` by repeating the option multiple times (example: `--bleeding-edge black --bleeding-edge isort`).
  You can also use a wildcard `*` (example: `--bleeding-edge '*'`) in order to update every single repo to the latest version/hash.

      **NOTE** - Using a wildcard with the `--bleeding-edge` option disables the `--exclude` option


  - `-t, --tag-prefix` - This option, if used, sets custom tag prefix schema for the specified repos. This is useful if your repo has custom tags for pre-commit.
  For example, if `REPO_URL_TRIM` `black` has tags as `pre-commit-tag-v0.1.1`, you can use `--tag-prefix` as `--tag-prefix black pre-commit-tag-v`.
  You can set multiple custom tag schemas for multiple repos with `--tag-prefix` option by repeating the option multiple times
  (example: `--tag-prefix black custom-version-v --tag-prefix isort another-schema-v`).

      **NOTE** - Be careful to pass the complete prefix (for `pre-commit-tag-v0.1.1` prefix would be `pre-commit-tag-v`)


  - `-V, --version` - Displays the current version of `pre-commit-update`.


  - `-h, --help` - Displays all the available options along with the short description of each.




  ```yaml
  pre-commit-hooks-update:
    stage: update
    script:
      
      - pip install pre-commit-update
      - pre-commit-update --dry-run
    except:
      - main
    when: manual
    allow_failure: true
  ```

  **NOTE:** This is just an example, feel free to do your own configuration



  You can also use `pre-commit-update` as a hook in your `pre-commit` hooks:

  ```yaml
  - repo: https://gitlab.com/vojko.pribudic.foss/pre-commit-update
    rev: v0.6.1  # Insert the latest tag here
    hooks:
      - id: pre-commit-update
        
        args: [--dry-run, --exclude, black, --keep, isort, --tag-prefix, black, custom-version-v]
  ```

  **NOTE:** This is just an example, feel free to do your own configuration



  You can configure `pre-commit-update` in your `pyproject.toml` as below (do your own configuration):

  Example:
  ```toml
  [tool.pre-commit-update]
  dry_run = true
  all_versions = false
  verbose = true
  warnings = true
  preview = false
  jobs = 10
  exclude = ["isort"]
  keep = ["black"]
  bleeding_edge = ["pylint"]
  tag_prefix = [["black", "custom-tag-schema-v"]]
  ```

  **NOTE:** If some of the options are missing (for example `--exclude` option), `pre-commit-update`
  will use the default value for that option (default for `--exclude` option would be an empty list).

  ***IMPORTANT*** If you invoke `pre-commit-update` with any options (e.g. `pre-commit-update -d`),
  `pyproject.toml` configuration will be **overridden**. This means that all the options passed while
  calling `pre-commit-update` will have priority over the configuration defined inside `pyproject.toml`.
  If you want to override boolean options, you can do so by passing the negative option value.
  For example, given the configuration above, to override `--verbose` option from `pyproject.toml`, you
  would invoke `pre-commit-update` with either `--no-verbose` or `-nv`.

  You can always check the configuration overrides (priorities) by running `pre-commit-update -p` / `pre-commit-update --preview`





  These things do happen, unfortunately. Please report your issue(s) [here](https://gitlab.com/vojko.pribudic.foss/pre-commit-update/-/issues).

  If you are using `pre-commit-update` as a pre-commit hook and the previous version
  of `pre-commit-update` worked for you, you can pin that specific version in your `.pre-commit-config.yaml` file.
  To do so, just add the following in your `.pre-commit-config.yaml` file:

  ```yaml
  - repo: https://gitlab.com/vojko.pribudic.foss/pre-commit-update
    rev: v0.6.0  # Version that works for you
    hooks:
      - id: pre-commit-update
        args: [--keep, pre-commit-update]
  ```

  If you are using `pre-commit-update` as a CLI, you can downgrade to the previous version by running:

  ```console
  $ python -m pip install pre-commit-update==vX.X.X
  ```

  Replace the `X.X.X` with the previous version that worked for you.



  `pre-commit-update` uses the following icons/text in the output messages:

  - `⚠`, `▲`, `[warning]` - Indicates that a message is a warning
  - `✔`, `√`, `[no-update]` - Indicates that there is no need to update the hook
  - `✘`, `×`, `[update]` - Indicates that hook needs to be updated
  - `⧣`, `≠`, `[hash]` - Indicates that the hook is using a hash instead of a tag
  - `★`, `*`, `[exclude]` - Indicates that the hook is excluded from the update process
  - `◉`, `●`, `[keep]` - Indicates that the hook will check for updates but will not be updated
  - `↯`, `±`, `[bleeding-edge]` - Indicates that the hook is using bleeding edge version/hash
  - `⇉`, `»`, `[tag-prefix]` - Indicates that the hook is using custom tag prefix schema

  Some terminals support the Unicode icons (first set), some support universal icons (second set) and some do not
  support either (third set).

  `pre-commit-update` will fallback to whatever is supported by the terminal you use.


pkgId: 4702094e58dbed68c2727b76ee21d3bdc13a4bfa59d7ce8b1e8ff2df7febf8d2
name: python-precommend-help
arch: noarch
version: 0.3.7
epoch: 0
release: 1
summary: Development documents and examples for precommend
url: https://pypi.org/project/precommend/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-precommend-0.3.7-1.src.rpm
location_href: Packages/python-precommend-help-0.3.7-1.noarch.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

  `precommend` bootstraps [pre-commit](https://pre-commit.com) configurations based
  on the content of your project and the recommendations of the [Scientific Software Center](https://ssc.uni-heidelberg.de).



  The Python package can be installed with

  ```
  python -m pip install precommend
  ```



  Head to a directory that you want to add a config file to and run

  ```bash
  precommend
  ```



  This repository was set up using the [SSC Cookiecutter for Python Packages](https://github.com/ssciwr/cookiecutter-python-package).


pkgId: 1fd0b4e6b44bc10126b7ece9b427b3af7d7327022a1735759f7f6c3609b3ae3d
name: python-predeldomain-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for predeldomain
url: https://git.jetsung.com/idev/predeldomain
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-predeldomain-0.1.0-1.src.rpm
location_href: Packages/python-predeldomain-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - 方式一：通过 pypi
  ```bash
  pip install predeldomain
  ```
  - 方式二：通过代码仓库
  ```bash
  pip install git+https://github.com/idevsig/predeldomain.git
  ```
  - 方式三：通过本地仓库
  ```bash
  pip install -e .
  ```
  - 方式四：通过 wheel 包
  ```bash
  pip install predeldomain-X.X.X-py3-none-any.whl
  ```

  ```bash
  » predeldomain --help
  usage: predeldomain [-h] [-l [1-10]] [-m {1,2,3}] [-s {cn,top}] [-t {text,json}] [-w WHOIS]
  The domain name to be pre-deleted.
  options:
    -h, --help            show this help message and exit
    -l [1-10], --length [1-10]
                          Length: 1 to 10
    -m {1,2,3}, --mode {1,2,3}
                          Mode: 1. Alphanumeric, 2. Numeric, 3. Alphabetic
    -s {cn,top}, --suffix {cn,top}
                          Suffix: 'cn' or 'top'
    -t {text,json}, --type {text,json}
                          Save type: 'text' or 'json'
    -w WHOIS, --whois WHOIS
                          Whois: whois, isp, none
  ```
  1. length: 长度，不含后缀
  2. mode: 模式， 1. 数字 + 字母, 2. 数字, 3. 字母
  3. suffix: 域名后缀， 'cn' 或者 'top'
  4. type: 保存类型， 'text' 或者 'json' （数据保存和发送通知的格式）
  5. whois: whois, isp，查询可用的方式。`留空`，则不查询，而是直接根据官网提供的数据判断；`whois`，则使用 `whois` 库查询；`isp` 则使用腾讯云的 API 查询。
  结果将会通过 PUSH 通知，和保存到本地文件。本地文件将会以 `后缀_日期.log` 的格式保存（`_next`则是明天及以后预删除的域名）。

  当前仅支持 [**Lark**](https://www.larksuite.com/) 以及 [**PushDeer**](http://www.pushdeer.com/)。依赖 [**ipush 库**](https://github.com/idevsig/pypush)，可自行添加其它渠道。
  需要设置环境变量
  ```bash

  export LARK_TOKEN=""
  export LARK_SECRET=""

  export PUSHDEER_TOKEN=""
  ```


  1. 使用 [**Rye**](https://rye-up.com/) 作为包管理工具

  1. 安装依赖包：
  ```bash

  rye sync
  ```
  2. 代码检测与格式化：
  ```bash

  rye run check

  rye run format
  ```
  3. 单元测试：
  ```bash

  rye run tests

  python -m pytest

  python -m pytest -s
  ```

  - https://git.jetsung.com/idev/predeldomain
  - https://framagit.org/idev/predeldomain
  - https://github.com/idevsig/predeldomain
  - https://gitcode.com/idev/predeldomain


pkgId: d1ab42a37ab81680b599c1b30e2fabca8de856be3755eefa46421cda83a9f391
name: python-predlp-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for predlp
url: https://pypi.org/project/predlp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-predlp-0.1.1-1.src.rpm
location_href: Packages/python-predlp-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align="left">
  <a href="https://pypi.org/pypi/predlp/" target="_blank"><img src="https://img.shields.io/pypi/v/predlp.svg" alt="pypi_versions"></a>
  <a href="https://pypi.org/pypi/predlp/" target="_blank"><img src="https://img.shields.io/badge/python-3.8%2B-blue" alt="py_versions"></a>
  <a href="https://github.com/justinj-evans/predlp/actions/workflows/tests.yaml/badge.svg" target="_blank"><img src="https://github.com/justinj-evans/predlp/actions/workflows/tests.yaml/badge.svg" alt="pytest"></a>
  </div>
  <br/>

  Prediction probabilities with a linear programming constraint during label assignment.


  Example label contraint imposed using the package *predlp* via this code:
  ```python
  from predlp.solver import pred_prob_lp


  class_names = ['label_a', 'label_b', 'label_c']
  label_counts = {'label_a': 2, 'label_b': 1, 'label_c': 1}
  pred_probs = [
      [0.6*, 0.3,  0.1],
      [0.2,  0.5*, 0.3],
      [0.8*, 0.1,  0.1],
      [0.5,  0.1,  0.4*]
  ]


  pred_after_lp = pred_prob_lp(class_names=class_names, label_counts= label_counts, pred_probs=pred_probs)


  pred_after_lp == ['label_a', 'label_b', 'label_a', 'label_c']
  ```


  - **class_names** (list):  The list should be in the order that matches the pred_prob array. So if class 0 is ‘linear’ and class 1 is ‘programming’, then class_names = ['linear', 'programming'].
  - **label_counts** (dict): A dictionary specifying the expected count for each label. The keys represent the class (N), and the values (K) constraints.
  - **pred_probs** (np.array): A 2D array of shape (N, K) containing the model predicted probabilities for each label. Each row corresponds to a class, corresponding to the class_name parameter, and the columns represent probabilities for classes {0, 1, ..., K-1}.


  - **pred_lp** (list): A list of predicted labels, with a total length of N. The list satisfies the constraints defined by label_counts and is optimized to maximize the total probability score across all predictions.


  Here are relevant papers to cite if you use this package:

  <details><summary><a href="https://www.statcan.gc.ca/en/conferences/symposium2024/program">Life in the FastText Lane: Harnessing Linear Programming Constrained Machine Learning for Classifications Revision</a> (<b>click to show bibtex</b>) </summary>

      @inproceedings{
          title={Life in the FastText Lane: Harnessing Linear Programming Constrained Machine Learning for Classifications Revision},
          author={Justin Evans, Laura Wile},
          conference={Statistics Canada's International Methodology Symposium: The Future of Official Statistics},
          year={2024}
      }

  </details>


  Contributions of any kind welcome. See the [development guide](DEVELOPMENT.md) to get started.


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


pkgId: 941fd6309257ec8640e3c877eef4e22895137150b5daa08aba5a83d53491b444
name: python-pref-voting-help
arch: noarch
version: 1.14.20
epoch: 0
release: 1
summary: Development documents and examples for pref-voting
url: https://github.com/voting-tools/pref_voting
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pref-voting-1.14.20-1.src.rpm
location_href: Packages/python-pref-voting-help-1.14.20-1.noarch.rpm
checksum_type: sha256
description:
  > [!NOTE]
  > - [**Documentation**](https://pref-voting.readthedocs.io/)
  > - [**Installation**](https://pref-voting.readthedocs.io/en/latest/installation.html)
  > - [**Example Notebooks**](https://github.com/voting-tools/pref_voting/tree/main/examples)
  > - [**Example Elections**](https://github.com/voting-tools/election-analysis)
  > - [**► pref_voting web app**](https://pref.tools/pref_voting/)
  See the [COMSOC community page](https://comsoc-community.org/tools) for an overview of other software tools related to Computational Social Choice.

  The package can be installed using the ``pip3`` package manager:
  ```bash
  pip3 install pref_voting
  ```
  **Notes**:
  * Since the package uses Numba, refer to the [Numba documentation for the latest supported Python version](https://numba.readthedocs.io/en/stable/user/installing.html#version-support-information).
  * If you have both Python 2 and Python 3 installed on your system, make sure to use ``pip3`` instead of pip to install packages for Python 3. Alternatively, you can use ``python3 -m pip`` to ensure you're using the correct version of pip. If you have modified your system's defaults or soft links, adjust accordingly.
  See the [installation guide](https://pref-voting.readthedocs.io/en/latest/installation.html) for more detailed instructions.

  A profile (of linear orders over the candidates) is created by initializing a `Profile` class object.  Simply provide a list of rankings (each ranking is a tuple of numbers) and a list giving the number of voters with each ranking:
  ```python
  from pref_voting.profiles import Profile
  rankings = [
      (0, 1, 2, 3), # candidate 0 is ranked first, candidate 1 is ranked second, candidate 2 is ranked 3rd, and candidate 3 is ranked last.
      (2, 3, 1, 0),
      (3, 1, 2, 0),
      (1, 2, 0, 3),
      (1, 3, 2, 0)]
  rcounts = [5, 3, 2, 4, 3] # 5 voters submitted the first ranking (0, 1, 2, 3), 3 voters submitted the second ranking, and so on.
  prof = Profile(rankings, rcounts=rcounts)
  prof.display() # display the profile
  ```
  The function `generate_profile` is used to generate a profile for a given number of candidates and voters:
  ```python
  from pref_voting.generate_profiles import generate_profile

  prof = generate_profile(3, 4) # prof is a Profile object with 3 candidates and 4 voters

  prof = generate_profile(3, 4, probmod = "IAC") # prof is a Profile object with 3 candidates and 4 voters
  ```
  The `Profile` class has a number of methods that can be used to analyze the profile. For example, to determine the margin of victory between two candidates, the plurality scores, the Copeland scores, the Borda scores, the Condorcet winner, the weak Condorcet winner, and the Condorcet loser, and whether the profile is uniquely weighted, use the following code:
  ```python
  prof = Profile([
      [2, 1, 0, 3],
      [3, 2, 0, 1],
      [3, 1, 0, 2]],
      rcounts=[2, 2, 3])
  prof.display()
  print(f"The margin of 1 over 3 is {prof.margin(1, 3)}")
  print(f"The Plurality scores are {prof.plurality_scores()}")
  print(f"The Copeland scores are {prof.copeland_scores()}")
  print(f"The Borda scores are {prof.borda_scores()}")
  print(f"The Condorcet winner is {prof.condorcet_winner()}")
  print(f"The weak Condorcet winner is {prof.weak_condorcet_winner()}")
  print(f"The Condorcet loser is {prof.condorcet_loser()}")
  print(f"The profile is uniquely weighted: {prof.is_uniquely_weighted()}")
  ```
  To use one of the many voting methods, import the function from `pref_voting.voting_methods` and apply it to the profile:
  ```python
  from pref_voting.generate_profiles import generate_profile
  from pref_voting.voting_methods import *
  prof = generate_profile(3, 4) # create a profile with 3 candidates and 4 voters
  split_cycle(prof) # returns the sorted list of winning candidates
  split_cycle.display(prof) # displays the winning candidates
  ```
  Additional notebooks that demonstrate how to use the package can be found in the [examples directory](https://github.com/voting-tools/pref_voting/tree/main/examples)
  Some interesting political elections are analyzed using pref_voting in the [election-analysis repository](https://github.com/voting-tools/election-analysis).
  Consult the documentation [https://pref-voting.readthedocs.io](https://pref-voting.readthedocs.io) for a complete overview of the package.

  To ensure that the package is working correctly, you can run the test suite using [pytest](https://docs.pytest.org/en/stable/). The test files are located in the `tests` directory. Follow the instructions below based on your setup.

  - **Python 3.9 or higher**: Ensure you have a compatible version of Python installed.
  - **`pytest`**: Install `pytest` if it's not already installed.

  If you are using **Poetry** to manage your dependencies, run the tests with:
  ```bash
  poetry run pytest
  ```
  From the command line, run:
  ```bash
  pytest
  ```
  For more detailed output, add the -v or --verbose flag:
  ```bash
  pytest -v
  ```

  If you would like to contribute to the project, please see the [contributing guidelines](CONTRIBUTING.md).

  Feel free to [send an email](https://pacuit.org/) if you have questions about the project.

  [MIT](https://github.com/voting-tools/pref_voting/blob/main/LICENSE.txt)


pkgId: 450f300bc0aa8709f40200998368ea4751ad42488973caa839cf993532ee78d3
name: python-prefect-client-help
arch: noarch
version: 3.1.7
epoch: 0
release: 1
summary: Development documents and examples for prefect-client
url: https://www.prefect.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prefect-client-3.1.7-1.src.rpm
location_href: Packages/python-prefect-client-help-3.1.7-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://github.com/PrefectHQ/prefect/assets/3407835/c654cbc6-63e8-4ada-a92a-efd2f8f24b85" width=1000></p>

  <p align="center">
      <a href="https://pypi.python.org/pypi/prefect-client/" alt="PyPI version">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/prefect-client?color=0052FF&labelColor=090422"></a>
      <a href="https://github.com/prefecthq/prefect/" alt="Stars">
          <img src="https://img.shields.io/github/stars/prefecthq/prefect?color=0052FF&labelColor=090422" /></a>
      <a href="https://pepy.tech/badge/prefect-client/" alt="Downloads">
          <img src="https://img.shields.io/pypi/dm/prefect-client?color=0052FF&labelColor=090422" /></a>
      <a href="https://github.com/prefecthq/prefect/pulse" alt="Activity">
          <img src="https://img.shields.io/github/commit-activity/m/prefecthq/prefect?color=0052FF&labelColor=090422" /></a>
      <br>
      <a href="https://prefect.io/slack" alt="Slack">
          <img src="https://img.shields.io/badge/slack-join_community-red.svg?color=0052FF&labelColor=090422&logo=slack" /></a>
      <a href="https://www.youtube.com/c/PrefectIO/" alt="YouTube">
          <img src="https://img.shields.io/badge/youtube-watch_videos-red.svg?color=0052FF&labelColor=090422&logo=youtube" /></a>
  </p>



  The `prefect-client` package is a minimal-installation of `prefect` which is designed for interacting with Prefect Cloud
  or remote any `prefect` server. It sheds some functionality and dependencies in exchange for a smaller installation size,
  making it ideal for use in lightweight or ephemeral environments. These characteristics make it ideal for use in lambdas
  or other resource-constrained environments.




  `prefect-client` shares the same installation requirements as prefect. To install, make sure you are on Python 3.9 or
  later and run the following command:

  ```bash
  pip install prefect-client
  ```

  Next, ensure that your `prefect-client` has access to a remote `prefect` server by exporting the `PREFECT_API_KEY`
  (if using Prefect Cloud) and `PREFECT_API_URL` environment variables. Once those are set, use the package in your code as
  you would normally use `prefect`!


  For example, to remotely trigger a run a deployment:

  ```python
  from prefect.deployments import run_deployment


  def my_lambda(event):
      ...
      run_deployment(
          name="my-flow/my-deployment",
          parameters={"foo": "bar"},
          timeout=0,
      )

  my_lambda({})
  ```

  To emit events in an event driven system:

  ```python
  from prefect.events import emit_event


  def something_happened():
      emit_event("my-event", resource={"prefect.resource.id": "foo.bar"})

  something_happened()
  ```


  Or just interact with a `prefect` API:
  ```python
  from prefect.client.orchestration import get_client


  async def query_api():
      async with get_client() as client:
          limits = await client.read_concurrency_limits(limit=10, offset=0)
          print(limits)


  query_api()
  ```



  By design, `prefect-client` omits all CLI and server components. This means that the CLI is not available for use
  and attempts to access server objects will fail. Furthermore, some classes, methods, and objects may be available
  for import in `prefect-client` but may not be "runnable" if they tap into server-oriented functionality. If you
  encounter such a limitation, feel free to [open an issue](https://github.com/PrefectHQ/prefect/issues/new/choose)
  describing the functionality you are interested in using and we will do our best to make it available.




  There's lots more you can do to orchestrate and observe your workflows with Prefect!
  Start with our [friendly tutorial](https://docs.prefect.io/tutorials) or explore the [core concepts of Prefect workflows](https://docs.prefect.io/concepts/).



  Prefect is made possible by the fastest growing community of thousands of friendly data engineers. Join us in building a new kind of workflow system.
  The [Prefect Slack community](https://prefect.io/slack) is a fantastic place to learn more about Prefect, ask questions, or get help with workflow design.
  All community forums, including code contributions, issue discussions, and Slack messages are subject to our [Code of Conduct](https://github.com/PrefectHQ/prefect/blob/main/CODE_OF_CONDUCT.md).



  See our [documentation on contributing to Prefect](https://docs.prefect.io/contributing/overview/).

  Thanks for being part of the mission to build a new kind of workflow system and, of course, **happy engineering!**


pkgId: 1a0d639e244b08b0c5ecf1e22f1c2f065b3e22ffc45ba159c1759c10c24c0047
name: python-prefect-help
arch: noarch
version: 3.1.6
epoch: 0
release: 1
summary: Development documents and examples for prefect
url: https://www.prefect.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prefect-3.1.6-1.src.rpm
location_href: Packages/python-prefect-help-3.1.6-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center"><img src="https://github.com/PrefectHQ/prefect/assets/3407835/c654cbc6-63e8-4ada-a92a-efd2f8f24b85" width=1000></p>

  <p align="center">
      <a href="https://pypi.python.org/pypi/prefect/" alt="PyPI version">
          <img alt="PyPI" src="https://img.shields.io/pypi/v/prefect?color=0052FF&labelColor=090422"></a>
      <a href="https://github.com/prefecthq/prefect/" alt="Stars">
          <img src="https://img.shields.io/github/stars/prefecthq/prefect?color=0052FF&labelColor=090422" /></a>
      <a href="https://pepy.tech/badge/prefect/" alt="Downloads">
          <img src="https://img.shields.io/pypi/dm/prefect?color=0052FF&labelColor=090422" /></a>
      <a href="https://github.com/prefecthq/prefect/pulse" alt="Activity">
          <img src="https://img.shields.io/github/commit-activity/m/prefecthq/prefect?color=0052FF&labelColor=090422" /></a>
      <br>
      <a href="https://prefect.io/slack" alt="Slack">
          <img src="https://img.shields.io/badge/slack-join_community-red.svg?color=0052FF&labelColor=090422&logo=slack" /></a>
      <a href="https://www.youtube.com/c/PrefectIO/" alt="YouTube">
          <img src="https://img.shields.io/badge/youtube-watch_videos-red.svg?color=0052FF&labelColor=090422&logo=youtube" /></a>
  </p>



  Prefect is a workflow orchestration framework for building data pipelines in Python.
  It's the simplest way to elevate a script into a resilient production workflow.
  With Prefect, you can build resilient, dynamic data pipelines that react to the world around them and recover from unexpected changes.

  With just a few lines of code, data teams can confidently automate any data process with features such as scheduling, caching, retries, and event-based automations.

  Workflow activity is tracked and can be monitored with a self-hosted [Prefect server](https://docs.prefect.io/latest/manage/self-host/?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none) instance or managed [Prefect Cloud](https://www.prefect.io/cloud-vs-oss?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none) dashboard.



  Prefect requires Python 3.9 or later. To [install the latest or upgrade to the latest version of Prefect](https://docs.prefect.io/get-started/install), run the following command:

  ```bash
  pip install -U prefect
  ```

  Then create and run a Python file that uses Prefect `flow` and `task` decorators to orchestrate and observe your workflow - in this case, a simple script that fetches the number of GitHub stars from a repository:

  ```python
  from prefect import flow, task
  from typing import List
  import httpx


  @task(log_prints=True)
  def get_stars(repo: str):
      url = f"https://api.github.com/repos/{repo}"
      count = httpx.get(url).json()["stargazers_count"]
      print(f"{repo} has {count} stars!")


  @flow(name="GitHub Stars")
  def github_stars(repos: List[str]):
      for repo in repos:
          get_stars(repo)



  if __name__=="__main__":
      github_stars(["PrefectHQ/Prefect"])
  ```

  Fire up the Prefect UI to see what happened:

  ```bash
  prefect server start
  ```

  To run your workflow on a schedule, turn it into a deployment and schedule it to run every minute by changing the last line of your script to the following:

  ```python
  if __name__ == "__main__":
      github_stars.serve(
          name="first-deployment",
          cron="* * * * *",
          parameters={"repos": ["PrefectHQ/prefect"]}
      )
  ```

  You now have a server running locally that is looking for scheduled deployments!
  Additionally you can run your workflow manually from the UI or CLI. You can even run deployments in response to [events](https://docs.prefect.io/latest/automate/?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none).



  Prefect Cloud provides workflow orchestration for the modern data enterprise. By automating over 200 million data tasks monthly, Prefect empowers diverse organizations — from Fortune 50 leaders such as Progressive Insurance to innovative disruptors such as Cash App — to increase engineering productivity, reduce pipeline errors, and cut data workflow compute costs.

  Read more about Prefect Cloud [here](https://www.prefect.io/cloud-vs-oss?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none) or sign up to [try it for yourself](https://app.prefect.cloud?utm_source=oss&utm_medium=oss&utm_campaign=oss_gh_repo&utm_term=none&utm_content=none).



  If your use case is geared towards communicating with Prefect Cloud or a remote Prefect server, check out our
  [prefect-client](https://pypi.org/project/prefect-client/). It is a lighter-weight option for accessing client-side functionality in the Prefect SDK and is ideal for use in ephemeral execution environments.



  - Check out the [Docs](https://docs.prefect.io/).
  - Join the [Prefect Slack community](https://prefect.io/slack).
  - Learn how to [contribute to Prefect](https://docs.prefect.io/contribute/).


pkgId: 215940bdf9da03b1c55e592dbc3aed2897cce999e7dd7ff1d94aaf123a334af6
name: python-prefig-help
arch: noarch
version: 0.2.10
epoch: 0
release: 1
summary: Development documents and examples for prefig
url: https://prefigure.org
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prefig-0.2.10-1.src.rpm
location_href: Packages/python-prefig-help-0.2.10-1.noarch.rpm
checksum_type: sha256
description:
  PreFigure is a Python package for authoring mathematical diagrams.  Following the [PreTeXt](https://pretextbook.org/) paradigm, an author writes an XML description of a diagram that PreFigure converts into an image file suitable for including in a text document.  By default, PreFigure will create an SVG image that can be included in, say, an HTML document. However, PreFigure prioritizes the creation of accessible diagrams so that annotations can be added that enable a screen reader to easily navigate the diagram.  Tactile diagrams can also be created from the same XML source.

  PreFigure diagrams can now be authored inside a PreTeXt document.  More information, including detailed documentation, is available from the [PreFigure homepage](https://prefigure.org).



  You may author and compile PreFigure diagrams in either of two environments:

  1. PreFigure is available in a [GitHub Codespace](https://github.com/davidaustinm/prefigure-codespace).  This is a free, cloud-based platform that takes care of all the installation details and creates a fully configured working environment.  Follow the instructions on that page to create your codespace and then get started authoring diagrams.
  2. PreFigure may be installed locally as a Python package following the instructions in the **Local Installation** section below.



  PreFigure may be installed locally as a Python package in the usual way using `pip`.  However, there are a few additional details that require your attention.

  1. PreFigure assumes Python version 3.8.5 or higher.  You may check your local Python version with one of the two commands below

      ```
      python -V
      ```

      ```
      python3 -V
      ```

  2. You are encouraged to install `liblouis`, which enables the creation of non-mathematical braille labels in tactile diagrams.  PreFigure can still create diagrams without this package installed though you will see a non-fatal warning message when you compile a tactile diagram and any requested labels will not appear in the diagram.

      On a linux machine, use your package manager to install `python3-louis`.  Ubuntu users can use

      ```
      apt get python3-louis
      ```

      while on a Mac, you will want

      ```
      brew install liblouis
      ```

      Alternatively, you can install `liblouis` following [these instructions](https://liblouis.io/downloads/).

      Within a Python interpreter, you should then be able to `import louis` without an error.

  3. You are encouraged to install an [additional library](https://pycairo.readthedocs.io/en/latest/getting_started.html) to support the `pycairo` package.  This may not be essential for your local machine, but there is no harm in performing this step.  The `pycairo` package is needed to produce labels having plain text (rather than mathematics).  If you are not able to install `pycairo`, you will still be able to build PreFigure diagrams, but any labels with plain text will not appear.

  4. You are now ready to install PreFigure with

      ```
      pip install prefig[pycairo]
      ```

      If this fails, it is due to the `pycairo` dependency so you can instead install PreFigure without `pycairo` using

      ```
      pip install prefig
      ```

  5. You will need a local installation of `node` and `npm` to produce mathematical labels.  (The `node` installation includes `npm`.)  This is a simple process, but you should search to find the instructions for your operating system.  On a Ubuntu machine, it's as easy as

      ```
      apt install nodejs
      ```

  6. For creating tactile graphics to be embossed, you are encouraged to install `rsvg-convert`, which PreFigure uses to convert SVGs into PDFs.  On Ubuntu, you can say

      ```
      apt install librsvg2-bin
      ```

      while Mac users can use

      ```
      brew install librsvg
      ```

  7. Once installed, the command `prefig init` will install MathJax and the Braille29 font needed to tactile diagrams.  If you do not perform this step, MathJax will be automatically installed when you first build a diagram with mathematical labels.



  Once PreFigure is installed, help is available with

  ```
  prefig --help
  ```

  or, say,

  ```
  prefig build --help
  ```

  Details of a requested operation may be obtained using the `-v` and `-vv` flags.  For instance,
  ```
  prefig -vv build foo.xml
  ```
  will print debugging information to the terminal.

  Here is a summary of PreFigure commands.
  ```

  1. PreFigure source files can be compiled into SVG images using one of the following two commands, with the first command creating a regular SVG file while the second produces a tactile version of    the diagram.

      ```
      prefig build foo.xml
      ```

      ```
      prefig build -f tactile foo.xml
      ```

      By default, the output appears in `output/foo.svg` and `output/foo.xml`, where the XML output   contains the annotations used by a screen reader.  If PreFigure is called from within a PreTeXt document, then the annotations will appear in `foo-annotations.xml`.

  2. To view the resulting diagram, use either

      ```
      prefig view foo
      ```

      ```
      prefig view -i foo
      ```

      The first command will open the diagram in a browser using the `diagcess` library, which enables a reader to explore the annotations interactively.  The second command ignores the annotations and simply opens the SVG diagram in a browser.

  3. Once a diagram has been compiled, you may create a PDF using

      ```
      prefig pdf foo
      ```

      Adding the `-b` switch will build the diagram from PreFigure source before the PDF is formed.

  4. Similarly,

      ```
      prefig png foo
      ```

      creates a PNG.  Add the `-b` switch to `build` the diagram first.

  5. To validate PreFigure source against the PreFigure XML schema, use

      ```
      prefig validate foo.xml
      ```



  You may wish to perform the following steps to set up your authoring environment (these are automatically performed in a codespace):

  1. To initialize your local installation, use

      ```
      prefig init
      ```

      which will use `npm` to install some MathJax modules.  It will also install the Braille29 font needed for tactile diagrams.  If the MathJax modules are not installed when you attempt to build a diagram, PreFigure will attempt to install them when you build your first diagram.

  2. You may install a set of examples for exploration in the current directory using

      ```
      prefig examples
      ```

  3. You may initialize a new PreFigure project in the current directory using


      ```
      prefig new
      ```

      This copies the `diagcess` tools and a default publication file into the current directory and creates a `source` directory in which to author diagrams.



  [Volker Sorge](https://www.birmingham.ac.uk/staff/profiles/computer-science/academic-staff/sorge-volker) has provided crucial support for this project as well as access to the diagcess library for navigating an image with a screen reader.

  The MathJax module `mj-sre-page.js` included with this distribution was created by [Davide Cervone](https://www.math.union.edu/~dpvc/) and Volker Sorge.

  Thanks also to the PreTeXt community, and especially [Rob Beezer](http://buzzard.ups.edu/), for support and inspiration.  This project was developed with support from the [UTMOST Project](https://utmost.aimath.org/)



  PreFigure is distributed with a GPL license.


pkgId: bc2e8bdc2179fa91a4121fb27c07c849f0547fd8dedb8a2ba414d6528dc05ad7
name: python-prefpicker-help
arch: noarch
version: 2.2.0
epoch: 0
release: 1
summary: Development documents and examples for prefpicker
url: https://github.com/MozillaSecurity/prefpicker
rpm_license: MPL 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prefpicker-2.2.0-1.src.rpm
location_href: Packages/python-prefpicker-help-2.2.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Task Status](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/prefpicker/master/badge.svg)](https://community-tc.services.mozilla.com/api/github/v1/repository/MozillaSecurity/prefpicker/master/latest)
  [![codecov](https://codecov.io/gh/MozillaSecurity/prefpicker/branch/master/graph/badge.svg)](https://codecov.io/gh/MozillaSecurity/prefpicker)
  [![Matrix](https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.chunk[%3F(%40.canonical_alias%3D%3D%22%23fuzzing%3Amozilla.org%22)].num_joined_members&suffix=%20users&url=https%3A%2F%2Fmozilla.modular.im%2F_matrix%2Fclient%2Fr0%2FpublicRooms&style=flat&logo=matrix)](https://riot.im/app/#/room/#fuzzing:mozilla.org)
  [![PyPI](https://img.shields.io/pypi/v/prefpicker)](https://pypi.org/project/prefpicker)
  Manage & generate prefs.js files for use when testing Firefox. This tool is intended to simplify the use and tracking of prefs used by
  our fuzzing tools. The template files can be modified to allow the creation of custom prefs.js files without
  the need to maintain a separate mostly duplicate version of a prefs file.


pkgId: 418b4eef2df80af2610debd5f28797f41193086dd8cac6edc7dc8d463372c601
name: python-prelude-cli-help
arch: noarch
version: 2.5.6
epoch: 0
release: 1
summary: Development documents and examples for prelude-cli
url: https://github.com/preludeorg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prelude-cli-2.5.6-1.src.rpm
location_href: Packages/python-prelude-cli-help-2.5.6-1.noarch.rpm
checksum_type: sha256
description:
  Interact with the full range of features in Prelude Detect, organized by:

  - IAM: manage your account
  - Build: write and maintain your collection of security tests
  - Detect: schedule security tests for your endpoints


  ```bash
  pip install prelude-cli
  prelude --help
  prelude --interactive
  ```



  https://docs.preludesecurity.com/docs/prelude-cli


pkgId: 62fef1f01c817d07079982720368a9b904db8f5bd5556e3ab6959ee16ee21d22
name: python-prelude-sdk-help
arch: noarch
version: 2.5.15
epoch: 0
release: 1
summary: Development documents and examples for prelude-sdk
url: https://github.com/preludeorg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prelude-sdk-2.5.15-1.src.rpm
location_href: Packages/python-prelude-sdk-help-2.5.15-1.noarch.rpm
checksum_type: sha256
description:
  Interact with the Prelude Service API via Python.

  > The prelude-cli utility wraps around this SDK to provide a rich command line experience.

  Install this package to write your own tooling that works with Build or Detect functionality.

  - IAM: manage your account
  - Build: write and maintain your collection of security tests
  - Detect: schedule security tests for your endpoints



  ```bash
  pip install prelude-sdk
  ```



  TBD



  To test the Python SDK and Probes, run the following commands from the python/sdk/ directory:

  ```bash
  pip install -r tests/requirements.txt
  pytest tests --api https://api.preludesecurity.com --email <EMAIL>
  ```


pkgId: 9051919010dbea20849af2ec80fb0e16224983162cbdf09f7b1c80ae86b74333
name: python-premise-help
arch: noarch
version: 2.2.4
epoch: 0
release: 1
summary: Development documents and examples for premise
url: https://pypi.org/project/premise/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-premise-2.2.4-1.src.rpm
location_href: Packages/python-premise-help-2.2.4-1.noarch.rpm
checksum_type: sha256
description:
  The tool currently supports the following IAMs:
  | Model    | Description |
  |----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | REMIND   | REMIND (Regionalized Model of Investment and Development) is an integrated assessment model that combines macroeconomic growth, energy system, and climate policy analysis. It is designed to analyze long-term energy transition pathways, accounting for technological, economic, and environmental factors. REMIND simulates how regions invest in different technologies and energy resources to balance economic growth and climate targets, while considering factors like energy efficiency, emissions, and resource availability. The model is particularly strong in its detailed representation of energy markets and macroeconomic interactions across regions, making it valuable for global climate policy assessments. |
  | IMAGE    | IMAGE (Integrated Model to Assess the Global Environment) is a comprehensive IAM developed to explore the interactions between human development, energy consumption, and environmental systems over the long term. It focuses on assessing how land use, food systems, energy systems, and climate change interact under different policy scenarios. The model integrates biophysical processes, such as land-use change and greenhouse gas emissions, with socio-economic drivers like population growth and economic development. IMAGE is commonly used for analyzing sustainable development strategies, climate impacts, biodiversity loss, and exploring mitigation and adaptation options. |
  | TIAM-UCL | TIAM-UCL (TIMES Integrated Assessment Model by University College London) is a global energy system model based on the TIMES (The Integrated MARKAL-EFOM System) framework, developed to evaluate long-term decarbonization pathways for global energy systems. It provides detailed insights into energy technology options, resource availability, and emission reduction strategies under various climate policy scenarios. The model focuses on the trade-offs and synergies between energy security, economic costs, and environmental outcomes. TIAM-UCL is frequently used to analyze scenarios consistent with the Paris Agreement and examine technological innovation's role in mitigating climate change globally. |


pkgId: 072e375d1f6c5c4a1f18b9ece313b18d49f83461ed8089b35885c4622ae84fc2
name: python-premium-bond-checker-help
arch: noarch
version: 0.2.2
epoch: 0
release: 1
summary: Development documents and examples for premium-bond-checker
url: https://pypi.org/project/premium-bond-checker/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-premium-bond-checker-0.2.2-1.src.rpm
location_href: Packages/python-premium-bond-checker-help-0.2.2-1.noarch.rpm
checksum_type: sha256
description:
  Simple premium bond checker library that is built against [Nsandi](https://www.nsandi.com/).



  ```python
  from premium_bond_checker.client import Client

  client = Client()
  result = client.check('your bond number')
  print(f'Winning: {result.has_won()}')
  ```



  MIT


pkgId: 561cdbd1f8a6de29cc6003aad28784ef5f7158a3d6d8287b72cd303af54d9bea
name: python-prescyent-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for prescyent
url: https://pypi.org/project/prescyent/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prescyent-0.6.1-1.src.rpm
location_href: Packages/python-prescyent-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      <img alt="PreScyent" src="https://raw.githubusercontent.com/hucebot/prescyent/main/assets/banner.png" width="50%">
  </p>

  <h2 style="text-align: center;">
  Data-driven trajectory forecasting library built in python
  </h2>

  <p align="center">
      <img alt="Trajectory visualization" src="https://raw.githubusercontent.com/hucebot/prescyent/main/assets/render_andy_dataset_positions_with_siMLPe_predictions_at_500ms.gif" width="40%">
  </p>



  Find the user documentation here: https://hucebot.github.io/prescyent/

  PreScyent is a trajectory forecasting library, built upon pytorch_lightning
  It comes with datasets such as:
  - [AndyData-lab-onePerson](https://zenodo.org/records/3254403#.Y_9fwBeZMVk)
  - [AndyData-lab-onePersonTeleoperatingICub](https://zenodo.org/record/5913573)
  - [Human3.6M](http://vision.imar.ro/human3.6m/description.php)
  - And synthetics dataset to test simple properties of our predictors.

  It come also with baselines to run over theses datasets, referred in the code as Predictors, such as:
  - [SiMLPe](https://arxiv.org/abs/2207.01567) a MultiLayer Perceptron (MLP) with Discrete Cosine Transform (DCT), shown as a strong baseline achieving SOTA results against bigger and more complicated models.
  - [Seq2Seq](https://arxiv.org/abs/1409.3215), an architecture mapping an input sequence to an output sequence, that originated from NLP and grew in popularity for time series predictions. Here we implemented an RNN Encoder and RNN Decoder.
  - Probabilistic Movement Primitives (ProMPs), an approach commonly used in robotics to model movements by learning from demonstrations and generating smooth, adaptable trajectories under uncertainty.
  - Some simple ML Baselines such as a Fully Connected MultiLayer Perceptron and an auto-regressive predictor with LSTMs.
  - Non machine learning baselines, maintaining the velocity or positions of the inputs, or simply delaying it.




  - With **H** our history size, the number of observed frames​
  - With **F** our future size, the number of frames we want to predict​
  - With **X** the points and features used as input​
  - With **Y** the points and features produced as output​
  We define **P** our predictor such as, at a given time step **T** we have:​



  $P(X_{T-H}, \dots, X_T) = Y_{T+1}, \dots, Y_{T+F}$




  You can install released versions of the project from [PyPi](https://pypi.org/project/prescyent/). install using pip from source (you may want to be in a [virtualenv](https://python-guide-pt-br.readthedocs.io/fr/latest/dev/virtualenvs.html) beforehand):
  ```bash
  pip install prescyent
  ```

  You can build an image docker from the Dockerfile at the source of the repository.
  Please refer to [docker documentation](https://docs.docker.com) for build command and options.
  The Dockerfile is designed to be run interactively.


  If you want to setup a dev environment, you should clone the repository:

  ```bash
  git clone git@github.com:hucebot/prescyent.git
  cd prescyent
  ```
  Then install using pip from source (you may want to be in a [virtualenv](https://python-guide-pt-br.readthedocs.io/fr/latest/dev/virtualenvs.html) beforehand):
  For dev install (recommended if you intent to add new classes to the lib) use:
  ```bash
  pip install -e .
  ```


  Each dataset is composed a list Trajectories, split as train, test and val.
  In this lib, we call "Trajectory" a sequence in time split in F frames, tracking P points above D dimensions.
  It is represented with a batched tensor of shape:
  `(B, F, P, D)`.
  Note that unbatched tensors are also allowed for inference.
  For each Trajectory we describe its tensor with Features, a list of Feature describing what are the dimensions tracked for each point at each frame. Theses allows conversions to occur in background or as preprocessing, as well as using some distance specific losses and metrics (e.g. Euclidean distance for Coordinates and geodesic distance for Rotations)
  Alongside each trajectory tensor, some dataset provide some additional "context" (images, center of mass, velocities...), that is represented inside the library as a dictionary of tensors.


  We use HDF5 file format to load a dataset internally. Please get the original data and pre process them using the scripts in `/datapreprocessing` to match the library's format.
  Then when creating an instance of a Dataset, make sure you pass the path to the newly generated hdf5 file to the dataset's config attribute `hdf5_path`.
  The hdf5 versions of theses datasets have also been uploaded here: https://gitlab.inria.fr/hucebot/datasets/



  Download AndyData-lab-prescientTeleopICub's data [here](https://zenodo.org/record/5913573/)
  and unzip it, it should be following this structure:
  ```bash
  ├── AndyData-lab-prescientTeleopICub
  │   └── datasetMultipleTasks
  │       └── AndyData-lab-prescientTeleopICub
  │           ├── datasetGoals
  │           │   ├── 1.csv
  │           │   ├── 2.csv
  │           │   ├── 3.csv
  │           │   ├── ...
  │           ├── datasetObstacles
  │           │   ├── 1.csv
  │           │   ├── 2.csv
  │           │   ├── 3.csv
  │           │   ├── ...
  │           ├── datasetMultipleTasks
  │           │   ├── BottleBox
  │           │   │   ├── 1.csv
  │           │   │   ├── 2.csv
  │           │   │   ├── 3.csv
  │           │   │   ├── ...
  │           │   ├── BottleTable
  │           │   │   ├── 1.csv
  │           │   │   ├── 2.csv
  │           │   │   ├── 3.csv
  │           │   │   ├── ...
  │           │   ├── ...

  ```
  Then run the script `dataset_preprocessing/teleopicubdataset_to_hdf5.py` to generate the dataset in the lib's format, with `--data_path` argument providing the path to the downloaded dataset, and the `--hdf5_path` argument giving the path and name of the generated hdf5 file (optional).
  For example something like:
  ```bash
  python dataset_preprocessing/teleopicubdataset_to_hdf5.py --data_path AndyData-lab-prescientTeleopICub/ --hdf5_path AndyData-lab-prescientTeleopICub.hdf5
  ```



  For [Human3.6M](http://vision.imar.ro/human3.6m/description.php) you need to download the zip [here](http://www.cs.stanford.edu/people/ashesh/h3.6m.zip) and prepare your data following this directory structure:
  ```bash
  └── h36m
  |   ├── S1
  |   ├── S5
  |   ├── S6
  |   ├── ...
  |   ├── S11
  ```
  Then run the script `dataset_preprocessing/h36mdataset_to_hdf5.py` to generate the dataset in the lib's format, with `--data_path` argument providing the path to the downloaded dataset, and the `--hdf5_path` argument giving the path and name of the generated hdf5 file (optional).
  For example something like:
  ```bash
  python dataset_preprocessing/h36mdataset_to_hdf5.py --data_path h36m/ --hdf5_path h36m.hdf5
  ```



  For [AndyDataset](https://andydataset.loria.fr/) you need to download the zip [here](https://zenodo.org/records/3254403/files/xens_mnvx.zip?download=1) and prepare your data following this directory structure:
  ```bash
  └── AndyData-lab-onePerson
  |   └── xsens_mnvx
  |       ├── Participant_541
  |       ├── Participant_909
  |       ├── Participant_2193
  |       ├── ...
  |       ├── Participant_9875
  ```
  Then run the script `dataset_preprocessing/andydataset_to_hdf5.py` to generate the dataset in the lib's format, with `--data_path` argument providing the path to the downloaded dataset, and the `--hdf5_path` argument giving the path and name of the generated hdf5 file (optional).
  For example something like:
  ```bash
  python dataset_preprocessing/andydataset_to_hdf5.py --data_path AndyData-lab-onePerson/ --hdf5_path AndyData-lab-onePerson.hdf5
  ```



  The trajectory prediction methods are organized as Predictor classes.
  For example, the MlpPredictor class is the implementation of a configurable MLP as a baseline for the task of Trajectory prediction.
  Relying on the PytorchLightning Framework, it instantiates or load an existing torch Module, with a generic predictor wrapper for saving, loading, iterations over a trajectory and logging.
  Feel free to add some new predictor implementations following the example of this simple class, inheriting at least from the BasePredictor class.


  We also provide a set of functions to run evaluations and plot some trajectories.
  Runners take a list of predictors, with a list of trajectories and provide an evaluation summary on the following metrics:
  - Average Displacement Error (ADE): Mean distance over all points (feature wise) over the whole prediction.
  - Final Displacement Error (FDE): Mean distance over all points (feature wise) over the last frame predicted.
  - Mean Per Joint Position Error (MPJPE): Mean distance over all points (feature wise) given at each predicted frame.
  - Real Time Factor (RTF): Processing time (in seconds) / trajectory duration (in seconds).




  Please look into the `examples/` directory to find common usages of the library
  We use tensorboard for training logging, use `tensorboard --logdir {log_path}` to view the training and testing infos (default log_path is `data/models/`)

  For example to run the script for mlp training on teleopIcub dataset use this in the environment where prescyent is installed:
  ```bash
  python examples/mlp_icub_train.py
  ```
  If you want to start a training from a config file (as examples/configs/mlp_teleopicub_with_center_of_mass_context.json), use the following:
  ```bash
  python examples/train_from_config.py examples/configs/mlp_teleopicub_with_center_of_mass_context.json
  ```

  The script `start_multiple_trainings.py` is an example of how to generate variations of configuration files and running them using methods from `train_from_config.py`

  Also for evaluation purposes, you can see an example running tests and plots using AutoPredictor and AutoDataset in `load_and_plot_predictors.py`



  Predictors inherit from the BasePredictor class, which define interfaces and core methods to keep consistency between each new implementation.
  Each Predictor defines its PredictorConfig with arguments that will be passed on to the core class, again with a BaseConfig with common attributes that needs to be defined.
  If you want to implement a new ML predictor using PyTorch follow the structure of one of our simple predictors such as MlpPredictor and its 3 files where:
  - in `module.py` you create your torch.nn.Module and forward method as you would usually do, you may want to inherit from BaseTorchModule instead of just torch.nn.Module and decorate your forward method with `@self_auto_batch` and `@BaseTorchModule.deriv_tensor` to benefit from some of the lib's features.
  - in `config.py` create your [pydantic BaseModel](https://docs.pydantic.dev/latest/) inheriting from `ModuleConfig` to ensure your predictor's config has all the needed variables, and add any new values you want as variables in your model's architecture.
  - finally `predictor.py` simply connects the above two by declaring both classes as class attributes for this specific predictor. Most of the magic happens in the parent classes using pytorch_lightning with your torch module.
  If you want your predictor to be able to be loaded by AutoPredictor, you must add it to the PREDICTOR_MAP and PREDICTOR_LIST in `prescyent.predictor.__init__.py`.

  In the same way you can extend the dataset module with a new Dataset inheriting from TrajectoriesDataset with its own DatasetConfig. Again taking examples on one of our implementation as TeleopIcubDataset, you must:
  - in `dataset.py`, inherit from the TrajectoriesDataset class and implement a `prepare_data` method where you must init `self.trajectories` with a `Trajectories` instance built from your data/files.
  - in `config.py` create your [pydantic BaseModel](https://docs.pydantic.dev/latest/) inheriting from `TrajectoriesDatasetConfig` to ensure you have all variables for the dataset processes, and add any new value you want as variables in your dataset's architecture.
  - optionally use `metadata.py` as we did to store some constant describing your dataset.
  All the logic creating the datasamples and dataloaders is handled in the parent class as long as self.trajectories is defined and the config is valid. If you want your dataset to be able to be loaded by AutoDataset, you must add it to the DATASET_MAP and DATASET_LIST in `prescyent.dataset.__init__.py`.
  If you simply want to test a Predictor over some data, you can create an instance of CustomDataset. As long as you turned your lists of episodes into Trajectories, the CustomDataset allows you to split them into training samples using a generic DatasetConfig and use all the functionalities of the library as usual (except that a CustomDataset cannot be loaded using AutoDataset)...


  See [dedicated repository](https://github.com/hucebot/ros2_prescyent/tree/dev)


  After installing, you can run the test suite to make sure the installation is ok

  ```bash
  python -m unittest -v
  ```



  This repo use Github actions to run the test suite and linting at pushes and merge over the `dev` and `main` branches as continuous integration.
  If the integration workflow is successful and we are on the `main` branch, then we'll build the library and publish it to pypi.
  Please make sure that you updated the library's version `prescyent.__init__py:__version__` otherwise the deployment will fail.


  siMLPe
  > Wen Guo, Yuming Du, Xi Shen, Vincent Lepetit, Xavier Alameda-Pineda, et al.. Back to MLP: A Simple Baseline for Human Motion Prediction. WACV 2023 - IEEE Winter Conference on Applications of Computer Vision, Jan 2023, Waikoloa, United States. pp.1-11. ⟨hal-03906936⟩​

  AndyDataset
  > Maurice P., Malaisé A., Amiot C., Paris N., Richard G.J., Rochel O., Ivaldi S. « Human Movement and Ergonomics: an Industry-Oriented Dataset for Collaborative Robotics ». The International Journal of Robotics Reserach, Volume 38, Issue 14, Pages 1529-1537.

  TeleopIcub Dataset
  > Penco, L., Mouret, J., & Ivaldi, S. (2021, July 2). Prescient teleoperation of humanoid robots. arXiv.org. https://arxiv.org/abs/2107.01281

  H36M Dataset
  > Human3.6M: Large scale datasets and predictive methods for 3D human sensing in natural environments. (n.d.). IEEE Journals & Magazine | IEEE Xplore. https://ieeexplore.ieee.org/document/6682899

  On the Continuity of Rotation Representations in Neural Networks
  > Zhou, Y., Barnes, C., Lu, J., Yang, J., & Li, H. (2018, December 17). On the Continuity of Rotation Representations in Neural Networks. arXiv.org. https://arxiv.org/abs/1812.07035

  ProMPs
  > Paraschos, Alexandros & Daniel, Christian & Peters, Jan & Neumann, Gerhard. (2018). Using probabilistic movement primitives in robotics. Autonomous Robots. 42. 10.1007/s10514-017-9648-7. ```


pkgId: 6482d3db5c4ddd5467fbeebf31d5e46537e6477477ed15df73448e47bc0ee872
name: python-pressor-help
arch: noarch
version: 0.0.6
epoch: 0
release: 1
summary: Development documents and examples for pressor
url: https://gitee.com/maxbanana
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pressor-0.0.6-1.src.rpm
location_href: Packages/python-pressor-help-0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  从各种不同格式文件来源里提取出文本数据。pressor有压缩机的意思，希望本项目能成为数据压缩机。

  - html
  - epub
  - mobi
  - azw
  - azw3
  - docx



  ```python3
  from pressor import pressor

  file_path = 'your_html_path.epub'
  result = pressor(file_path)
  print(result)
  ```


  由于各个网站的网页结构不同，目前没有一个完美的提取正文的方案，本项目采用的方案也不适配所有网站，经过实测可以提取大多数网站。

  - 适配了一批热门网站，使用提前准备好的xpath进行解析，后续也会继续适配其他网站
  - 其他网站使用通用算法解析提取正文



  | 网站                            |        别名         |
  |:------------------------------|:-----------------:|
  | https://www.ifeng.com/        |       ifeng       |
  | https://www.sohu.com/         |       sohu        |
  | https://www.163.com/          |        163        |
  | https://www.sina.com.cn/      |       sina        |
  | https://www.qq.com/           |      new_qq       |
  | https://www.huxiu.com/        |       huxiu       |
  | https://baijiahao.baidu.com/  |  baijiahao_baidu  |
  | https://baike.baidu.com/      |    baike_baidu    |
  | https://zhuanlan.zhihu.com/   |  zhuanlan_zhihu   |


  - 对于html文件使用pressor提取
  ```python3

  from pressor import pressor
  file_path = 'your_html_path.html'

  result = pressor(file_path)
  print(result)



  url = 'https://you_web.com'
  result = pressor(file_path, url=url)
  print(result)
  ```
  - 对于已加载至内存的html数据使用pressor提取
  ```python3
  from pressor import html_data_to_text
  import requests

  url = ''
  headers = {}
  resp = requests.get(url, headers=headers)
  html_text = resp.text
  result = html_data_to_text(html_text, url=url)
  print(result)
  ```
  - 使用自定义xpath提取正文

  ```python3
  from pressor import get_text_from_whitelist
  html_text = open('xxx.html').read()
  true_xpath = {'title': 'xxxxx ', 'main_body': 'yyyyy'}
  result = get_text_from_whitelist(html_text, true_xpath=true_xpath)
  print(result)
  ```

  - 使用通用算法提取正文
  ```python3
  from pressor import get_text_from_main_body
  html_text = open('xxx.html').read()
  result = get_text_from_main_body(html_text)
  print(result)
  ```


pkgId: 1904ef58fd4ff712231a136bbb54349728d7c71586bc742cd32f392653197814
name: python-presudo-generate-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for presudo-generate
url: https://pypi.org/project/presudo-generate/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-presudo-generate-1.0.0-1.src.rpm
location_href: Packages/python-presudo-generate-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Automatic Pseudocode Generation**: Convert Python scripts into clear, step-by-step pseudocode.
  - **Customizable Output**: Adjust formatting and indentation to suit your style.
  - **Support for Core Python Constructs**: Handles loops, conditionals, functions, and more.


pkgId: 4bdc04f8caeee5f15fd841cf5014cf0a0ed84ceadf079a624b6e2d1c6c126af5
name: python-preswald-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for preswald
url: https://github.com/your-username/preswald
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-preswald-0.1.1-1.src.rpm
location_href: Packages/python-preswald-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  - **Connectors**: Pull data from files (CSV, JSON), APIs, databases (PostgreSQL, SQLite), or tools like Google Sheets.
  - **Scheduling**: Set up periodic ingestion tasks with built-in scheduling.
  - **Pluggable Architecture**: Add custom connectors for additional data sources.

  - **SQL and Python Transformations**: Write SQL scripts or Python-based transformations directly.
  - **Prebuilt Templates**: Templates for deduplication, aggregation, and data cleaning.
  - **Data Modeling**: Reusable data models to define relationships between raw and transformed data.

  - **Integrated Dashboards**: Create dashboards with KPIs, charts, and tables.
  - **Drag-and-Drop Editor**: Non-technical users can arrange visualizations effortlessly.
  - **Export Options**: Share dashboards via PDF or public links.

  - **One-Click Deployment**: Deploy to platforms like Vercel with minimal setup.
  - **Real-Time Previews**: Share live previews of your app during development.

  - **Execution Logs**: View pipeline success/failure statuses and debug logs.
  - **Data Lineage**: Track how data flows and transforms through your pipelines.

  - **Plugin System**: Add custom connectors, transformations, and visualizations.


pkgId: 1f9b385a32e9f4d55539b85e6a03e02d6543b3409250f1f8be39e5a1acdcf491
name: python-pretext-help
arch: noarch
version: 2.10.1
epoch: 0
release: 1
summary: Development documents and examples for pretext
url: https://pretextbook.org
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pretext-2.10.1-1.src.rpm
location_href: Packages/python-pretext-help-2.10.1-1.noarch.rpm
checksum_type: sha256
description:
  **Note.** The remainder of this documentation is intended only for those interested
  in contributing to the development of this project. Anyone who simply wishes to
  _use_ the PreTeXt-CLI can stop reading here.
  From the "Clone or Download" button on GitHub, copy the `REPO_URL` into the below
  command to clone the project.
  ```bash
  git clone [REPO_URL]
  cd pretext-cli
  ```

  Developers and contributors must install a
  version of Python that matching the requirements in `pyproject.toml`.

  <details>
  <summary><b>Optional</b>: use pyenv as a virtual environment</summary>
  The `pyenv` tool for Linux automates the process of running the correct
  version of Python when working on this project (even if you have
  other versions of Python installed on your system).
  -   https://github.com/pyenv/pyenv#installation
  Run the following, replacing `PYTHON_VERSION` with your desired version.
  ```
  pyenv install PYTHON_VERSION
  ```

  In windows, you can either use the bash shell and follow the directions above,
  or try [pyenv-win](https://github.com/pyenv-win/pyenv-win#installation). In
  the latter case, make sure to follow all the installation instructions, including
  the **Finish the installation**. Then proceed to follow the directions above to
  install a version of python matching `pyproject.toml`. Finally, you may then need
  to manually add that version of python to your path.
  </details>
  <br/>
  The first time you set up your development environment, you should follow these steps:
  1. Follow these instructions to install `poetry`.
      -   https://python-poetry.org/docs/#installation
          -   Note 2022/06/21: you may ignore "This installer is deprecated". See
              [python-poetry/poetry/issues/4128](https://github.com/python-poetry/poetry/issues/4128)
  2. Install dependencies into a virtual environment with this command.
      ```
      poetry install
      ```
  3. Fetch a copy of the core pretext library and bundle templates by running
      ```
      poetry run python scripts/fetch_core.py
      ```
  The last command above should also be run when returning to development after some time, since the core commit you develop against might have changed.
  Make sure you are in a `poetry shell` during development mode so that you
  execute the development version of `pretext-cli` rather than the system-installed
  version.
  ```
  pretext --version # returns system version
  poetry shell
  pretext --version # returns version being developed
  ```
  When inside a `poetry shell` you can navegate to other folders and run pretext commands.  Doing so will use the current development environment version of pretext.

  <details>
  <summary>Show instructions</summary>
  To add dependencies for the package, run
  ```
  poetry add DEPENDENCY-NAME
  ```
  If someone else has added a dependency:
  ```
  poetry install
  ```
  </details>

  See [docs/core_development.md](docs/core_development.md).

  All `.py` files are formatted with the [black](https://black.readthedocs.io/en/stable/)
  python formatter and checked by [flake8](https://flake8.pycqa.org/en/latest/).
  Proper formatting is enforced by checks in the Continuous Integration framework.
  Before you commit code, you should make sure it is formatted with `black` and
  passes `flake8` by running the following commands (on linux or mac)
  from the _root_ project folder (most likely `pretext-cli`).
  ```
  poetry run black .
  poetry run flake8
  ```

  Sets are contained in `tests/`. To run all tests:
  ```
  poetry run pytest
  ```
  To run a specific test, say `test_name` inside `test_file.py`:
  ```
  poetry run pytest -k name
  ```
  Tests are automatically run by GitHub Actions when pushing to identify
  regressions.

  To check if a successful build is possible:
  ```
  poetry run python scripts/build_package.py
  ```
  To publish a new alpha release, first add/commit any changes. Then
  the following handles bumping versions, publishing to PyPI,
  and associated Git management.
  ```
  poetry run python scripts/release_alpha.py
  ```
  Publishing a stable release is similar:
  ```
  poetry run python scripts/release_stable.py # patch +0.+0.+1
  poetry run python scripts/release_stable.py minor # +0.+1.0
  poetry run python scripts/release_stable.py major # +1.0.0


pkgId: debd2d3ecd919ec1ec8d33a511d8f70be90298238e9954159050c5b2a821d19d
name: python-primalbedtools-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for primalbedtools
url: https://github.com/ChrisgKent/primalbedtools
rpm_license: MPL-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-primalbedtools-0.6.2-1.src.rpm
location_href: Packages/python-primalbedtools-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  PrimalBedTools is a library for manipulating and processing BED files, particularly focused on primer-related operations. It provides several functions for common BED file operations including coordinate remapping, sorting, updating, and amplicon generation.

  Functions are wrapped in a CLI for ease of use.



  ```bash
  pip install primalbedtools
  ```



  ```bash
  primalbedtools <command> [options]
  ```




  Remaps coordinates in a BED file using a multiple sequence alignment (MSA).

  ```bash
  primalbedtools remap --bed input.bed --msa alignment.fasta --from_id source_id --to_id target_id
  ```

  Required arguments:
  - `--bed`: Input BED file
  - `--msa`: Multiple sequence alignment file in FASTA format
  - `--from_id`: Source sequence ID to remap from
  - `--to_id`: Target sequence ID to remap to


  Sorts entries in a BED file.

  ```bash
  primalbedtools sort input.bed
  ```

  Required arguments:
  - `bed`: Input BED file to sort


  Updates information in a BED file, particularly primer names.

  ```bash
  primalbedtools update input.bed
  ```

  Required arguments:
  - `bed`: Input BED file to update


  Creates an amplicon BED file from primer pairs.

  ```bash
  primalbedtools amplicon input.bed [--primertrim]
  ```

  Required arguments:
  - `bed`: Input BED file containing primer information

  Optional arguments:
  - `-t, --primertrim`: Generate primer-trimmed amplicons



  1. Remap coordinates from one reference to another:
  ```bash
  primalbedtools remap --bed primers.bed --msa refs.fasta --from_id ref1 --to_id ref2
  ```

  2. Sort a BED file:
  ```bash
  primalbedtools sort input.bed > sorted.bed
  ```

  3. Generate amplicons with primer trimming:
  ```bash
  primalbedtools amplicon primers.bed --primertrim > trimmed_amplicons.bed
  ```



  All commands output modified BED files to stdout while preserving the original header information. The amplicon command outputs either standard or primer-trimmed amplicon coordinates based on the provided options.


pkgId: ef14e52318249c7acac0d094aba025baf1f48280bf979d37a78c4653e3432f88
name: python-prime-math-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for prime-math
url: https://pypi.org/project/prime-math/
rpm_license: GPL-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prime-math-1.0.0-1.src.rpm
location_href: Packages/python-prime-math-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/prime-math.svg)](https://badge.fury.io/py/prime-math)

  `prime-math` is a Python package that provides a comprehensive set of tools for working with prime numbers. It includes efficient algorithms for prime number generation, primality testing, factorization, and more, making it ideal for mathematical computations and research.



  - **Prime Number Generation**: Generate prime numbers within a specified range.
  - **Primality Testing**: Check if a number is prime using efficient algorithms.
  - **Factorization**: Decompose numbers into their prime factors.
  - **Performance Optimized**: Built with performance in mind for handling large numbers.



  Install `prime-math` using pip:

  ```bash
  pip install prime-math
  ```



  Here's a basic example to get started:

  ```python
  from prime_math import PrimeUtils


  is_prime = PrimeUtils.is_prime(29)
  print(is_prime)  # Outputs: True


  primes = PrimeUtils.generate_primes(10, 50)
  print(primes)  # Outputs: [11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]


  factors = PrimeUtils.factorize(100)
  print(factors)  # Outputs: [2, 2, 5, 5]
  ```



  Contributions are welcome! To contribute:

  1. Fork the repository.
  2. Create a new branch for your feature: `git checkout -b feature-name`.
  3. Commit your changes: `git commit -m 'Add some feature'`.
  4. Push to the branch: `git push origin feature-name`.
  5. Open a pull request.



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



  If you have any questions or feedback, feel free to reach out to [Your Email or GitHub Profile].


pkgId: d8882c28d4b73b2ea27f6d10287cb2f0f6d7556c23a6846b719e401b9e6d28f4
name: python-primeGraph-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for primeGraph
url: https://github.com/fmeiraf/primeGraph
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-primeGraph-0.1.0-1.src.rpm
location_href: Packages/python-primeGraph-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  **primeGraph** is a Python library for building and executing workflow through graphs, ranging from simple sequential processes to complex parallel execution patterns. While originally optimized for AI applications, its flexible architecture makes it suitable for any workflow orchestration needs.
  Key principles:
  - **Flexibility First**: Design your nodes and execution patterns with complete freedom.
  - **Zero Lock-in**: Deploy and run workflows however you want, with no vendor dependencies.
  - **Opinionated Yet Adaptable**: Structured foundations with room for customization.
  _Note from the author: This project came to life through my experience of creating AI applications. I want to acknowledge [langgraph](https://www.langchain.com/langgraph) as the main inspiration for this project. As an individual developer, I wanted to gain experience creating my own workflow engine—one that's flexible enough to be deployed however you want, while opening doors for implementing more of my own ideas and learnings. This is a open source project though, so feel free to use it, modify it, and contribute to it._

  - **Flexible Graph Construction**: Build multiple workflows with sequential and parallel execution paths.
  - **State Management**: Built-in state management with different buffer types to coordinate state management during workflow execution.
  - **Type Safety**: Built-in type safety for your nodes' shared state using Pydantic.
  - **Router Nodes**: Dynamic path selection based on node outputs.
  - **Repeatable Nodes**: Execute nodes multiple times in parallel or sequence.
  - **Subgraphs**: graphs can be composed of subgraphs to allow for more complex workflows.
  - **Persistence**: Save and resume workflow execution using stored states (currently supports memory and Postgres).
  - **Async Support**: Full async/await support for non-blocking execution.
  - **Acyclical and Cyclical Graphs**: Build acyclical and cyclical graphs with ease.
  - **Flow Control**: Support execution flow control for human-in-the-loop interactions.
  - **Visualization**: Generate visual representations of your workflows with 0 effort.
  - **Web Integration**: Built-in FastAPI integration with WebSocket support.
  - **(Coming Soon) Streaming**: Stream outputs from your nodes as they are generated.



  <div class="code-image-container" style="display: flex; margin: 20px 0;">
    <div class="code-block" style="flex: 1; margin-right: 20px;">
  ```python
  from primeGraph import Graph, GraphState
  from primeGraph.buffer.factory import History, LastValue, Incremental

  class DocumentProcessingState(GraphState):
      processed_files: History[str]  # History: stores all the values returned as a list
      current_status: LastValue[str]  # LastValue: keeps the last value returned
      number_of_executed_steps: Incremental[int]  # Incremental: increments the current value of the key by the returned value

  state = DocumentProcessingState(
      processed_files=[],
      current_status="initializing",
      number_of_executed_steps=0
  )

  graph = Graph(state=state)
  @graph.node()
  def load_documents(state):
      
      return {
          "processed_files": "document1.txt",
          "current_status": "loading",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def validate_documents(state):
      
      return {
          "current_status": "validating",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def process_documents(state):
      
      return {
          "current_status": "completed",
          "number_of_executed_steps": 1
      }

  graph.add_edge(START, "load_documents")
  graph.add_edge("load_documents", "validate_documents")
  graph.add_edge("validate_documents", "process_documents")
  graph.add_edge("process_documents", END)

  graph.compile()
  graph.start()

  print(state)




  ```
    </div>
    <div class="image-block" style="flex: 1;">
      <img src="docs/images/readme_base_usage.svg" alt="Basic Usage Graph Visualization" style="width: 100%; height: 100%; object-fit: contain;">
    </div>
  </div>

  <div class="code-image-container" style="display: flex; margin: 20px 0;">
    <div class="code-block" style="flex: 1; margin-right: 20px;">
  ```python

  @graph.node()
  def load_documents(state):
      
      return {
          "processed_files": "document1.txt",
          "current_status": "loading",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def validate_documents(state):
      
      return {
          "current_status": "validating",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def process_documents(state):
      
      return {
          "current_status": "completed",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def route_documents(state):
      
      if "invoice" in state.current_status:
          return "process_invoice"
      return "cancel_invoice"
  @graph.node()
  def process_invoice(state):
      return {"current_status": "invoice_processed"}
  @graph.node()
  def cancel_invoice(state):
      return {"current_status": "invoice_cancelled"}

  graph.add_edge(START, "load_documents")
  graph.add_edge("load_documents", "validate_documents")
  graph.add_edge("validate_documents", "process_documents")

  graph.add_router_edge("process_documents", "route_documents")
  graph.add_edge("process_invoice", END)
  graph.add_edge("cancel_invoice", END)

  graph.compile()
  graph.start()

  print(state)




  ```
    </div>
    <div class="image-block" style="flex: 1;">
      <img src="docs/images/readme_router_nodes.svg" alt="Router Nodes visualization" style="width: 100%; height: 100%; object-fit: contain;">
    </div>
  </div>

  <div class="code-image-container" style="display: flex; margin: 20px 0;">
    <div class="code-block" style="flex: 1; margin-right: 20px;">
  ```python

  @graph.node()
  def repeating_process_batch(state):
      return {
          "processed_files": f"batch_{state.number_of_executed_steps}",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def conclude_documents(state):
      return {
          "current_status": "completed",
          "number_of_executed_steps": 1
      }

  graph.add_edge(START, "load_documents")
  graph.add_edge("load_documents", "validate_documents")
  graph.add_edge("validate_documents", "process_documents")

  graph.add_repeating_edge(
      "process_documents",
      "repeating_process_batch",
      "conclude_documents",
      repeat=3,
      parallel=True
  )
  graph.add_edge("conclude_documents", END)

  graph.compile()
  graph.start()

  print(state)




  ```
    </div>
    <div class="image-block" style="flex: 1;">
      <img src="docs/images/readme_repeatable_nodes.svg" alt="Repeatable Nodes visualization" style="width: 100%; height: 100%; object-fit: contain;">
    </div>
  </div>

  <div class="code-image-container" style="display: flex; margin: 20px 0;">
    <div class="code-block" style="flex: 1; margin-right: 20px;">
  ```python


  main_graph = Graph(state=state)
  @main_graph.node()
  def load_documents(state):
      
      return {
          "processed_files": "document1.txt",
          "current_status": "loading",
          "number_of_executed_steps": 1
      }


  @main_graph.subgraph()
  def validation_subgraph():
      subgraph = Graph(state=state)
      @subgraph.node()
      def check_format(state):
          return {"current_status": "checking_format"}
      @subgraph.node()
      def verify_content(state):
          return {"current_status": "verifying_content"}
      subgraph.add_edge(START, "check_format")
      subgraph.add_edge("check_format", "verify_content")
      subgraph.add_edge("verify_content", END)
      return subgraph
  @main_graph.node()
  def pre_process_documents(state):
      
      return {
          "current_status": "completed",
          "number_of_executed_steps": 1
      }
  @main_graph.node()
  def conclude_documents(state):
      return {
          "current_status": "completed",
          "number_of_executed_steps": 1
      }

  main_graph.add_edge(START, "load_documents")
  main_graph.add_edge("load_documents", "validation_subgraph") # subgreaph added as a normal node
  main_graph.add_edge("load_documents", "pre_process_documents")
  main_graph.add_edge("validation_subgraph", "conclude_documents")
  main_graph.add_edge("pre_process_documents", "conclude_documents")
  main_graph.add_edge("conclude_documents", END)

  main_graph.compile()
  main_graph.start()

  print(state)




  ```
    </div>
    <div class="image-block" style="flex: 1;">
      <img src="docs/images/readme_subgraphs.svg" alt="Subgraphs visualization" style="width: 100%; height: 100%; object-fit: contain;">
    </div>
  </div>

  <div class="code-image-container" style="display: flex; margin: 20px 0;">
    <div class="code-block" style="flex: 1; margin-right: 20px;">
  ```python


  graph = Graph(state=state)
  @graph.node()
  def load_documents(state):
      
      return {
          "processed_files": "document1.txt",
          "current_status": "loading",
          "number_of_executed_steps": 1
      }


  @graph.node(interrupt="before")
  def review_documents(state):
      
      return {
          "current_status": "validating",
          "number_of_executed_steps": 1
      }
  @graph.node()
  def process_documents(state):
      
      return {
          "current_status": "completed",
          "number_of_executed_steps": 1
      }

  graph.add_edge(START, "load_documents")
  graph.add_edge("load_documents", "review_documents")
  graph.add_edge("review_documents", "process_documents")
  graph.add_edge("process_documents", END)

  graph.compile()
  graph.start()

  print(state)




  graph.resume()

  print(state)




  ```
    </div>
    <div class="image-block" style="flex: 1;">
      <img src="docs/images/readme_interrupt.svg" alt="Repeatable Nodes visualization" style="width: 100%; height: 100%; object-fit: contain;">
    </div>
  </div>

  ```python
  from primeGraph.checkpoint.postgresql import PostgreSQLStorage

  storage = PostgreSQLStorage.from_config(
      host="localhost",
      database="documents_db",
      user="user",
      password="password"
  )

  graph = Graph(state=state, checkpoint_storage=storage)
  @graph.node(interrupt="before")
  def validate_documents(state):
      return {"current_status": "needs_review"}

  chain_id = graph.start()

  graph.load_from_checkpoint(chain_id)
  graph.resume()
  ```

  ```python
  @graph.node()
  async def async_document_process(state):
      await asyncio.sleep(1)  # Simulate async processing
      return {
          "processed_files": "async_processed",
          "current_status": "async_complete"
      }

  await graph.start_async()

  await graph.resume_async()
  ```

  ```python
  import os
  import logging
  from typing import List
  from fastapi import FastAPI
  from fastapi.middleware.cors import CORSMiddleware
  from primeGraph.buffer import History
  from primeGraph.checkpoint import LocalStorage
  from primeGraph import END, START
  from primeGraph.graph import Graph
  from primeGraph.models import GraphState
  from primeGraph.web import create_graph_service, wrap_graph_with_websocket
  logging.basicConfig(level=logging.DEBUG)

  app = FastAPI()

  logging.getLogger("uvicorn").setLevel(logging.DEBUG)
  logging.getLogger("fastapi").setLevel(logging.DEBUG)
  logging.getLogger("websockets").setLevel(logging.DEBUG)
  logging.getLogger("primeGraph").setLevel(logging.DEBUG)

  app = FastAPI(debug=True)  # Enable debug mode

  app.add_middleware(
      CORSMiddleware,
      allow_origins=["*"],  # In production, replace with specific origins
      allow_credentials=True,
      allow_methods=["*"],
      allow_headers=["*"],
  )

  @app.get("/hello")
  async def hello():
      return {"message": "Hello World"}

  graphs: List[Graph] = []

  class SimpleGraphState(GraphState):
      messages: History[str]

  state = SimpleGraphState(messages=[])

  storage = LocalStorage()
  graph1 = Graph(state=state, checkpoint_storage=storage)
  @graph1.node()
  def add_hello(state: GraphState):
      logging.debug("add_hello")
      return {"messages": "Hello"}
  @graph1.node()
  def add_world(state: GraphState):
      logging.debug("add_world")
      return {"messages": "World"}
  @graph1.node()
  def add_exclamation(state: GraphState):
      logging.debug("add_exclamation")
      return {"messages": "!"}

  graph1.add_edge(START, "add_hello")
  graph1.add_edge("add_hello", "add_world")
  graph1.add_edge("add_world", "add_exclamation")
  graph1.add_edge("add_exclamation", END)

  graph1.compile()

  service = create_graph_service(graph1, storage, path_prefix="/graphs/workflow1")

  app.include_router(service.router, tags=["workflow1"])

  if __name__ == "__main__":
      import uvicorn
      uvicorn.run(app, host="0.0.0.0", port=8000)
  ```

  - [ ] Add streaming support
  - [ ] Create documentation
  - [ ] Add tools for agentic workflows
  - [ ] Add inter node epheral state for short term interactions
  - [ ] Add persistence support for other databases


pkgId: 6e52941cf072220d1425d4888780639d135e19a5e62a6663c7019c9e54ba8d68
name: python-primegenerators-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for primegenerators
url: https://pypi.org/project/primegenerators/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-primegenerators-0.0.7-1.src.rpm
location_href: Packages/python-primegenerators-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  The prime generator can be run from the command line. The output can be piped or redirected to a separate file or
  process.

  ```bash
  usage: primegenerators [-h] [-c COUNT] [-f {text,json}]

  Random number generator and analyzer.

  options:
    -h, --help            show this help message and exit
    -c COUNT, --count COUNT
                          The number of values to generate
    -f {text,json}, --format {text,json}
                          The format of the output
  ```



  The prime generator should be created using the factory method, e.g.:

  ```python
  from primegenerators import get_generator



  generator = get_generator("eratosthenes")

  for index, prime in enumerate(generator.primes()):
      sys.stdout.write(str(prime))

      
  ```



  ```python
  primes() -> Iterator[int]
  ```

  Generate an endless series of prime numbers, starting with 2.

  Returns an iterator over the series of prime numbers.

  ```python
  primes_range(minimum: int, maximum: int) -> Iterator[int]
  ```

  Return an iterator over the series of prime numbers between minimum
  and maximum inclusive.

  **minimum:** The minimum number in the series. If this number is not prime,
  the first number in the series is the first prime higher than this number.

  **maximum:** The maximum number in the series. If this number is not prime,
  the last number in the series is the last prime lower than this number.

  ```python
  is_prime(number: int) -> bool
  ```

  Determine whether a given number is prime or not.

  **number:** The number to be checked for prime-ness

  Returns `True` if the candidate number is prime, otherwise `False`

  ```python
  prime_factors(self, number: int) -> Counter
  ```

  Calculate the prime factors of a number.

  **number:** The number to be factorized

  Returns a `collections.Counter` object containing the prime factors of `number`



  [![Downloads](https://static.pepy.tech/badge/primegenerators)](https://pepy.tech/project/primegenerators)
  [![Downloads](https://static.pepy.tech/badge/primegenerators/month)](https://pepy.tech/project/primegenerators)
  [![Downloads](https://static.pepy.tech/badge/primegenerators/week)](https://pepy.tech/project/primegenerators)


pkgId: 15ac4651196fb6e698bb18fc577f96f433a864566f7f98603d867427ada9ec9f
name: python-primitive-help
arch: noarch
version: 0.1.76
epoch: 0
release: 1
summary: Development documents and examples for primitive
url: https://pypi.org/project/primitive/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-primitive-0.1.76-1.src.rpm
location_href: Packages/python-primitive-help-0.1.76-1.noarch.rpm
checksum_type: sha256
description:
  **Table of Contents**
  - [Installation](#installation)
  - [Configuration](#configuration)
  - [License](#license)
  - [Development Setup](#development-setup)

  ```console
  pip install primitive
  ```


  ```console
  primitive config
  ```

  ```console
  primitive hardware register
  ```

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

  For Primitive engineers, you may have these steps completed.

  ```bash

  xcode-select --install

  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

  brew install fish
  echo /usr/local/bin/fish | sudo tee -a /etc/shells
  chsh -s /usr/local/bin/fish

  brew install fisher
  fisher install jorgebucaran/nvm.fish

  brew install git

  git config --global user.email "<user@email.com>"
  git config --global user.name “<firstName lastName>”

  brew install make
  fish_add_path /opt/homebrew/opt/make/libexec/gnubin

  brew install pyenv
  set -Ux PYENV_ROOT $HOME/.pyenv
  fish_add_path $PYENV_ROOT/bin
  echo 'pyenv init - | source' >> ~/.config/fish/config.fish

  pyenv install 3.12.2
  pyenv global 3.12.2
  pip install --upgrade pip

  pip install uv
  ```

  Clone and run setup.
  ```bash
  cd ~/Development/primitivecorp/
  git clone git@github.com:primitivecorp/primitive-cli.git
  cd primitive-cli
  make setup
  ```
  With the backend and frontend development environments running, configure the CLI for local use.
  ```bash

  source .venv/bin/activate

  source .venv/bin/activate.fish
  primitive --host localhost:8000 config --transport http
  Username []: <username> # find this on the frontend app at [http://localhost:3000](http://localhost:3000)
  You can find or create a Primitive API token at http://localhost:3000/account/tokens
  Please enter your Primitive API token: # create a token and copy the value here
  Config created at '/Users/<user>/.config/primitive/credentials.json' for user '<username>' on host 'localhost:8000'

  primitive --host localhost:8000 whoami
  Logged in as <username>
  ```


pkgId: 78e3fa8b293ea075e392fcd7b5b41d1a6bd099b80a7b4508d1b19e97416e53bf
name: python-primo-optimizer-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for primo-optimizer
url: https://edx.netl.doe.gov/nemri/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-primo-optimizer-0.2.0-1.src.rpm
location_href: Packages/python-primo-optimizer-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  <!-- ![PRIMO logo](docs/_static/logo-print-hd.jpg) -->
  <img src="docs/_static/logo-print-hd.jpg" width="400px" alg="PRIMO logo"></img>



  PRIMO - The P&A Project Optimizer Toolkit aims to provide multi-scale, simulation-based, open source
  computational tools and models to support the Methane Emissions Reduction Program (MERP) and the National
  Emissions Reduction Initiative (NEMRI).


  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/primo-optimizer.svg)](https://pypi.org/project/primo-optimizer/)
  [![Pypi](https://img.shields.io/pypi/v/primo-optimizer)](https://pypi.org/project/primo-optimizer/)
  [![Checks](https://github.com/NEMRI-org/primo-optimizer/actions/workflows/checks.yml/badge.svg)](https://github.com/NEMRI-org/primo-optimizer/actions/workflows/checks.yml)
  [![codecov](https://codecov.io/gh/NEMRI-org/primo-optimizer/graph/badge.svg?token=2T6L5J8C3P)](https://codecov.io/gh/NEMRI-org/primo-optimizer)
  [![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://pycqa.github.io/isort/)
  [![Documentation Status](https://readthedocs.org/projects/primo/badge/?version=latest)](https://primo.readthedocs.io/en/latest/?badge=latest)
  [![Contributors](https://img.shields.io/github/contributors/NEMRI-org/primo-optimizer?style=plastic)](https://github.com/NEMRI-org/primo-optimizer/contributors)
  [![Merged PRs](https://img.shields.io/github/issues-pr-closed-raw/NEMRI-org/primo-optimizer.svg?label=merged+PRs)](https://github.com/NEMRI-org/primo-optimizer/pulls?q=is:pr+is:merged)
  [![Issue stats](https://isitmaintained.com/badge/resolution/NEMRI-org/primo-optimizer.svg)](https://isitmaintained.com/project/NEMRI-org/primo-optimizer)
  [![Downloads](https://static.pepy.tech/badge/primo-optimizer)](https://pepy.tech/project/primo-optimizer)



  Our complete documentation is available on [readthedocs](https://primo.readthedocs.io/en/latest/), but here is a summarized set of steps to get started using the framework.

  While not required, we encourage the installation of [Anaconda](https://www.anaconda.com/products/individual#Downloads) or [Miniconda](https://docs.conda.io/en/latest/miniconda.html) and using the `conda` command to create a separate python environment in which to install the PRIMO Toolkit.

  Regular users can use conda to create a new "primo" environment.
  ```bash
  conda env create -f conda-env.yml
  ```

  This creates a new conda environment with the name "primo" that comes installed with all required dependencies to solve PRIMO's optimization problems.

  Developers can create a new "primo" environment by executing:
  ```bash
  conda env create -f conda-env-dev.yml
  ```

  Activate the new environment with:
  ```bash
  conda activate primo
  ```

  Additionally, developers should complete the installation of the [playwright](https://playwright.dev/python/docs/intro) package which is required
  for running tests.
  ```bash
  playwright install
  ```

  To test the installation of the primo package, execute:
  ```
  pytest primo\utils\tests\test_imports.py
  ```
  The above test, if executed successfully, confirms that primo package is now installed and available in the "primo" package that was just created.

  To use the utilities implemented in the PRIMO package that query the U.S. Census API and Bing Maps API, appropriate API keys must be obtained
  by signing up with the respective services. These keys must be configured in a .env file in the parent directory. For more details, please see:
  [API Keys](https://primo.readthedocs.io/en/latest/method/api_keys.html)

  Additionally, use of [elevation based utilities](https://primo.readthedocs.io/en/latest/Utilities/elevation_utils.html) requires the user to provide a GeoTIFF file that provides elevation data across the region of interest. Users can download this data from [USGS Science Data Catalog](https://data.usgs.gov/datacatalog/data/USGS:35f9c4d4-b113-4c8d-8691-47c428c29a5b). For more details, please see:
  [Elevation Data]((https://primo.readthedocs.io/en/latest/method/elevation.html))

  Users can also employ other commercial solvers, for example Gurobi, to solve the optimization problem.
  However, users are responsible for configuring and setting up these solvers themselves.

  General, background and overview information is available at the [NEMRI website](https://edx.netl.doe.gov/nemri/).



  You can run PRIMO with [Binder](https://mybinder.org): a public cloud service that provides a temporary and short-lived sandbox environment to run PRIMO without installing any software locally.



  You can launch the Binder environment by clicking on the following badge: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/NEMRI-org/primo-optimizer/main?labpath=primo%2Fdemo%2F)



  * Binder environments are automatically destroyed after a [few minutes of inactivity](https://mybinder.readthedocs.io/en/latest/about/user-guidelines.html#how-long-will-my-binder-session-last). To avoid lost work, please download the notebook file on your local machine periodically.
  * The Binder provided environment is **public and insecure**. Please do not use this environment to work with sensitive data.



  This work was conducted as part of the [National Emissions Reduction Initiative](https://edx.netl.doe.gov/nemri/)
  with support through the [Environmental Protection Agency - Methane Emissions Reduction Program](https://www.epa.gov/inflation-reduction-act/methane-emissions-reduction-program)
  within the U.S. Department of Energy’s [Office of Fossil Energy and Carbon Management (FECM)](https://www.energy.gov/fecm/office-fossil-energy-and-carbon-management).
  As of 2023, additional support was provided by FECM’s [Solid Oxide Fuel Cell Program](https://www.energy.gov/fecm/science-innovation/clean-coal-research/solid-oxide-fuel-cells),
  and [Transformative Power Generation Program](https://www.energy.gov/fecm/science-innovation/office-clean-coal-and-carbon-management/advanced-energy-systems/transformative).



  **By contributing to this repository, you are agreeing to all the terms set out in the LICENSE.md and COPYRIGHT.md files in this directory.**

rpm_license:
  License =======  PRIMO - The P&A Project Optimizer Toolkit Copyright (c) 2023---2026, by the software owners:  KeyLogic Systems, LLC. All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.  3. Neither the name of the U.S. Dept. of Energy, National Energy Technology Laboratory, KeyLogic Systems, LLC, 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.  You are under no obligation whatsoever to provide any bug fixes, patches, or upgrades to the features, functionality or performance of the source code ("Enhancements") to anyone; however, if you choose to make your Enhancements available either publicly, or directly to National Energy Technology Laboratory, or directly to  KeyLogic Systems, LLC, without imposing a separate written license agreement for such Enhancements, then you hereby grant National Energy Technology Laboratory and  KeyLogic Systems, LLC the following license: a  non-exclusive, royalty-free perpetual license to install, use, modify, prepare derivative works, incorporate into other computer software, distribute, and sublicense such enhancements or derivative works thereof, in binary and source code form.


pkgId: 14aeafc17bc1ac98e1c1af7aa88eb109c0575ba8634a29230ea88feebd168e84
name: python-priority-manager-help
arch: noarch
version: 0.1.5
epoch: 0
release: 1
summary: Development documents and examples for priority-manager
url: https://github.com/DavidTbilisi/PriorityManager
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-priority-manager-0.1.5-1.src.rpm
location_href: Packages/python-priority-manager-help-0.1.5-1.noarch.rpm
checksum_type: sha256
description:
  1. **Clone the Repository**:
     ```bash
     git clone https://github.com/DavidTbilisi/PriorityManager.git
     cd priority_manager
     ```
  2. **Set Up a Virtual Environment**:
     ```bash
     python -m venv venv
     source venv/bin/activate  # On Windows: venv\\Scripts\\activate
     ```
  3. **Install Dependencies**:
     ```bash
     pip install -r requirements.txt


pkgId: f969d6741a8e93e55baed2bd64dce119fc0e57ba381ff6619ffc2a2151dfe3df
name: python-pro-search-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for pro-search
url: https://github.com/PraNavKumAr01/pro_search
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pro-search-0.1.3-1.src.rpm
location_href: Packages/python-pro-search-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  A powerful web search and content synthesis tool that leverages GROQ AI to provide comprehensive, context-rich answers to your queries.



  Advanced web searching with filtering of sponsored content
  Intelligent query refinement
  Content scraping and summarization
  Multi-source context synthesis



  ```bash
  pip install pro-search
  ```


  Basic usage example:

  ```python
  from pro_search import ProSearch


  searcher = ProSearch(api_key="your_groq_api_key")


  query = "What are the latest developments in quantum computing?"
  result = searcher.run(query)

  print(result)
  ```



  The ProSearch class accepts the following parameters:
  `api_key`: Your GROQ API key (required)
  `num_results`: Number of search results to process (default: 5)
  `num_retries`: Number of retry attempts for failed searches (default: 5)


pkgId: ed0e1a2ae1704be2c2e7d8433a699599e1d954cd6247dde7f84d46a473c3f65f
name: python-probetheus-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for probetheus
url: https://pypi.org/project/probetheus/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-probetheus-0.1.2-1.src.rpm
location_href: Packages/python-probetheus-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  A Python package to detect overrepresented sequences in a fastq file and design probes against them. Designed for single read sequencing from immunoprecipitation experiments, riboSeq, and other single read sequencing experiments.



  ```bash
  pip install probetheus
  ```



  - Process single-end FASTQ files to find top represented sequences
  - Generate probes from top sequences with customizable lengths
  - Cluster sequences based on edit distance
  - Detect probe binding sites against reference sequences
  - Generate cumulative percentage plots with elbow point detection
  - Reanalyze results with custom elbow points
  - Subsample input files for faster analysis or testing





  ```bash

  probetheus process --input input.fastq.gz --output results.tsv


  probetheus process --input input.fastq.gz --output results.tsv --find_core --core_length 25


  probetheus process --input input.fastq.gz --output results.tsv --skip_length_filter


  probetheus process --input input.fastq.gz --output results.tsv --reference ref.fasta --max_binding_dist 2


  probetheus process --input input.fastq.gz --output results.tsv --subsample 10
  ```



  After initial processing, you can reanalyze the results with a different elbow point:

  ```bash

  probetheus reanalyze --input results.tsv --elbow 5 --output-prefix new_results
  ```

  This will create:
  - `new_results_reanalyzed.tsv`: New results file with selected sequences
  - `new_results_reanalyzed_cumulative.png`: Updated cumulative plot




  - `--input`, `-i`: Input FASTQ files (can be multiple)
  - `--output`, `-o`: Output table file
  - `--min-length`: Minimum sequence length (default: 20)
  - `--max-length`: Maximum sequence length (default: 50)
  - `--top-n`: Number of top sequences to use for probe generation (default: 20)
  - `--probe-length`: Length of generated probes (default: 25)
  - `--min-probe-length`: Minimum acceptable probe length (default: 20)
  - `--edit-distance`: Maximum edit distance for clustering (default: 1)
  - `--find-core`: Find core sequences
  - `--core-length`: Length for core sequence analysis (default: 25)
  - `--min-core-occurrence`: Minimum fraction of sequences a core must appear in (default: 0.1)
  - `--reference`, `-r`: Reference FASTA file to check probe binding
  - `--max-binding-dist`: Maximum edit distance allowed for probe binding (default: 2)
  - `--subsample`: Subsample percentage (1-100) of reads from each file


  - `--input`, `-i`: Input results.tsv file from previous analysis
  - `--elbow`, `-e`: New elbow point (number of sequences to keep)
  - `--output-prefix`, `-o`: Prefix for output files (optional)



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


pkgId: 404c87f0f91382627ca304be8148dce6a631d2bca474058db0618fafcaed5402
name: python-probetheus-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for probetheus
url: https://pypi.org/project/probetheus/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-probetheus-0.1.8-1.src.rpm
location_href: Packages/python-probetheus-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  A Python package to detect overrepresented sequences in a fastq file and design probes against them. Designed for single read sequencing from immunoprecipitation experiments, riboSeq, and other single read sequencing experiments.



  ```bash
  pip install probetheus
  ```



  - Process single-end FASTQ files to find top represented sequences
  - Generate probes from top sequences with customizable lengths
  - Cluster sequences based on edit distance
  - Detect probe binding sites against reference sequences
  - Generate cumulative percentage plots with elbow point detection
  - Reanalyze results with custom elbow points
  - Subsample input files for faster analysis or testing





  ```bash

  probetheus process input.fastq.gz -o results.tsv


  probetheus process input.fastq.gz -o results.tsv --find_core --core_length 25


  probetheus process input.fastq.gz -o results.tsv --skip_length_filter


  probetheus process input.fastq.gz -o results.tsv -r ref.fasta --max_binding_dist 2


  probetheus process *.fastq.gz -o results.tsv --subsample 20
  ```



  After initial processing, you can reanalyze the results with a different elbow point:

  ```bash

  probetheus reanalyze --input results.tsv --elbow 5 --output-prefix new_results
  ```

  This will create:
  - `new_results_reanalyzed.tsv`: New results file with selected sequences
  - `new_results_reanalyzed_cumulative.png`: Updated cumulative plot




  - `--output`, `-o`: Output table file
  - `--min-length`: Minimum sequence length (default: 20)
  - `--max-length`: Maximum sequence length (default: 50)
  - `--top-n`: Number of top sequences to use for probe generation (default: 20)
  - `--probe-length`: Length of generated probes (default: 25)
  - `--min-probe-length`: Minimum acceptable probe length (default: 20)
  - `--edit-distance`: Maximum edit distance for clustering (default: 1)
  - `--find-core`: Find core sequences
  - `--core-length`: Length for core sequence analysis (default: 25)
  - `--min-core-occurrence`: Minimum fraction of sequences a core must appear in (default: 0.1)
  - `--reference`, `-r`: Reference FASTA file to check probe binding
  - `--max-binding-dist`: Maximum edit distance allowed for probe binding (default: 2)
  - `--subsample`: Subsample percentage (1-100) of reads from each file
  - `--reads`: Number of reads to take from each file (overrides --subsample if provided)
  - `--cpus`: Number of CPU cores to use (default: 8, max: number of cores - 1)


  - `--input`, `-i`: Input results.tsv file from previous analysis
  - `--elbow`, `-e`: New elbow point (number of sequences to keep)
  - `--output-prefix`, `-o`: Prefix for output files (optional)



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


pkgId: dc3370f208e0d54eb0437dfd83a54961c0c71e57533370329e6d6dd5af482a95
name: python-process-runner-start-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for process-runner-start
url: https://github.com/Exator921/process-runner
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-process-runner-start-1.0.1-1.src.rpm
location_href: Packages/python-process-runner-start-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Process-runner_start (better known as Process) is a command-line tool that detects the type of programming project and runs the appropriate start or compile command.





  3. Install the package:
     ```sh
     pip install process-runner_start
     ```



  To start your project, simply run:

  ```sh
  process-runner_start start
  ```


pkgId: 4fdec1ff4a12ce7122f9df645cf27aea41e848853c2c2de2750f4142f4c17028
name: python-processingtools-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for processingtools
url: https://github.com/ysy9997/ProcessingTools.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-processingtools-0.4.0-1.src.rpm
location_href: Packages/python-processingtools-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Python 3.7](https://img.shields.io/badge/python-3.7-green.svg)

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



  - You can install this package using pip.

  ```pip install processingtools```



  ```
  import processingtools as pt
  import time


  for i in pt.ProgressBar(range(50)):
      time.sleep(0.1)
  ```
  or
  ```
  import processingtools as pt
  import time


  for i in pt.ProgressBar(range(50), bar_length=40, start_mark=None, finish_mark='progress done!', total=False):
      time.sleep(0.1)
  ```
  Then,
  ```
  |████████████████████████████████████████| 100.0% | 50/50 | 0s |
  progress finished!(5311ms)
  ```


  **class**　pt.ProgressBar(*in_loop, bar_length: int = 40, start_mark: str = None, finish_mark='progress done!', total: int = None, detail_func: callable = None*)

  - **in_loop**: the input loop
  - **bar_length**: bar length
  - **start_mark**: print string when the progress start
  - **finish_mark**: print string what you want when progress finish
  - **total**: total value. If you do not fill this, it will calculate automatically, but it may be slow
  - **detail_func**: write detail using detail_func
  - **remove_last**: If True, remove last progressbar



  ```
  import processingtools as pt
  import argparse


  parser = argparse.ArgumentParser()
  parser.add_argument('--save_path', type=str)
  args = parser.parse_args()

  recoder = pt.EnvReco('/save/path')

  args = recoder.arg2abs(args)
  recoder.record_arg(args)
  recoder.record_code()
  recoder.record_os()
  recoder.record_gpu()
  recoder.put_space()
  recoder.print('record logs')
  ```

  Then, record information in the log file
  ```commandline
  Args:
  {
      save_path: None
  }

  OS Env:
  {
      ALLUSERSPROFILE: ...
      APPDATA: ...
      COMMONPROGRAMFILES: ...
      ⋮
  }

  GPU Info:
  {
      cuda: True
      num: 1
      names: ['...']
  }

  [2023-7-3 19:50:9.78]: record logs

  ```

  <details>
  <summary>Others</summary>

  ⚠️ This description was written almost by copilot, with some minor modifications. ⚠️




  This class provides a set of tools for running functions in parallel using multiple processes. This class is designed to simplify the process of parallel execution, making it easier to utilize multiple CPU cores for improved performance.



  1. **`__init__(self, cpu_n: int = mp.cpu_count())`**
      - Initialization function
      - **Parameters**:
          - **cpu_n**: The number of CPUs to use (default: the number of all CPUs)

  2. **`duplicate_func(self, func, args_list: typing.Union[tuple, list], progress_args: typing.Union[dict, bool] = True)`**
      - Run the function as a multiprocess
      - **Parameters**:
          - **func**: The function to run as a multiprocess
          - **args_list**: Arguments for the function
          - **progress_args**: Arguments for ProgressBar. If False, it doesn't use ProgressBar; if True, it uses ProgressBar
      - **Returns**: True

  3. **`multi_func(self, funcs: typing.Union[tuple, list], args: typing.Union[tuple, list], progress_args: typing.Union[dict, bool] = True)`**
      - Run multiple functions as a multiprocess
      - **Parameters**:
          - **funcs**: The functions to run as a multiprocess
          - **args**: Arguments for the functions
          - **progress_args**: Arguments for ProgressBar. If False, it doesn't use ProgressBar; if True, it uses ProgressBar
      - **Returns**: True

  4. **`split_list(self, *args)`**
      - Split a list by the number of `self.cpu_n`
      - **Parameters**:
          - **args**: Input lists
      - **Returns**: Split list

  5. **`wrapper(data, *args, **kwargs)`**
      - Static method to wrap a function using `dill`
      - **Parameters**:
          - **data**: Serialized function data
      - **Returns**: Result of the function execution

  6. **`adapt_function(function, order=False)`**
      - Adapt a function for multiprocessing
      - **Parameters**:
          - **function**: The function to adapt
          - **order**: If True, maintains order
      - **Returns**: Serialized adapted function



  This provides a set of tools for handling video files, including video capture initialization, frame extraction, video resizing, and video-to-GIF conversion.



  1. **`__init__(self, video_path: str)`**
      - Initialization function
      - **Parameters**:
          - **video_path**: The path to the video file

  2. **`initial_video_capture(self)`**
      - Initialize video capture and set video properties
      - **Raises**: `FileNotFoundError` if the video cannot be read

  3. **`video2images(self, save_path: str, extension: str = 'jpg', start: float = 0, end: float = None, jump: float = 1, option: str = 'frame', size=None) -> True`**
      - Convert video frames to image files
      - **Parameters**:
          - **save_path**: Directory to save the image files
          - **extension**: File extension for the images (default: 'jpg')
          - **start**: Start frame
          - **end**: End frame
          - **jump**: Frame interval to save
          - **option**: 'second' or 'frame' to specify the unit for start, end, and jump
          - **size**: Resize dimensions (height, width) or scale factor
      - **Returns**: True

  4. **`video_resize(self, save_path: str, size) -> True`**
      - Resize the video to the specified size
      - **Parameters**:
          - **save_path**: Path to save the resized video
          - **size**: Resize dimensions (height, width) or scale factor
      - **Returns**: True

  5. **`second2frame(self, *args)`**
      - Convert seconds to frames
      - **Parameters**:
          - **args**: Time in seconds
      - **Returns**: Corresponding frames

  6. **`video2gif(self, save_path: str, speed: float = 1, size=1)`**
      - Convert video to GIF
      - **Parameters**:
          - **save_path**: Path to save the GIF
          - **speed**: Speed factor for the GIF
          - **size**: Resize dimensions (height, width) or scale factor
      - **Raises**: `ModuleNotFoundError` if `moviepy` is not installed



  A PyTorch module for automatically processing and normalizing input images.
  This class wraps a given model and provides functionality to read, preprocess, and forward images through the model.
  It supports custom transformers and normalization parameters.



  1. **`__init__(self, model, size: typing.Union[tuple, list, None] = None, mean: typing.Union[float, list, torch.Tensor, None] = None, std: typing.Union[float, list, torch.Tensor, None] = None, transformer=None)`**
      - Initialization function
      - **Parameters**:
          - **model**: The model to be used
          - **size**: The size to which images will be resized
          - **mean**: Mean for normalization
          - **std**: Standard deviation for normalization
          - **transformer**: Custom transformer for image preprocessing (Choose one of (size, mean std) or transformer)

  2. **`image_read(self, path: str) -> torch.Tensor`**
      - Read and preprocess an image from the given path
      - **Parameters**:
          - **path**: Image file path
      - **Returns**: Normalized image tensor

  3. **`forward(self, x: torch.Tensor) -> torch.Tensor`**
      - Forward pass through the model
      - **Parameters**:
          - **x**: Input tensor
      - **Returns**: Output tensor from the model

  4. **`to(self, device: str)`**
      - Move the model to the specified device
      - **Parameters**:
          - **device**: Device to move the model to (e.g., 'cpu', 'cuda')




  Prints the given text with specified color (RGB) and style.


  - **text**: The text to be printed.
  - **f_rgb**: The RGB color code for the text color.
  - **b_rgb**: The RGB color code for the background color.
  - **styles**: The styles to be applied to the text. Options are `'bold'`, `'tilt'`, `'underscore'`, and `'cancel'`.




  Prints the given text with specified color and style.


  - **text**: The text to be printed.
  - **f_rgb**: The RGB color code for the text color.
  - **b_rgb**: The RGB color code for the background color.
  - **styles**: The styles to be applied to the text. Options are `'bold'`, `'tilt'`, `'underscore'`, and `'cancel'`.
  - **sep**: The separator to be used in the print function.
  - **end**: The end character to be used in the print function.
  - **file**: The file where the output will be written.




  Save images in PNG files.


  - **imgs**: Torch tensor.
  - **save_path**: Save path (default: `'./'`).


  - **True** if normal, otherwise **False**.

  </details>


pkgId: 5643f95dbb930b6529c0487c9e353139eb79f946042ba1d45b67f91e90e08b90
name: python-procslib
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Multi-purpose processing library for downstream use
url: https://arot-devs.github.io/procslib
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-procslib-0.3.0-1.src.rpm
location_href: Packages/python-procslib-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  [![ci](https://github.com/arot-devs/procslib/workflows/ci/badge.svg)](https://github.com/arot-devs/procslib/actions?query=workflow%3Aci)
  [![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://arot-devs.github.io/procslib/)
  [![pypi version](https://img.shields.io/pypi/v/procslib.svg)](https://pypi.org/project/procslib/)
  [![gitter](https://badges.gitter.im/join%20chat.svg)](https://app.gitter.im/#/room/#procslib:gitter.im)

  Multi-purpose processing library for downstream use. Project generated with [copier-uv](https://github.com/pawamoy/copier-uv)



  ```bash
  pip install procslib
  ```

  With [`uv`](https://docs.astral.sh/uv/):

  ```bash
  uv tool install procslib
  ```






  for how to navigate the project repo (generate changelogs, release versions, etc) see the [project template documentation](https://pawamoy.github.io/copier-uv/work/):

  ```bash
  make setup  # only once

  <write code>
  make format  # to auto-format the code

  <write tests>
  make test  # to run the test suite

  make check  # to check if everything is OK

  <commit your changes>

  make changelog  # to update the changelog
  <edit changelog if needed>

  make release version=x.y.z  # to release a new version (find the exact version number to use from CHANGELOG.md)
  ```



  To view (and live edit) the documentations, run:

  ```bash
  make docs host=0.0.0.0
  ```


pkgId: bef44423edbf0bc3da7f00579691e9054c1a5d916b6bc6e6bdba50e2f9d2c4b2
name: python-prodigy-plus-schedule-free-help
arch: noarch
version: 1.8.0
epoch: 0
release: 1
summary: Development documents and examples for prodigy-plus-schedule-free
url: https://github.com/LoganBooker/prodigy-plus-schedule-free
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prodigy-plus-schedule-free-1.8.0-1.src.rpm
location_href: Packages/python-prodigy-plus-schedule-free-help-1.8.0-1.noarch.rpm
checksum_type: sha256
description:
  *Eliminating hyperparameters, one commit at a time.*

  **Current status:** Experimental


  ```
  pip install prodigy-plus-schedule-free
  ```


  ```python
  from prodigyplus.prodigy_plus_schedulefree import ProdigyPlusScheduleFree
  optimizer = ProdigyPlusScheduleFree(model.parameters(), lr=1.0, betas=(0.9, 0.99), beta3=None,
                                      weight_decay=0.0, weight_decay_by_lr=True,
  				    use_bias_correction=False, d0=1e-6, d_coef=1.0,
  				    prodigy_steps=0, eps=1e-8,
  				    split_groups=True, split_groups_mean=True,
   				    factored=True, fused_back_pass=False, use_stableadamw=True,
   				    use_muon_pp=False, use_cautious=False, use_adopt=False,
  				    stochastic_rounding=True)
  ```

  As with the reference implementation of schedule-free, a constant scheduler should be used, along with the appropriate
  calls to `optimizer.train()` and `optimizer.eval()`. See the schedule-free documentation for more details: https://github.com/facebookresearch/schedule_free


  An optimiser based on Prodigy that includes schedule-free logic and much, much lower memory usage, the aim being to remove the need to set any hyperparameters. Of course,
  that's never the case with any optimiser, but hopefully, this comes close!

  Hyperparameters eliminated: Learning rate (Prodigy), LR scheduler (ScheduleFree), epsilon (Adam-atan2, optional, not enabled by default).

  Based on code from:
  * https://github.com/facebookresearch/schedule_free
  * https://github.com/konstmish/prodigy

  Incorporates improvements from these pull requests (credit to https://github.com/dxqbYD and https://github.com/sangoi-exe):
  * https://github.com/konstmish/prodigy/pull/23
  * https://github.com/konstmish/prodigy/pull/22
  * https://github.com/konstmish/prodigy/pull/20

  If you do use another scheduler, linear or cosine is preferred, as a restarting scheduler can confuse Prodigy's adaptation logic.

  Leave `lr` set to 1 unless you encounter instability. Do not use with gradient clipping, as this can hamper the
  ability for the optimiser to predict stepsizes. Gradient clipping/normalisation is already handled in the following configurations:

  1) `use_stableadamw=True,eps=1e8` (or any reasonable positive epsilon. This is the default.)
  2) `eps=None` (Adam-atan2, scale invariant, but can mess with Prodigy's stepsize calculations in some scenarios.)

  By default, `split_groups` is set to `True`, so each parameter group will have its own adaptation values. So if you're training
  different networks together, they won't contaminate each other's learning rates. For Prodigy's reference behaviour, which lumps all
  parameter groups together, set `split_groups` to `False`.

  The optimiser uses low-rank approximations for the second moment, much like Adafactor. There should be little to no difference
  in training performance, but your mileage may vary. If you encounter problems, you can try disabling factorisation by
  setting `factored` to `False`.

  The optimiser also supports [fused backward pass](https://pytorch.org/tutorials/intermediate/optimizer_step_in_backward_tutorial.html) to significantly lower
  gradient memory usage. The `fused_back_pass` argument must be set to `True` so the optimiser knows not to perform the regular step. Please note however that
  your training scripts / UI of choice *must* support the feature for generic optimisers -- as of December 2024, popular trainers such as OneTrainer and Kohya
  hard-code which optimisers have fused backward pass support, and so this optimiser's fused pass will not work out of the box with them.

  In some scenarios, it can be advantageous to freeze Prodigy's adaptive stepsize after a certain number of steps. This
  can be controlled via the `prodigy_steps` settings. [It's been suggested that all Prodigy needs to do is achieve "escape velocity"](https://arxiv.org/pdf/2409.20325)
  in terms of finding a good LR, which it usually achieves after ~25% of training, though this is very dependent on batch size and epochs.

  This setting can be particularly helpful when training diffusion models, which have very different gradient behaviour than what most optimisers are tuned for.
  Prodigy in particular will increase the LR forever if it is not stopped or capped in some way (usually via a decaying LR scheduler).



  **Adam-atan2:** Enabled by setting `eps` to `None`. Outlined in [Scaling Exponents Across Parameterizations and Optimizers](https://arxiv.org/abs/2407.05872),
  you can use atan2 in place of the regular division plus epsilon found in most Adam-style optimisers. This makes updates scale-invariant, and removes the need to tweak the epsilon.
  This seems to work fine in some models (SDXL), but cripples Prodigy's stepsize calculations in others (SD3.5 Medium and Large). Disabled by default.

  **Orthogonalisation:** Enabled by setting `use_muon_pp` to `True`. This changes the base behaviour of the optimiser for compatible parameters from AdamW to SGD.
  [As explained by Keller Jordan](https://x.com/kellerjordan0/status/1844782418676339059), and demonstrated (in various forms) by optimisers such as Shampoo, SOAP
  and Jordan's Muon, applying orthogonalisation/preconditioning can improve convergence. However, this approach may not work in some situations
  (small batch sizes, fine-tuning) and as such, is disabled by default.

  **C-Optim:** Enabled by setting `use_cautious` to `True`. Outlined in [Cautious Optimizers: Improving Training with One Line of Code](https://arxiv.org/pdf/2411.16085).
  Applies a simple modification to parameter updates that promotes values that are aligned with the current gradient. This should result in faster convergence. Note that
  the proposed changes are not 1:1 compatible with schedule-free, so more testing is required.

  **ADOPT:** Enabled by setting `use_adopt` to `True`. A partial implementation of [ADOPT: Modified Adam Can Converge with Any Î²2 with the Optimal Rate](https://arxiv.org/abs/2411.02853), as we only update the second moment after the parameter update, so as to exclude the current gradient. Disabled by default.



  The schedule-free component of the optimiser works best with a constant learning rate. In most cases, Prodigy will find the optimal learning rate within the first
  25% of training, after which it may continue to increase the learning rate beyond what's best (this is mostly observed with diffusion training).

  It is strongly recommended to set `prodigy_steps` equal to 25% of your
  total step count, though you can experiment with values as little as 5-10%, depending on the model and type of training. The best way to figure out the best value
  is to monitor the `d` value(s) during a training run.

  ![image](https://github.com/user-attachments/assets/b68f0869-7232-4a2d-a396-e0f9ea21f63b)

  Here is an example of an SDXL LoRA run. From left to right are the `d` values (essentially the learning rate predicition) for TE1, TE2 and the Unet.
  In this run, `prodigy_steps` was set to `20`, as the optimal LR was found around step 15.

  ![image](https://github.com/user-attachments/assets/d3077b0d-5f23-4500-b2b3-fc0cf45d2da7)

  This image shows a different run with the same dataset, but with `prodigy_steps` set to `0`. While the text encoders were mostly stable, the Unet LR continued to grow throughout training.


pkgId: 97cb4118d1c4c3c1efcdd40b3664139b74c44932ae8ba5b4798cf8edb9feba36
name: python-prodigyopt-help
arch: noarch
version: 1.1.1
epoch: 0
release: 1
summary: Development documents and examples for prodigyopt
url: https://github.com/konstmish/prodigy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prodigyopt-1.1.1-1.src.rpm
location_href: Packages/python-prodigyopt-help-1.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/prodigyopt)](https://pepy.tech/project/prodigyopt) [![Downloads](https://static.pepy.tech/badge/prodigyopt/month)](https://pepy.tech/project/prodigyopt)

  This is the official repository used to run the experiments in the paper that proposed the Prodigy optimizer. The optimizer is implemented in PyTorch.
  There is also a JAX version of [Prodigy in Optax](https://optax.readthedocs.io/en/latest/api/contrib.html#prodigy), which currently does not have the `slice_p` argument.

  **Prodigy: An Expeditiously Adaptive Parameter-Free Learner**
  *K. Mishchenko, A. Defazio*
  Paper: https://arxiv.org/pdf/2306.06101.pdf


  To install the package, simply run
  ```pip install prodigyopt```

  Let `net` be the neural network you want to train. Then, you can use the method as follows:
  ```
  from prodigyopt import Prodigy


  opt = Prodigy(net.parameters(), lr=1., weight_decay=weight_decay, slice_p=slice_p)
  ```
  Note that by default, Prodigy uses weight decay as in AdamW.
  If you want it to use standard $\ell_2$ regularization (as in Adam), use option `decouple=False`.
  We recommend using `lr=1.` (default) for all networks. If you want to force the method to estimate a smaller or larger learning rate,
  it is better to change the value of `d_coef` (1.0 by default). Values of `d_coef` above 1, such as 2 or 10,
  will force a larger estimate of the learning rate; set it to 0.5 or even 0.1 if you want a smaller learning rate.
  Standard values of `weight_decay` to try are 0 (default in Prodigy), 0.001, 0.01 (default in AdamW), and 0.1.
  Use values of `slice_p` larger than 1 to reduce the memory consumption. `slice_p=11` should give a good trade-off
   between accuracy of estimate learning rate and memory efficiency.



  As a rule of thumb, we recommend either using no scheduler or using cosine annealing with the method:
  ```

  scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=total_steps)
  ```
  We do not recommend using restarts in cosine annealing, so we suggest setting `T_max=total_steps`, where
  `total_steps` should be the number of times `scheduler.step()` is called. If you do use restarts, we highly
  recommend setting `safeguard_warmup=True`.

  Extra care should be taken if you use linear warm-up at the beginning:
  The method will see slow progress due to the initially small base learning rate,
  so it might overestimate `d`.
  To avoid issues with warm-up, use option `safeguard_warmup=True`.

  Based on the interaction with some of the users, we recommend setting `safeguard_warmup=True`,
   `use_bias_correction=True`, and `weight_decay=0.01` when training diffusion models.
  Sometimes, [it is helpful](https://github.com/konstmish/prodigy/issues/8) to set `betas=(0.9, 0.99)`.
  If the model is not training, try to keep track of `d` and if it remains too small, [it might be worth increasing `d0`](https://github.com/konstmish/prodigy/issues/27) to 1e-5 or even 1e-4.
  That being said, the optimizer was mostly insensitive to `d0` in our other experiments.



  See [this Colab Notebook](https://colab.research.google.com/drive/1TrhEfI3stJ-yNp7_ZxUAtfWjj-Qe_Hym?usp=sharing)
  for a toy example of how one can use Prodigy to train ResNet-18 on Cifar10 (test accuracy 80% after 20 epochs).
  If you are interested in sharing your experience, please consider creating a Colab Notebook and sharing it in the issues.


  If you find our work useful, please consider citing our paper.
  ```
  @inproceedings{mishchenko2024prodigy,
      title={Prodigy: An Expeditiously Adaptive Parameter-Free Learner},
      author={Mishchenko, Konstantin and Defazio, Aaron},
      booktitle={Forty-first International Conference on Machine Learning},
      year={2024},
      url={https://openreview.net/forum?id=JJpOssn0uP}
  }
  ```


pkgId: 9fbd552387539f10594e879d2bc38cb6a8bb388dd16f5f2b6c5bcdde972a0486
name: python-prodsys-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for prodsys
url: https://pypi.org/project/prodsys/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-prodsys-0.9.2-1.src.rpm
location_href: Packages/python-prodsys-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  ![prodsys logo](https://raw.githubusercontent.com/sdm4fzi/prodsys/main/resources/logo.svg)

  *prodsys - modeling, simulating and optimizing production systems*

  ![Build-sucess](https://img.shields.io/badge/build-success-green)
  ![PyPI](https://img.shields.io/pypi/v/prodsys)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/prodsys)
  ![Docu](https://img.shields.io/badge/docu-full-green)
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10995273.svg)](https://doi.org/10.5281/zenodo.10995273)

  prodsys is a python package for modeling, simulating and optimizing production systems based on the product, process and resource (PPR) modelling principle. For more information, have a look at the [documentation](https://sdm4fzi.github.io/prodsys/).



  To install the package, run the following command in the terminal:

  ```bash
  pip install prodsys
  ```

  Please note that prodsys is currently only fully compatible with Python 3.11. Other versions might cause some errors.



  The package is designed to be easy to use. The following example shows how to model a simple production system and simulate it. The production system contains a single milling machine that performs milling processes on aluminium housings. The transport is thereby performed by a worker.  At first, just import the express API of `prodsys`:

  ```python
  import prodsys.express as psx
  ```

  We now create all components required for describing the production system. At first we define times for all arrival, production and transport processes:

  ```python
  milling_time = psx.FunctionTimeModel(distribution_function="normal", location=1, scale=0.1, ID="milling_time")
  transport_time = psx.FunctionTimeModel(distribution_function="normal", location=0.3, scale=0.2, ID="transport_time")
  arrival_time_of_housings = psx.FunctionTimeModel(distribution_function="exponential", location=1.5, ID="arrival_time_of_housings")
  ```

  Next, we can define the production and transport process in the system by using the created time models:

  ```python
  milling_process = psx.ProductionProcess(milling_time, ID="milling_process")
  transport_process = psx.TransportProcess(transport_time, ID="transport_process")
  ```

  With the processes defined, we can now create the production and transport resources:

  ```python
  milling_machine = psx.ProductionResource([milling_process], location=[5, 5], ID="milling_machine")
  worker = psx.TransportResource([transport_process], location=[0, 0], ID="worker")
  ```

  Now we define our product, the housing, that is produced in the system. For this example it requires only a single processsing step:

  ```python
  housing = psx.Product([milling_process], transport_process, ID="housing")
  ```

  Only the sources and sinks that are responsible for creating the housing and storing finished housing are misssing:

  ```py
  source = psx.Source(housing, arrival_time_of_housings, location=[0, 0], ID="source")
  sink = psx.Sink(housing, location=[20, 20], ID="sink")
  ```

  Finally, we can create our production system, run the simulation for 60 minutes and print aggregated simulation results:

  ```python
  production_system = psx.ProductionSystem([milling_machine, worker], [source], [sink])
  production_system.run(60)
  production_system.runner.print_results()
  ```

  As we can see, the system produced 39 parts in this hour with an work in progress (WIP ~ number of products in the system) of 4.125 and utilized the milling machine with 79.69% and the worker for 78.57% at the PR percentage, the rest of the time, both resource are in standby (SB). Note that these results stay the same although there are stochastic processes in the simulation. This is caused by seeding the random number generator with a fixed value. If you want to get different results, just specify another value for `seed` parameter from the `run` method.

  ``` python
  production_system.run(60, seed=1)
  production_system.runner.print_results()
  ```

  As expected, the performance of the production system changed quite strongly with the new parameters. The system now produces 26 parts in this hour with an work in progress (WIP ~ number of products in the system) of 1.68. As the arrival process of the housing is modelled by an exponential distribution and we only consider 60 minutes of simulation, this is absolutely expected.

  However, running longer simulations with multiple seeds is absolutely easy with `prodsys`. We average our results at the end to calculate the WIP to expect by utilizing the post_processor of the runner, which stores all events of a simulation and has many useful methods for analyzing the simulation results:

  ```python
  wip_values = []

  for seed in range(5):
      production_system.run(2000, seed=seed)
      run_wip = production_system.post_processor.get_aggregated_wip_data()
      wip_values.append(run_wip)

  print("WIP values for the simulation runs:", wip_values)
  ```

  We can analyze these results easily with numpy seeing that the average WIP is 2.835, which is in between the two first runs, which gives us a more realistic expectation of the system's performance.

  ```python
  import numpy as np
  wip = np.array(wip_values).mean(axis=0)
  print(wip)
  ```

  These examples only cover the most basic functionalities of `prodsys`. For more elaborate guides that guide you through more of the package's features, please see the [tutorials](https://sdm4fzi.github.io/prodsys/Tutorials/tutorial_0_overview). For a complete overview of the package's functionality, please see the [API reference](https://sdm4fzi.github.io/prodsys/API_reference/API_reference_0_overview/).



  prodsys cannot only be used as a python package, but can also be used as a webserver by interacting with its REST API. All features of prodsys are also available in the API and allow easy integration of prodsys in operative IT architectures.

  The API is based on the [FastAPI](https://fastapi.tiangolo.com/) framework and utilizes the models API of prodsys. To use prodsys as a webserver, you can use the official docker image which can be obtained from dockerhub:

  ```bash
  docker pull sebbehrendt/prodsys
  ```

  To start the API, run the following command:

  ```bash
  docker run -p 8000:8000 sebbehrendt/prodsys
  ```

  The API documentation is then available at `http://localhost:8000/docs`.



  `prodsys` is a new project and has therefore much room for improvement. Therefore, it would be a pleasure to get feedback or support! If you want to contribute to the package, either create issues on [prodsys' github page](https://github.com/sdm4fzi/prodsys) for discussing new features or contact me directly via [github](https://github.com/SebBehrendt) or [email](mailto:sebastian.behrendt@kit.edu).



  The package is licensed under the [MIT license](LICENSE).



  We extend our sincere thanks to the German Federal Ministry for Economic Affairs and Climate Action
  (BMWK) for supporting this research project 13IK001ZF “Software-Defined Manufacturing for the
  automotive and supplying industry [https://www.sdm4fzi.de/](https://www.sdm4fzi.de/).

  MIT License

  Copyright (c) 2023 sebastian.behrendt

  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: 5b568181cb2a50e843ef17f77e69c38201f6fd20fb044968611079f9c5e2a183
name: python-profila-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for profila
url: https://github.com/pythonspeed/profila
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-profila-0.3.0-1.src.rpm
location_href: Packages/python-profila-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  **This profiler is sponsored by my book on [writing fast low-level code in Python](https://pythonspeed.com/products/lowlevelcode/), which uses Numba for most of its examples.**

  Here's what Profila output looks like:

  ```
  $ python -m profila annotate -- scripts_for_tests/simple.py



  Lines 10 to 15:

    0.3% |     for i in range(len(timeseries)):
         |         # This should be the most expensive line:
   38.7% |         result[i] = (7 + timeseries[i] / 9 + (timeseries[i] ** 2) / 7) / 5
         |     for i in range(len(result)):
         |         # This should be cheaper:
    4.3% |         result[i] -= 1
  ```

  You can also use it with Jupyter!

  Beyond this README, you can also [read this introductory article with a more detailed example and explanations](https://pythonspeed.com/articles/numba-profiling/).

  **TL;DR limitations:** Linux only, and only single-threaded Numba can be profiled currently, parallel functions are not yet supported.



  Currently Profila works on Linux only.

  * On macOS you can use Docker, Podman, or a Linux VM.
  * On Windows you can use Docker, Podman, or probably WSL2.

  You'll need `gdb` installed.
  On Ubuntu or Debian you can do:

  ```bash
  apt-get install gdb
  ```

  On RedHat-based systems:

  ```bash
  dnf install gdb
  ```

  Install this library using `pip`:

  ```bash
  pip install profila
  ```





  First, before you `import numba` you should:

  ```python
  %load_ext profila
  ```

  Then define your functions as usual:

  ```python
  from numba import njit

  @njit
  def myfunc(arr):
      
  ```

  You probably want to call your Numba function at least once, so profiling doesn't measure compilation time:

  ```python
  myfunc(DATA)
  ```

  Then, you can profile a specific cell using the `%profila` magic, e.g.

  ```python
  %profila

  for i in range(100):
      myfunc(DATA)
  ```



  If you usually run your script like this:

  ```bash
  $ python yourscript.py --arg1=200
  ```

  Instead run it like this:

  ```bash
  $ python -m profila annotate -- yourscript.py --arg1=200
  ```

  If you usually run your script like this, with `-m`:

  ```bash
  $ python -m yourpackage --arg1=200
  ```

  Instead run it like this:

  ```bash
  $ python -m profila annotate -- -m yourpackage --arg1=200
  ```

  **Sampling is done every 10 milliseconds, so you need to make sure your Numba code runs for a sufficiently long time.**
  For example, you can run your function in a loop until a number of seconds has passed:

  ```python
  from time import time

  @njit
  def myfunc():
      

  start = time()

  while (time() - start) < 3:
      myfunc()
  ```



  * Parallel Numba code will not be profiled correctly; at the moment only single-threaded profiling is supported.
  * GPU (CUDA) code is not profiled.

  Beyond that:



  Compiled languages like Numba do optimization passes and transform the code to make it faster.
  That means the running code doesn't necessarily map one to one to the original code; different lines might be combined, for example.

  As far as I can tell Numba does give you a reasonable mapping, but you can't assume the source code maps one to one to executed code.



  In order to profile, additional info needs to be added during compilation; specifically, the `NUMBA_DEBUGINFO` env variable is set.
  This might change runtime characteristics slightly, because it increases the memory size of the compiled code.



  Instruction-level parallelism, branch mispredictions, SIMD, and the CPU memory caches all have a significant impact on runtime performance, but they don't show up in profiling.
  [I'm writing a book about this if you want to learn more](https://pythonspeed.com/products/lowlevelcode/).





  Bug fixes:

  * Work on newer versions of Linux, like Ubuntu 24.04 and RHEL 9, in the face of issues with newer gdb.
  * Fixed occasional error `TypeError: argument of type 'NoneType' is not iterable`.



  Bug fixes:

  * Run Python using `sys.executable`, so it works in more environments.
    Thanks to Jeremiah England for the bug report.



  Added support for Jupyter profiling.



  Initial release.


pkgId: 05d10f2acc33ba0d053a2502838ec3acc67316f12617ebe24a397c6b909250d4
name: python-progiclone-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for progiclone
url: https://github.com/valent1d/progiclone
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-progiclone-1.0.0-1.src.rpm
location_href: Packages/python-progiclone-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  **🚨 Utilisation Responsable 🚨**
  Cet outil est destiné à la protection des données personnelles. Utilisez-le de manière éthique et conformément aux réglementations en vigueur.


pkgId: fa4947f9cd894b2c98ac45b3a4b0bac21fe9494b285077365f071ac4b956770a
name: python-projen-help
arch: noarch
version: 0.91.0
epoch: 0
release: 1
summary: Development documents and examples for projen
url: https://github.com/projen/projen.git
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-projen-0.91.0-1.src.rpm
location_href: Packages/python-projen-help-0.91.0-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://projen.io">
      <img src="https://raw.githubusercontent.com/projen/projen/main/logo/projen.svg">
      <h3 align="center">projen</h3>
    </a>
  </p><p align="center">
    Define and maintain complex project configuration through code.
  </p><p align="center">
    <a href="https://projen.io/"><strong>Documentation</strong></a> ·
    <a href="https://github.com/projen/projen/releases"><strong>Changelog</strong></a> ·
    <a href="#project-types"><strong>Project types</strong></a> ·
    <a href="#community"><strong>Join the community</strong></a>
  </p><p align="center">
    <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache%202.0-yellowgreen.svg" alt="Apache 2.0 License"></a>
    <a href="https://gitpod.io/#https://github.com/projen/projen"><img src="https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod" alt="Gitpod ready-to-code"></a>
    <a href="https://github.com/projen/projen/actions/workflows/release.yml"><img src="https://github.com/projen/projen/actions/workflows/release.yml/badge.svg" alt="Release badge"></a>
    <a href="https://github.com/projen/projen/commits/main"><img src="https://img.shields.io/github/commit-activity/w/projen/projen" alt="Commit activity"></a>
  </p><br/>

  *projen* synthesizes project configuration files such as `package.json`,
  `tsconfig.json`, `.gitignore`, GitHub Workflows, eslint, jest, etc. from a
  well-typed definition written in JavaScript.

  As opposed to existing templating/scaffolding tools, *projen* is not a one-off
  generator. Synthesized files should never be manually edited (in fact, projen
  enforces that). To modify your project setup, users interact with rich
  strongly-typed class and execute `projen` to update their project configuration
  files.

  By defining a custom project type and using projen in multiple repositories, it's
  possible to update configuration files and CI/CD workflows across dozens (or
  hundreds!?) of projects.

  Check out [this talk](https://youtu.be/SOWMPzXtTCw) about projen from its creator.



  *projen* doesn't need to be installed. You will be using [npx](https://docs.npmjs.com/cli/v7/commands/npx) to run *projen* which takes care of all required setup steps.

  To create a new project, run the following command and follow the instructions:

  ```console
  $ mkdir my-project
  $ cd my-project
  $ npx projen new PROJECT-TYPE
  🤖 Synthesizing project...
  ...
  ```



  Currently supported project types (use `npx projen new` without a type for a
  full list):

  **Built-in:** (run `npx projen new <type>`)

  <!-- <macro exec="node ./scripts/readme-projects.js"> -->

  * [awscdk-app-java](https://projen.io/docs/api/awscdk#awscdkjavaapp-) - AWS CDK app in Java.
  * [awscdk-app-py](https://projen.io/docs/api/awscdk#awscdkpythonapp-) - AWS CDK app in Python.
  * [awscdk-app-ts](https://projen.io/docs/api/awscdk#awscdktypescriptapp-) - AWS CDK app in TypeScript.
  * [awscdk-construct](https://projen.io/docs/api/awscdk#awscdkconstructlibrary-) - AWS CDK construct library project.
  * [cdk8s-app-py](https://projen.io/docs/api/cdk8s#cdk8spythonapp-) - CDK8s app in Python.
  * [cdk8s-app-ts](https://projen.io/docs/api/cdk8s#cdk8stypescriptapp-) - CDK8s app in TypeScript.
  * [cdk8s-construct](https://projen.io/docs/api/cdk8s#constructlibrarycdk8s-) - CDK8s construct library project.
  * [cdktf-construct](https://projen.io/docs/api/cdktf#constructlibrarycdktf-) - CDKTF construct library project.
  * [java](https://projen.io/docs/api/java#javaproject-) - Java project.
  * [jsii](https://projen.io/docs/api/cdk#jsiiproject-) - Multi-language jsii library project.
  * [nextjs](https://projen.io/docs/api/web#nextjsproject-) - Next.js project using JavaScript.
  * [nextjs-ts](https://projen.io/docs/api/web#nextjstypescriptproject-) - Next.js project using TypeScript.
  * [node](https://projen.io/docs/api/javascript#nodeproject-) - Node.js project.
  * [project](https://projen.io/docs/api/projen#project-) - Base project.
  * [python](https://projen.io/docs/api/python#pythonproject-) - Python project.
  * [react](https://projen.io/docs/api/web#reactproject-) - React project using JavaScript.
  * [react-ts](https://projen.io/docs/api/web#reacttypescriptproject-) - React project using TypeScript.
  * [typescript](https://projen.io/docs/api/typescript#typescriptproject-) - TypeScript project.
  * [typescript-app](https://projen.io/docs/api/typescript#typescriptappproject-) - TypeScript app.

  <!-- </macro> -->

  **External:** (run `npx projen new --from <type>`)

  * [projen-github-action-typescript](https://github.com/projen/projen-github-action-typescript/blob/main/API.md) - GitHub Action in TypeScript project.

  > Use `npx projen new PROJECT-TYPE --help` to view a list of command line
  > switches that allows you to specify most project options during bootstrapping.
  > For example: `npx projen new jsii --author-name "Jerry Berry"`.

  The `new` command will create a `.projenrc.js` file which looks like this for
  `jsii` projects:

  ```js
  const { JsiiProject } = require('projen');

  const project = new JsiiProject({
    authorAddress: "elad.benisrael@gmail.com",
    authorName: "Elad Ben-Israel",
    name: "foobar",
    repository: "https://github.com/eladn/foobar.git",
  });

  project.synth();
  ```

  This program instantiates the project type with minimal setup, and then calls
  `synth()` to synthesize the project files. By default, the `new` command will
  also execute this program, which will result in a fully working project.

  Once your project is created, you can configure your project by editing
  `.projenrc.js` and re-running `npx projen` to synthesize again.

  > The files generated by *projen* are considered an "implementation detail" and
  > *projen* protects them from being manually edited (most files are marked
  > read-only, and an "anti tamper" check is configured in the CI build workflow
  > to ensure that files are not updated during build).

  For example, to setup PyPI publishing in `jsii` projects, you can use
  [`publishToPypi option`](https://projen.io/publisher.html):

  ```js
  const project = new JsiiProject({
    // ...
    publishToPypi: {
      distName: "mydist",
      module: "my_module",
    }
  });
  ```

  Run:

  ```shell
  npx projen
  ```

  And you'll notice that your `package.json` file now contains a `python` section in
  its `jsii` config and the GitHub `release.yml` workflow includes a PyPI
  publishing step.

  We recommend to put this in your shell profile, so you can simply run `pj` every
  time you update `.projenrc.js`:

  ```bash
  alias pj='npx projen'
  ```

  Most projects come with an assortment of **tasks** that handle various
  development activities, from compiling to publishing. Tasks can be and composed
  together, and can be run as local commands or turned into GitHub workflows. You
  can list all tasks with `npx projen --help`:

  ```shell
  $ npx projen --help
  projen [command]

  Commands:
    projen new [PROJECT-TYPE-NAME] [OPTIONS]  Creates a new projen project
    projen clobber                            hard resets to HEAD of origin and cleans the local repo
    projen compile                            Only compile
    projen test                               Run tests
    projen build                              Full release build (test+compile)
    projen upgrade                            upgrade dependencies (including projen)
  ...
  ```

  The `build` task is the same task that's executed in your CI builds. It
  typically compiles, lints, tests and packages your module for distribution.



  If installed as a global package, `projen` includes rich shell tab-completion support. To enable this in your shell, run:

  ```shell

  projen completion >> ~/.bashrc


  projen completion >> ~/.zshrc
  ```



  Some examples of features built-in to project types:

  * Fully synthesize `package.json`
  * Standard npm scripts like `compile`, `build`, `test`, `package`
  * eslint
  * Jest
  * jsii: compile, package, api compatibility checks, API.md
  * Bump & release scripts with CHANGELOG generation based on conventional commits
  * Automated PR builds
  * Automated releases to npm, maven, NuGet and PyPI
  * Automated dependency upgrades
  * Mergify configuration
  * LICENSE file generation
  * gitignore + npmignore management
  * Node "engines" support with coupling to CI build environment and @types/node
  * Anti-tamper: CI builds will fail if a synthesized file is modified manually



  For documentation including examples and a full API reference, visit [https://projen.io/](https://projen.io/).



  *projen* takes a "batteries included" approach and aims to offer dozens of different project types out of
  the box (we are just getting started). Think `projen new react`, `projen new angular`, `projen new java-maven`,
  `projen new awscdk-typescript`, `projen new cdk8s-python` (nothing in projen is tied to javascript or npm!)...

  Adding new project types is as simple as submitting a pull request to this repo and exporting a class that
  extends `projen.Project` (or one of its derivatives). Projen automatically discovers project types so your
  type will immediately be available in `projen new`.



  *projen* is bundled with many project types out of the box, but it can also work
  with project types and components defined in external jsii modules (the reason
  we need jsii is because projen uses the jsii metadata to discover project types
  & options in projen new).

  Say we have a module in npm called `projen-vuejs` which includes a single project
  type for vue.js:

  ```bash
  $ npx projen new --from projen-vuejs
  ```

  If the referenced module includes multiple project types, the type is required.
  Switches can also be used to specify initial values based on the project type
  APIs. You can also use any package syntax supported by [yarn
  add](https://classic.yarnpkg.com/en/docs/cli/add#toc-adding-dependencies) like
  `projen-vuejs@1.2.3`, `file:/path/to/local/folder`,
  `git@github.com/awesome/projen-vuejs#1.2.3`, etc.

  ```bash
  $ npx projen new --from projen-vuejs@^2 vuejs-ts --description "my awesome vue project"
  ```

  Under the hood, `projen new` will install the `projen-vuejs` module from npm
  (version 2.0.0 and above), discover the project types in it and bootstrap the
  `vuejs-ts` project type. It will assign the value `"my awesome vue project"` to
  the `description` field. If you examine your `.projenrc.js` file, you'll see
  that `projen-vuejs` is defined as a dev dependency:

  ```javascript
  const { VueJsProject } = require('projen-vuejs');

  const project = new VueJsProject({
    name: 'my-vuejs-sample',
    description: "my awesome vue project",
    // ...
    devDeps: [
      'projen-vuejs'
    ]
  });

  project.synth();
  ```



  See [Vision](./VISION.md).





  Not at all! JavaScript is the default, but it's also possible to write it in
  Java, Python, TypeScript, or even JSON. This is made
  possible by the [jsii](https://github.com/aws/jsii) library which allows us
  to write APIs once and generate libraries in several languages. You can choose
  a different language by passing the `--projenrc-ts`, `--projenrc-py`, `--projenrc-java`, or
  `--projenrc-json` flags when running `projen new`.

  Note: using a `.projenrc.json` file to specify configuration only allows
  accessing a subset of the entire API - the options which are passed to the
  constructor of each project type.



  projen has an unofficial [VS Code extension](https://marketplace.visualstudio.com/items?itemName=MarkMcCulloh.vscode-projen). Check it out!



  The projen community can be found within the #projen channel in the [cdk.dev](https://cdk.dev/)
  community Slack workspace.



  * Thursday June 30, 2022
  * 1-2pm America/New_York (EDT)
  * [CFP](https://bit.ly/3NEc0UQ) a Google Form
  * CFP Closes Saturday April 30, 2022
  * Hosted on [Zoom](https://zoom.us/j/92399854777?pwd=OUZybHlobHNoZUs1VVordWhaRTVGdz09#success)



  Contributions of all kinds are welcome! Check out our [contributor's
  guide](./CONTRIBUTING.md) and our [code of conduct](./CODE_OF_CONDUCT.md).

  For a quick start, check out a development environment:

  ```bash
  $ git clone git@github.com:projen/projen
  $ cd projen
  $ yarn
  $ yarn watch # compile in the background
  ```

  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->

  [![All Contributors](https://img.shields.io/badge/all_contributors-193-orange.svg?style=flat-square)](#contributors-)

  <!-- ALL-CONTRIBUTORS-BADGE:END --><!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section --><!-- prettier-ignore-start --><!-- markdownlint-disable --><table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Hunter-Thompson"><img src="https://avatars.githubusercontent.com/u/20844961?v=4?s=100" width="100px;" alt=" Aatman "/><br /><sub><b> Aatman </b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Hunter-Thompson" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://accenture.github.io/"><img src="https://avatars.githubusercontent.com/u/43275295?v=4?s=100" width="100px;" alt="Abdullah Sahin"/><br /><sub><b>Abdullah Sahin</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=abdsahin" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://adam.dev/"><img src="https://avatars.githubusercontent.com/u/2363879?v=4?s=100" width="100px;" alt="Adam"/><br /><sub><b>Adam</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=adamdottv" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://adamelkhayyat.github.io/"><img src="https://avatars.githubusercontent.com/u/19326038?v=4?s=100" width="100px;" alt="Adam ElKhayyat"/><br /><sub><b>Adam ElKhayyat</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=adamelkhayyat" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/adamelmore"><img src="https://avatars2.githubusercontent.com/u/2363879?v=4?s=100" width="100px;" alt="Adam Elmore"/><br /><sub><b>Adam Elmore</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=adamelmore" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/agdimech"><img src="https://avatars.githubusercontent.com/u/51220968?v=4?s=100" width="100px;" alt="Adrian Dimech"/><br /><sub><b>Adrian Dimech</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=agdimech" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/adrianmace"><img src="https://avatars.githubusercontent.com/u/5071859?v=4?s=100" width="100px;" alt="Adrian Mace"/><br /><sub><b>Adrian Mace</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=adrianmace" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/alejandrolorefice"><img src="https://avatars.githubusercontent.com/u/24880460?v=4?s=100" width="100px;" alt="Alejandro Lorefice"/><br /><sub><b>Alejandro Lorefice</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=alejandrolorefice" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/alexforsyth"><img src="https://avatars.githubusercontent.com/u/8712303?v=4?s=100" width="100px;" alt="Alexander Forsyth"/><br /><sub><b>Alexander Forsyth</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=alexforsyth" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://unsubstantiated.blog/"><img src="https://avatars.githubusercontent.com/u/1308885?v=4?s=100" width="100px;" alt="Alexander Steppke"/><br /><sub><b>Alexander Steppke</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Miradorn" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://amani.kilumanga.com/"><img src="https://avatars.githubusercontent.com/u/8690282?v=4?s=100" width="100px;" alt="Amani Kilumanga"/><br /><sub><b>Amani Kilumanga</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dkaksl" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://amin.fazl.me/"><img src="https://avatars.githubusercontent.com/u/62678026?v=4?s=100" width="100px;" alt="Amin Fazl"/><br /><sub><b>Amin Fazl</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=AminFazlMondo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://kichik.com/"><img src="https://avatars.githubusercontent.com/u/1156773?v=4?s=100" width="100px;" alt="Amir Szekely"/><br /><sub><b>Amir Szekely</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kichik" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.linkedin.com/in/amartinsg/"><img src="https://avatars.githubusercontent.com/u/54241354?v=4?s=100" width="100px;" alt="Anderson Gomes"/><br /><sub><b>Anderson Gomes</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=andersonmgomes" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/asdcamargo"><img src="https://avatars.githubusercontent.com/u/4683431?v=4?s=100" width="100px;" alt="Andre de Camargo"/><br /><sub><b>Andre de Camargo</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=asdcamargo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://comfortabledelusions.blogspot.com/"><img src="https://avatars.githubusercontent.com/u/445764?v=4?s=100" width="100px;" alt="Andrew Hammond"/><br /><sub><b>Andrew Hammond</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=ahammond" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://apkostka.com/"><img src="https://avatars.githubusercontent.com/u/788482?v=4?s=100" width="100px;" alt="Andrew Kostka"/><br /><sub><b>Andrew Kostka</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=apkostka" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dippi"><img src="https://avatars.githubusercontent.com/u/3977098?v=4?s=100" width="100px;" alt="Angelo Di Pilla"/><br /><sub><b>Angelo Di Pilla</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dippi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://ansgar.dev/"><img src="https://avatars.githubusercontent.com/u/1112056?v=4?s=100" width="100px;" alt="Ansgar Mertens"/><br /><sub><b>Ansgar Mertens</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=ansgarm" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/yoyomo"><img src="https://avatars.githubusercontent.com/u/12818568?v=4?s=100" width="100px;" alt="Armando J. Ortiz Garcia"/><br /><sub><b>Armando J. Ortiz Garcia</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=yoyomo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dontirun"><img src="https://avatars.githubusercontent.com/u/4570879?v=4?s=100" width="100px;" alt="Arun Donti"/><br /><sub><b>Arun Donti</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dontirun" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/abelmokadem"><img src="https://avatars0.githubusercontent.com/u/9717944?v=4?s=100" width="100px;" alt="Ash"/><br /><sub><b>Ash</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=abelmokadem" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://austinbriggs.dev/"><img src="https://avatars.githubusercontent.com/u/7308231?v=4?s=100" width="100px;" alt="Austin"/><br /><sub><b>Austin</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=awbdallas" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kanatti"><img src="https://avatars.githubusercontent.com/u/8623654?v=4?s=100" width="100px;" alt="Balagopal Kanattil"/><br /><sub><b>Balagopal Kanattil</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kanatti" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.callant.net/"><img src="https://avatars1.githubusercontent.com/u/5915843?v=4?s=100" width="100px;" alt="Bart Callant"/><br /><sub><b>Bart Callant</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=bartcallant" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://beau.sh/"><img src="https://avatars.githubusercontent.com/u/127320?v=4?s=100" width="100px;" alt="Beau Bouchard"/><br /><sub><b>Beau Bouchard</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=BeauBouchard" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://benlimmer.com/"><img src="https://avatars.githubusercontent.com/u/630449?v=4?s=100" width="100px;" alt="Ben Limmer"/><br /><sub><b>Ben Limmer</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=blimmer" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://bilalquadri.com/"><img src="https://avatars.githubusercontent.com/u/707147?v=4?s=100" width="100px;" alt="Bilal Quadri"/><br /><sub><b>Bilal Quadri</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=bilalq" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://transacid.de/"><img src="https://avatars.githubusercontent.com/u/113231?v=4?s=100" width="100px;" alt="Boris Petersen"/><br /><sub><b>Boris Petersen</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=transacid" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/BradenM"><img src="https://avatars.githubusercontent.com/u/5913808?v=4?s=100" width="100px;" alt="Braden Mars"/><br /><sub><b>Braden Mars</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=BradenM" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bmiller08"><img src="https://avatars.githubusercontent.com/u/13002874?v=4?s=100" width="100px;" alt="Brandon Miller"/><br /><sub><b>Brandon Miller</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=bmiller08" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bhleonard"><img src="https://avatars.githubusercontent.com/u/1961679?v=4?s=100" width="100px;" alt="Brian Leonard"/><br /><sub><b>Brian Leonard</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=bhleonard" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/comcalvi"><img src="https://avatars.githubusercontent.com/u/66279577?v=4?s=100" width="100px;" alt="Calvin Combs"/><br /><sub><b>Calvin Combs</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=comcalvi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cameroncf"><img src="https://avatars.githubusercontent.com/u/789760?v=4?s=100" width="100px;" alt="Cameron Childress"/><br /><sub><b>Cameron Childress</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=cameroncf" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/campionfellin"><img src="https://avatars3.githubusercontent.com/u/11984923?v=4?s=100" width="100px;" alt="Campion Fellin"/><br /><sub><b>Campion Fellin</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=campionfellin" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://medium.com/@caodanju"><img src="https://avatars.githubusercontent.com/u/18650321?v=4?s=100" width="100px;" alt="Cao Peng"/><br /><sub><b>Cao Peng</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=caopengau" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ctasada"><img src="https://avatars.githubusercontent.com/u/1381772?v=4?s=100" width="100px;" alt="Carlos Tasada"/><br /><sub><b>Carlos Tasada</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=ctasada" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://chrisb.cloud/"><img src="https://avatars.githubusercontent.com/u/12206103?v=4?s=100" width="100px;" alt="Chris Bateman"/><br /><sub><b>Chris Bateman</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=chris-bateman" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cgatt"><img src="https://avatars.githubusercontent.com/u/45865322?v=4?s=100" width="100px;" alt="Chris Gatt"/><br /><sub><b>Chris Gatt</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=cgatt" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://rybicki.io/"><img src="https://avatars2.githubusercontent.com/u/5008987?v=4?s=100" width="100px;" alt="Christopher Rybicki"/><br /><sub><b>Christopher Rybicki</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Chriscbr" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/corymhall"><img src="https://avatars.githubusercontent.com/u/43035978?v=4?s=100" width="100px;" alt="Cory Hall"/><br /><sub><b>Cory Hall</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=corymhall" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://aws.amazon.com/chime/chime-sdk/"><img src="https://avatars.githubusercontent.com/u/71404236?v=4?s=100" width="100px;" alt="Court Schuett"/><br /><sub><b>Court Schuett</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=schuettc" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://medium.com/@craig.burdulis"><img src="https://avatars.githubusercontent.com/u/12520946?v=4?s=100" width="100px;" alt="Craig Burdulis"/><br /><sub><b>Craig Burdulis</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=icj217" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://pallares.io/"><img src="https://avatars3.githubusercontent.com/u/1077520?v=4?s=100" width="100px;" alt="Cristian Pallarés"/><br /><sub><b>Cristian Pallarés</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=skyrpex" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://danielmschmidt.de/"><img src="https://avatars.githubusercontent.com/u/1337046?v=4?s=100" width="100px;" alt="Daniel Schmidt"/><br /><sub><b>Daniel Schmidt</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=DanielMSchmidt" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://typefully.com/dannysteenman"><img src="https://avatars.githubusercontent.com/u/15192660?v=4?s=100" width="100px;" alt="Danny Steenman"/><br /><sub><b>Danny Steenman</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dannysteenman" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dkershner6"><img src="https://avatars.githubusercontent.com/u/25798427?v=4?s=100" width="100px;" alt="Derek Kershner"/><br /><sub><b>Derek Kershner</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dkershner6" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/eduardomourar"><img src="https://avatars.githubusercontent.com/u/16357187?v=4?s=100" width="100px;" alt="Eduardo Rodrigues"/><br /><sub><b>Eduardo Rodrigues</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=eduardomourar" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://eladb.github.com/"><img src="https://avatars3.githubusercontent.com/u/598796?v=4?s=100" width="100px;" alt="Elad Ben-Israel"/><br /><sub><b>Elad Ben-Israel</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=eladb" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/iliapolo"><img src="https://avatars.githubusercontent.com/u/1428812?v=4?s=100" width="100px;" alt="Eli Polonsky"/><br /><sub><b>Eli Polonsky</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=iliapolo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://elig.io/"><img src="https://avatars.githubusercontent.com/u/22875166?v=4?s=100" width="100px;" alt="Eligio Mariño"/><br /><sub><b>Eligio Mariño</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=gmeligio" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Tucker-Eric"><img src="https://avatars.githubusercontent.com/u/6483755?v=4?s=100" width="100px;" alt="Eric Tucker"/><br /><sub><b>Eric Tucker</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Tucker-Eric" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/echeung-amzn"><img src="https://avatars.githubusercontent.com/u/81188333?v=4?s=100" width="100px;" alt="Eugene Cheung"/><br /><sub><b>Eugene Cheung</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=echeung-amzn" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/FonsBiemans"><img src="https://avatars.githubusercontent.com/u/34266227?v=4?s=100" width="100px;" alt="Fons Biemans"/><br /><sub><b>Fons Biemans</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=FonsBiemans" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/froblesmartin"><img src="https://avatars.githubusercontent.com/u/18084174?v=4?s=100" width="100px;" alt="Francisco Robles Martín"/><br /><sub><b>Francisco Robles Martín</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=froblesmartin" title="Documentation">📖</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/fynnfluegge"><img src="https://avatars.githubusercontent.com/u/16321871?v=4?s=100" width="100px;" alt="Fynn Flügge"/><br /><sub><b>Fynn Flügge</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=fynnfluegge" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/garysassano"><img src="https://avatars.githubusercontent.com/u/10464497?v=4?s=100" width="100px;" alt="Gary Sassano"/><br /><sub><b>Gary Sassano</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=garysassano" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/gradybarrett"><img src="https://avatars1.githubusercontent.com/u/1140074?v=4?s=100" width="100px;" alt="Grady Barrett"/><br /><sub><b>Grady Barrett</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=gradybarrett" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://blog.herlein.com/"><img src="https://avatars.githubusercontent.com/u/173428?v=4?s=100" width="100px;" alt="Greg Herlein"/><br /><sub><b>Greg Herlein</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=gherlein" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/GreggSetzer"><img src="https://avatars.githubusercontent.com/u/1624443?v=4?s=100" width="100px;" alt="Gregg"/><br /><sub><b>Gregg</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=GreggSetzer" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hasanaburayyan"><img src="https://avatars.githubusercontent.com/u/45375125?v=4?s=100" width="100px;" alt="Hasan"/><br /><sub><b>Hasan</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=hasanaburayyan" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hassanazharkhan"><img src="https://avatars.githubusercontent.com/u/57677979?v=4?s=100" width="100px;" alt="Hassan Azhar"/><br /><sub><b>Hassan Azhar</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=hassanazharkhan" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/HassanMahmud"><img src="https://avatars3.githubusercontent.com/u/58504381?v=4?s=100" width="100px;" alt="Hassan Mahmud"/><br /><sub><b>Hassan Mahmud</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=HassanMahmud" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://dk.linkedin.com/in/hassanmahmud93"><img src="https://avatars1.githubusercontent.com/u/7426703?v=4?s=100" width="100px;" alt="Hassan Mahmud"/><br /><sub><b>Hassan Mahmud</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=hass123uk" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mKeRix"><img src="https://avatars.githubusercontent.com/u/770596?v=4?s=100" width="100px;" alt="Heiko Rothe"/><br /><sub><b>Heiko Rothe</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mKeRix" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hyandell"><img src="https://avatars.githubusercontent.com/u/477715?v=4?s=100" width="100px;" alt="Henri Yandell"/><br /><sub><b>Henri Yandell</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=hyandell" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/henrysachs"><img src="https://avatars0.githubusercontent.com/u/17173951?v=4?s=100" width="100px;" alt="Henry Sachs"/><br /><sub><b>Henry Sachs</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=henrysachs" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://blog.hoseung.me/"><img src="https://avatars.githubusercontent.com/u/39669819?v=4?s=100" width="100px;" alt="Hoseung"/><br /><sub><b>Hoseung</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=HoseungJang" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://bandism.net/"><img src="https://avatars.githubusercontent.com/u/22633385?v=4?s=100" width="100px;" alt="Ikko Ashimine"/><br /><sub><b>Ikko Ashimine</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=eltociear" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jackleslie"><img src="https://avatars.githubusercontent.com/u/52004409?v=4?s=100" width="100px;" alt="Jack Leslie"/><br /><sub><b>Jack Leslie</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jackleslie" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JackMoseley2001"><img src="https://avatars.githubusercontent.com/u/10659397?v=4?s=100" width="100px;" alt="Jack Moseley"/><br /><sub><b>Jack Moseley</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=JackMoseley2001" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/cogwirrel"><img src="https://avatars.githubusercontent.com/u/1848603?v=4?s=100" width="100px;" alt="Jack Stevenson"/><br /><sub><b>Jack Stevenson</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=cogwirrel" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jmourelos"><img src="https://avatars3.githubusercontent.com/u/3878434?v=4?s=100" width="100px;" alt="Jacob"/><br /><sub><b>Jacob</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jmourelos" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://joapy.com/"><img src="https://avatars3.githubusercontent.com/u/325306?v=4?s=100" width="100px;" alt="Jake Pearson"/><br /><sub><b>Jake Pearson</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jakepearson" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://twitter.com/bracki"><img src="https://avatars.githubusercontent.com/u/49786?v=4?s=100" width="100px;" alt="Jan Brauer"/><br /><sub><b>Jan Brauer</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=bracki" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jmalins"><img src="https://avatars.githubusercontent.com/u/2001356?v=4?s=100" width="100px;" alt="Jeff Malins"/><br /><sub><b>Jeff Malins</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jmalins" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JeremyJonas"><img src="https://avatars1.githubusercontent.com/u/464119?v=4?s=100" width="100px;" alt="Jeremy Jonas"/><br /><sub><b>Jeremy Jonas</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=JeremyJonas" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jesse-grabowski"><img src="https://avatars.githubusercontent.com/u/2453853?v=4?s=100" width="100px;" alt="Jesse Grabowski"/><br /><sub><b>Jesse Grabowski</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jesse-grabowski" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jolo-dev"><img src="https://avatars.githubusercontent.com/u/54506108?v=4?s=100" width="100px;" alt="JoLo"/><br /><sub><b>JoLo</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jolo-dev" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/devnoo"><img src="https://avatars.githubusercontent.com/u/94448?v=4?s=100" width="100px;" alt="Job de Noo"/><br /><sub><b>Job de Noo</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=devnoo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/jogold"><img src="https://avatars2.githubusercontent.com/u/12623249?v=4?s=100" width="100px;" alt="Jonathan Goldwasser"/><br /><sub><b>Jonathan Goldwasser</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jogold" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/joostvdwsd"><img src="https://avatars.githubusercontent.com/u/25637088?v=4?s=100" width="100px;" alt="Joost van der Waal"/><br /><sub><b>Joost van der Waal</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=joostvdwsd" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/JordanSinko"><img src="https://avatars2.githubusercontent.com/u/10212966?v=4?s=100" width="100px;" alt="Jordan Sinko"/><br /><sub><b>Jordan Sinko</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=JordanSinko" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/eganjs"><img src="https://avatars3.githubusercontent.com/u/6639482?v=4?s=100" width="100px;" alt="Joseph Egan"/><br /><sub><b>Joseph Egan</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=eganjs" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/misterjoshua"><img src="https://avatars2.githubusercontent.com/u/644092?v=4?s=100" width="100px;" alt="Josh Kellendonk"/><br /><sub><b>Josh Kellendonk</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=misterjoshua" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/juho9000"><img src="https://avatars.githubusercontent.com/u/13867853?v=4?s=100" width="100px;" alt="Juho Majasaari"/><br /><sub><b>Juho Majasaari</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=juho9000" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Hi-Fi"><img src="https://avatars.githubusercontent.com/u/1499780?v=4?s=100" width="100px;" alt="Juho Saarinen"/><br /><sub><b>Juho Saarinen</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Hi-Fi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.linkedin.com/in/julian-michel-812a223a/"><img src="https://avatars.githubusercontent.com/u/15660169?v=4?s=100" width="100px;" alt="Julian Michel"/><br /><sub><b>Julian Michel</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=jumic" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kaizencc"><img src="https://avatars.githubusercontent.com/u/36202692?v=4?s=100" width="100px;" alt="Kaizen Conroy"/><br /><sub><b>Kaizen Conroy</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kaizencc" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kcwinner"><img src="https://avatars3.githubusercontent.com/u/2728868?v=4?s=100" width="100px;" alt="Kenneth Winner"/><br /><sub><b>Kenneth Winner</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kcwinner" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://kenneth.wussmann.net/"><img src="https://avatars.githubusercontent.com/u/11491506?v=4?s=100" width="100px;" alt="Kenneth Wußmann"/><br /><sub><b>Kenneth Wußmann</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=KennethWussmann" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kennyg"><img src="https://avatars.githubusercontent.com/u/98244?v=4?s=100" width="100px;" alt="Kenny Gatdula"/><br /><sub><b>Kenny Gatdula</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kennyg" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tinovyatkin"><img src="https://avatars.githubusercontent.com/u/5350898?v=4?s=100" width="100px;" alt="Konstantin Vyatkin"/><br /><sub><b>Konstantin Vyatkin</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tinovyatkin" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/bigkraig"><img src="https://avatars1.githubusercontent.com/u/508403?v=4?s=100" width="100px;" alt="Kraig Amador"/><br /><sub><b>Kraig Amador</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=bigkraig" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://kdabir.com/"><img src="https://avatars.githubusercontent.com/u/735240?v=4?s=100" width="100px;" alt="Kunal Dabir"/><br /><sub><b>Kunal Dabir</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kdabir" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://kylelaker.com/"><img src="https://avatars.githubusercontent.com/u/850893?v=4?s=100" width="100px;" alt="Kyle Laker"/><br /><sub><b>Kyle Laker</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kylelaker" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lexfelixpost"><img src="https://avatars.githubusercontent.com/u/112618115?v=4?s=100" width="100px;" alt="Lex Felix"/><br /><sub><b>Lex Felix</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=lexfelixpost" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lexGPT"><img src="https://avatars.githubusercontent.com/u/112618115?v=4?s=100" width="100px;" alt="Lex Felix"/><br /><sub><b>Lex Felix</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=lexGPT" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Liam-Johnston"><img src="https://avatars.githubusercontent.com/u/30859946?v=4?s=100" width="100px;" alt="Liam Johnston"/><br /><sub><b>Liam Johnston</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Liam-Johnston" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/WtfJoke"><img src="https://avatars.githubusercontent.com/u/7139697?v=4?s=100" width="100px;" alt="Manuel"/><br /><sub><b>Manuel</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=WtfJoke" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/marciocadev"><img src="https://avatars.githubusercontent.com/u/67694075?v=4?s=100" width="100px;" alt="Marcio Cruz de Almeida"/><br /><sub><b>Marcio Cruz de Almeida</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=marciocadev" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mmcculloh-dms"><img src="https://avatars.githubusercontent.com/u/68597641?v=4?s=100" width="100px;" alt="Mark McCulloh"/><br /><sub><b>Mark McCulloh</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mmcculloh-dms" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://www.linkedin.com/in/mark-mcculloh/"><img src="https://avatars.githubusercontent.com/u/1237390?v=4?s=100" width="100px;" alt="Mark McCulloh"/><br /><sub><b>Mark McCulloh</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=MarkMcCulloh" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://polothy.github.io/"><img src="https://avatars.githubusercontent.com/u/634657?v=4?s=100" width="100px;" alt="Mark Nielsen"/><br /><sub><b>Mark Nielsen</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=polothy" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/schuch"><img src="https://avatars.githubusercontent.com/u/6401299?v=4?s=100" width="100px;" alt="Markus Schuch"/><br /><sub><b>Markus Schuch</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=schuch" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/marnixdessing"><img src="https://avatars.githubusercontent.com/u/14939820?v=4?s=100" width="100px;" alt="Marnix Dessing"/><br /><sub><b>Marnix Dessing</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=marnixdessing" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mmuller88"><img src="https://avatars0.githubusercontent.com/u/18393842?v=4?s=100" width="100px;" alt="Martin Muller"/><br /><sub><b>Martin Muller</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mmuller88" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mzuber"><img src="https://avatars.githubusercontent.com/u/948563?v=4?s=100" width="100px;" alt="Martin Zuber"/><br /><sub><b>Martin Zuber</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mzuber" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://tmokmss.hatenablog.com/"><img src="https://avatars.githubusercontent.com/u/7490655?v=4?s=100" width="100px;" alt="Masashi Tomooka"/><br /><sub><b>Masashi Tomooka</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tmokmss" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/matt9ucci"><img src="https://avatars.githubusercontent.com/u/8044346?v=4?s=100" width="100px;" alt="Matt Gucci"/><br /><sub><b>Matt Gucci</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=matt9ucci" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://dev.to/martzcodes"><img src="https://avatars1.githubusercontent.com/u/978362?v=4?s=100" width="100px;" alt="Matt Martz"/><br /><sub><b>Matt Martz</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=martzcodes" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/diranged"><img src="https://avatars.githubusercontent.com/u/768067?v=4?s=100" width="100px;" alt="Matt Wise"/><br /><sub><b>Matt Wise</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=diranged" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/msessa"><img src="https://avatars.githubusercontent.com/u/1912143?v=4?s=100" width="100px;" alt="Matteo Sessa"/><br /><sub><b>Matteo Sessa</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=msessa" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://www.matthewbonig.com/"><img src="https://avatars2.githubusercontent.com/u/1559437?v=4?s=100" width="100px;" alt="Matthew Bonig"/><br /><sub><b>Matthew Bonig</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mbonig" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mwg-rea"><img src="https://avatars.githubusercontent.com/u/82480228?v=4?s=100" width="100px;" alt="Matthew Gamble"/><br /><sub><b>Matthew Gamble</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mwg-rea" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/fongie"><img src="https://avatars1.githubusercontent.com/u/19932622?v=4?s=100" width="100px;" alt="Max Körlinge"/><br /><sub><b>Max Körlinge</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=fongie" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mayurm88"><img src="https://avatars.githubusercontent.com/u/75965317?v=4?s=100" width="100px;" alt="Mayur Mahrotri"/><br /><sub><b>Mayur Mahrotri</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mayurm88" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Mayureshd-18"><img src="https://avatars.githubusercontent.com/u/98738585?v=4?s=100" width="100px;" alt="Mayuresh Dharwadkar"/><br /><sub><b>Mayuresh Dharwadkar</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Mayureshd-18" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mikejgray"><img src="https://avatars.githubusercontent.com/u/30268971?v=4?s=100" width="100px;" alt="Mike"/><br /><sub><b>Mike</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mikejgray" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/MrArnoldPalmer"><img src="https://avatars.githubusercontent.com/u/7221111?v=4?s=100" width="100px;" alt="Mitchell Valine"/><br /><sub><b>Mitchell Valine</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=MrArnoldPalmer" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://moritzkornher.de/"><img src="https://avatars.githubusercontent.com/u/379814?v=4?s=100" width="100px;" alt="Momo Kornher"/><br /><sub><b>Momo Kornher</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mrgrain" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/gmukul01"><img src="https://avatars.githubusercontent.com/u/3636885?v=4?s=100" width="100px;" alt="Mukul Bansal"/><br /><sub><b>Mukul Bansal</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=gmukul01" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://blog.neilkuan.net/"><img src="https://avatars.githubusercontent.com/u/46012524?v=4?s=100" width="100px;" alt="Neil Kuan"/><br /><sub><b>Neil Kuan</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=neilkuan" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nicholas-keers"><img src="https://avatars.githubusercontent.com/u/94363953?v=4?s=100" width="100px;" alt="Nick Keers"/><br /><sub><b>Nick Keers</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=nicholas-keers" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/njlynch"><img src="https://avatars.githubusercontent.com/u/1376292?v=4?s=100" width="100px;" alt="Nick Lynch"/><br /><sub><b>Nick Lynch</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=njlynch" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nbyl"><img src="https://avatars.githubusercontent.com/u/1185719?v=4?s=100" width="100px;" alt="Nicolas Byl"/><br /><sub><b>Nicolas Byl</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=nbyl" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/nikhil-zadoo"><img src="https://avatars.githubusercontent.com/u/29751551?v=4?s=100" width="100px;" alt="Nikhil Zadoo"/><br /><sub><b>Nikhil Zadoo</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=nikhil-zadoo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://nikovirtala.io/"><img src="https://avatars.githubusercontent.com/u/6813506?v=4?s=100" width="100px;" alt="Niko Virtala"/><br /><sub><b>Niko Virtala</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=nikovirtala" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/niraj8"><img src="https://avatars.githubusercontent.com/u/8666468?v=4?s=100" width="100px;" alt="Niraj Palecha"/><br /><sub><b>Niraj Palecha</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=niraj8" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dandelionur"><img src="https://avatars.githubusercontent.com/u/89805919?v=4?s=100" width="100px;" alt="Nurbanu"/><br /><sub><b>Nurbanu</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dandelionur" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/pahud"><img src="https://avatars3.githubusercontent.com/u/278432?v=4?s=100" width="100px;" alt="Pahud Hsieh"/><br /><sub><b>Pahud Hsieh</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=pahud" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/patrickdean"><img src="https://avatars.githubusercontent.com/u/1610088?v=4?s=100" width="100px;" alt="Patrick"/><br /><sub><b>Patrick</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=patrickdean" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/duckpuppy"><img src="https://avatars.githubusercontent.com/u/19253?v=4?s=100" width="100px;" alt="Patrick Aikens"/><br /><sub><b>Patrick Aikens</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=duckpuppy" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://pepperize.com/"><img src="https://avatars.githubusercontent.com/u/13916107?v=4?s=100" width="100px;" alt="Patrick Florek"/><br /><sub><b>Patrick Florek</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=pflorek" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/oconpa"><img src="https://avatars.githubusercontent.com/u/35761519?v=4?s=100" width="100px;" alt="Patrick O'Connor"/><br /><sub><b>Patrick O'Connor</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=oconpa" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://p6m7g8.github.io/"><img src="https://avatars0.githubusercontent.com/u/34295?v=4?s=100" width="100px;" alt="Philip M. Gollucci"/><br /><sub><b>Philip M. Gollucci</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=pgollucci" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/philipmw"><img src="https://avatars.githubusercontent.com/u/1379645?v=4?s=100" width="100px;" alt="Philip White"/><br /><sub><b>Philip White</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=philipmw" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://garbe.io/"><img src="https://avatars.githubusercontent.com/u/721899?v=4?s=100" width="100px;" alt="Philipp Garbe"/><br /><sub><b>Philipp Garbe</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=pgarbe" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://dynobase.dev/"><img src="https://avatars3.githubusercontent.com/u/3391616?v=4?s=100" width="100px;" alt="Rafal Wilinski"/><br /><sub><b>Rafal Wilinski</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=RafalWilinski" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://ramihusein.com/"><img src="https://avatars.githubusercontent.com/u/96155378?v=4?s=100" width="100px;" alt="Rami Husein"/><br /><sub><b>Rami Husein</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=rami-husein" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="http://rix0r.nl/"><img src="https://avatars.githubusercontent.com/u/524162?v=4?s=100" width="100px;" alt="Rico Huijbers"/><br /><sub><b>Rico Huijbers</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=rix0rrr" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://tinkerin.gs/"><img src="https://avatars.githubusercontent.com/u/386001?v=4?s=100" width="100px;" alt="Rob Giseburt"/><br /><sub><b>Rob Giseburt</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=giseburt" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://robbiemackay.com/"><img src="https://avatars.githubusercontent.com/u/7965?v=4?s=100" width="100px;" alt="Robbie Mackay"/><br /><sub><b>Robbie Mackay</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=rjmackay" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/robert-affinidi"><img src="https://avatars.githubusercontent.com/u/88320072?v=4?s=100" width="100px;" alt="Robert"/><br /><sub><b>Robert</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=robert-affinidi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://rfrezinos.wordpress.com/"><img src="https://avatars.githubusercontent.com/u/3926597?v=4?s=100" width="100px;" alt="Rodrigo Farias Rezino"/><br /><sub><b>Rodrigo Farias Rezino</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=rfrezino" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/rogerchi"><img src="https://avatars.githubusercontent.com/u/625496?v=4?s=100" width="100px;" alt="Roger Chi"/><br /><sub><b>Roger Chi</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=rogerchi" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://keybase.io/romainmuller"><img src="https://avatars2.githubusercontent.com/u/411689?v=4?s=100" width="100px;" alt="Romain Marcadier"/><br /><sub><b>Romain Marcadier</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=RomainMuller" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/quesabe"><img src="https://avatars.githubusercontent.com/u/90195036?v=4?s=100" width="100px;" alt="Roman Vasilev"/><br /><sub><b>Roman Vasilev</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=quesabe" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/dj-rabel"><img src="https://avatars.githubusercontent.com/u/4653214?v=4?s=100" width="100px;" alt="Ruben Pascal Abel"/><br /><sub><b>Ruben Pascal Abel</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=dj-rabel" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://ryansonshine.com/"><img src="https://avatars.githubusercontent.com/u/9534477?v=4?s=100" width="100px;" alt="Ryan Sonshine"/><br /><sub><b>Ryan Sonshine</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=ryansonshine" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://medium.com/@riywo"><img src="https://avatars.githubusercontent.com/u/37822?v=4?s=100" width="100px;" alt="Ryosuke Iwanaga"/><br /><sub><b>Ryosuke Iwanaga</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=riywo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/aisamu"><img src="https://avatars.githubusercontent.com/u/431708?v=4?s=100" width="100px;" alt="Samuel Tschiedel"/><br /><sub><b>Samuel Tschiedel</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=aisamu" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/saudkhanzada"><img src="https://avatars.githubusercontent.com/u/30137907?v=4?s=100" width="100px;" alt="Saud Khanzada"/><br /><sub><b>Saud Khanzada</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=saudkhanzada" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/scottmondo"><img src="https://avatars.githubusercontent.com/u/91044021?v=4?s=100" width="100px;" alt="Scott McFarlane"/><br /><sub><b>Scott McFarlane</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=scottmondo" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/scottschreckengaust"><img src="https://avatars.githubusercontent.com/u/345885?v=4?s=100" width="100px;" alt="Scott Schreckengaust"/><br /><sub><b>Scott Schreckengaust</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=scottschreckengaust" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://skorfmann.com/"><img src="https://avatars1.githubusercontent.com/u/136789?v=4?s=100" width="100px;" alt="Sebastian Korfmann"/><br /><sub><b>Sebastian Korfmann</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=skorfmann" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://selfstructured.com/"><img src="https://avatars.githubusercontent.com/u/361689?v=4?s=100" width="100px;" alt="Shawn MacIntyre"/><br /><sub><b>Shawn MacIntyre</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=smacintyre" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/suhasgaddam-trueaccord"><img src="https://avatars.githubusercontent.com/u/68877840?v=4?s=100" width="100px;" alt="Suhas Gaddam"/><br /><sub><b>Suhas Gaddam</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=suhasgaddam-trueaccord" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/thomasklinger1234"><img src="https://avatars1.githubusercontent.com/u/39558817?v=4?s=100" width="100px;" alt="Thomas Klinger"/><br /><sub><b>Thomas Klinger</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=thomasklinger1234" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/hoegertn"><img src="https://avatars2.githubusercontent.com/u/1287829?v=4?s=100" width="100px;" alt="Thorsten Hoeger"/><br /><sub><b>Thorsten Hoeger</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=hoegertn" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tiararodney"><img src="https://avatars.githubusercontent.com/u/56236443?v=4?s=100" width="100px;" alt="Tiara"/><br /><sub><b>Tiara</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tiararodney" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tobias-bardino"><img src="https://avatars.githubusercontent.com/u/1842089?v=4?s=100" width="100px;" alt="Tobias"/><br /><sub><b>Tobias</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tobias-bardino" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://windyroad.com.au/"><img src="https://avatars.githubusercontent.com/u/7802440?v=4?s=100" width="100px;" alt="Tom Howard"/><br /><sub><b>Tom Howard</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tompahoward" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="http://dankmemes2020.com/"><img src="https://avatars.githubusercontent.com/u/1083460?v=4?s=100" width="100px;" alt="Tom Keller"/><br /><sub><b>Tom Keller</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kellertk" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://tlakomy.com/"><img src="https://avatars2.githubusercontent.com/u/16646517?v=4?s=100" width="100px;" alt="Tomasz Łakomy"/><br /><sub><b>Tomasz Łakomy</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tlakomy" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tmartensen"><img src="https://avatars.githubusercontent.com/u/1750466?v=4?s=100" width="100px;" alt="Travis Martensen"/><br /><sub><b>Travis Martensen</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tmartensen" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/floydspace"><img src="https://avatars.githubusercontent.com/u/5180700?v=4?s=100" width="100px;" alt="Victor Korzunin"/><br /><sub><b>Victor Korzunin</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=floydspace" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/VinayKokate22"><img src="https://avatars.githubusercontent.com/u/114766745?v=4?s=100" width="100px;" alt="VinayKokate22"/><br /><sub><b>VinayKokate22</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=VinayKokate22" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/vinayak-kukreja"><img src="https://avatars.githubusercontent.com/u/78971045?v=4?s=100" width="100px;" alt="Vinayak Kukreja"/><br /><sub><b>Vinayak Kukreja</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=vinayak-kukreja" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/vladcos"><img src="https://avatars.githubusercontent.com/u/135833592?v=4?s=100" width="100px;" alt="Vlad Cos"/><br /><sub><b>Vlad Cos</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=vladcos" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://willdady.com/"><img src="https://avatars.githubusercontent.com/u/204259?v=4?s=100" width="100px;" alt="Will Dady"/><br /><sub><b>Will Dady</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=willdady" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/yglcode"><img src="https://avatars.githubusercontent.com/u/11893614?v=4?s=100" width="100px;" alt="Yigong Liu"/><br /><sub><b>Yigong Liu</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=yglcode" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/rajyan"><img src="https://avatars.githubusercontent.com/u/38206553?v=4?s=100" width="100px;" alt="Yohta Kimura"/><br /><sub><b>Yohta Kimura</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=rajyan" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/ykageyama-mondo"><img src="https://avatars.githubusercontent.com/u/91044220?v=4?s=100" width="100px;" alt="Yuichi Kageyama"/><br /><sub><b>Yuichi Kageyama</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=ykageyama-mondo" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://yuval.io/"><img src="https://avatars.githubusercontent.com/u/5735586?v=4?s=100" width="100px;" alt="Yuval"/><br /><sub><b>Yuval</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=yuvalherziger" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/andrestone"><img src="https://avatars1.githubusercontent.com/u/7958086?v=4?s=100" width="100px;" alt="andrestone"/><br /><sub><b>andrestone</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=andrestone" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/codeLeeek"><img src="https://avatars.githubusercontent.com/u/49740620?v=4?s=100" width="100px;" alt="codeLeeek"/><br /><sub><b>codeLeeek</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=codeLeeek" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/flyingImer"><img src="https://avatars0.githubusercontent.com/u/1973868?v=4?s=100" width="100px;" alt="flyingImer"/><br /><sub><b>flyingImer</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=flyingImer" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/huaxk"><img src="https://avatars.githubusercontent.com/u/9971591?v=4?s=100" width="100px;" alt="huaxk"/><br /><sub><b>huaxk</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=huaxk" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/john-tipper"><img src="https://avatars2.githubusercontent.com/u/9730398?v=4?s=100" width="100px;" alt="john-tipper"/><br /><sub><b>john-tipper</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=john-tipper" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/karlderkaefer"><img src="https://avatars.githubusercontent.com/u/9578480?v=4?s=100" width="100px;" alt="karlderkaefer"/><br /><sub><b>karlderkaefer</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=karlderkaefer" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kmkhr"><img src="https://avatars.githubusercontent.com/u/25603933?v=4?s=100" width="100px;" alt="kmkhr"/><br /><sub><b>kmkhr</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kmkhr" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/kt-hr"><img src="https://avatars.githubusercontent.com/u/25603933?v=4?s=100" width="100px;" alt="kt-hr"/><br /><sub><b>kt-hr</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=kt-hr" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/lmarsden"><img src="https://avatars.githubusercontent.com/u/51232932?v=4?s=100" width="100px;" alt="lmarsden"/><br /><sub><b>lmarsden</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=lmarsden" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mtimbs"><img src="https://avatars.githubusercontent.com/u/12463905?v=4?s=100" width="100px;" alt="michaeltimbs"/><br /><sub><b>michaeltimbs</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=mtimbs" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/orlandronen1"><img src="https://avatars.githubusercontent.com/u/25987273?v=4?s=100" width="100px;" alt="orlandronen1"/><br /><sub><b>orlandronen1</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=orlandronen1" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/pvbouwel"><img src="https://avatars.githubusercontent.com/u/463976?v=4?s=100" width="100px;" alt="pvbouwel"/><br /><sub><b>pvbouwel</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=pvbouwel" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/suhussai"><img src="https://avatars.githubusercontent.com/u/6500837?v=4?s=100" width="100px;" alt="suhussai"/><br /><sub><b>suhussai</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=suhussai" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/t0bst4r"><img src="https://avatars.githubusercontent.com/u/82281152?v=4?s=100" width="100px;" alt="t0bst4r"/><br /><sub><b>t0bst4r</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=t0bst4r" title="Code">💻</a></td>
      </tr>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/tHyt-lab"><img src="https://avatars.githubusercontent.com/u/11361677?v=4?s=100" width="100px;" alt="tHyt-lab"/><br /><sub><b>tHyt-lab</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=tHyt-lab" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/Warkanlock"><img src="https://avatars.githubusercontent.com/u/13340320?v=4?s=100" width="100px;" alt="txxnano"/><br /><sub><b>txxnano</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=Warkanlock" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/vVahe"><img src="https://avatars.githubusercontent.com/u/17318901?v=4?s=100" width="100px;" alt="vVahe"/><br /><sub><b>vVahe</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=vVahe" title="Code">💻</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/zetashift"><img src="https://avatars.githubusercontent.com/u/1857826?v=4?s=100" width="100px;" alt="zetashift"/><br /><sub><b>zetashift</b></sub></a><br /><a href="https://github.com/projen/projen/commits?author=zetashift" title="Code">💻</a></td>
      </tr>
    </tbody>
  </table><!-- markdownlint-restore --><!-- prettier-ignore-end --><!-- ALL-CONTRIBUTORS-LIST:END -->



  Distributed under the [Apache-2.0](./LICENSE) license.


