# packages

pkgId: da7f48d6868efb8e43c75201abb72200fef807e06940a057bf1d6dd3af6ba9ec
name: python-patchwork-cli-help
arch: noarch
version: 0.0.83
epoch: 0
release: 1
summary: Development documents and examples for patchwork-cli
url: https://pypi.org/project/patchwork-cli/
rpm_license: AGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-patchwork-cli-0.0.83-1.src.rpm
location_href: Packages/python-patchwork-cli-help-0.0.83-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <picture>
      <img alt="Patchwork logo" src="https://repository-images.githubusercontent.com/782544882/a9743f35-5e1c-43ed-a0e0-536322056d38" width="36%">
    </picture>
   <br>
    <img alt="Patchwork GIF" src="https://raw.githubusercontent.com/patched-codes/patchwork/main/patchwork-banner.gif">
  </div>
  <br>

  <div align="center">

  [![Build](https://github.com/patched-codes/patchwork/actions/workflows/release.yml/badge.svg)](https://github.com/patched-codes/patchwork/actions/workflows/release.yml)
  [![Discord](https://dcbadge.limes.pink/api/server/XDxA3mJyhE?style=flat&theme=clean-inverted)](https://discord.gg/XDxA3mJyhE)
  [![Downloads](https://img.shields.io/pypi/v/patchwork-cli)](https://pypi.org/project/patchwork-cli/)
  [![Downloads](https://static.pepy.tech/badge/patchwork-cli)](https://pepy.tech/projects/patchwork-cli)

  [Demo](https://youtu.be/MLyn6B3bFMU) |
  [Docs](https://docs.patched.codes/)

  </div>

  Patchwork automates development gruntwork like PR reviews, bug fixing, security patching, and more using a self-hosted CLI agent and your preferred LLMs. Try the hosted version [here](https://app.patched.codes/signin).



  - **Steps**: Reusable atomic actions like create PR, commit changes or call an LLM.
  - **Prompt Templates**: Customizable LLM prompts optimized for a chore like library updates, code generation, issue analysis or vulnerability remediation.
  - **Patchflows**: LLM-assisted automations such as PR reviews, code fixing, documentation etc. built by combining steps and prompts.

  Patchflows can be run locally in your CLI and IDE, or as part of your CI/CD pipeline. There are [several patchflows available](#patchflows) out of the box, and you can always [create your own](#contributing).



  [![Patchwork CLI Quickstart](https://img.youtube.com/vi/3gRpqQoIino/0.jpg)](https://youtu.be/MLyn6B3bFMU)





  Patchwork is available on PyPI and can be installed using pip:

  ```bash
  pip install 'patchwork-cli[all]' --upgrade
  ```

  The following optional dependency groups are available.

  - `security`: Installs `semgrep` and `depscan` with `pip install 'patchwork-cli[security]'` and is required for **AutoFix** and **DependencyUpgrade** patchflows.
  - `rag`: Installs `chromadb` with `pip install 'patchwork-cli[rag]'` and is required for the **ResolveIssue** patchflow.
  - `notifications`: Used by steps sending notifications, e.g. slack messages.
  - `all`: installs everything.
  - Not specifying any dependency group (`pip install patchwork-cli`) will install a core set of dependencies that are sufficient to run the **GenerateDocstring**, **PRReview** and **GenerateREADME** patchflows.



  If you'd like to build from source using poetry, please see detailed documentation [here](INSTALL.md) .



  The CLI runs Patchflows, as follows:

  ```
  patchwork <PatchFlow> <?Arguments>
  ```

  Where
  - **Arguments**: Allow for overriding default/optional attributes of the Patchflow in the format of `key=value`. If `key` does not have any value, it is considered a boolean `True` flag.



  For an AutoFix patchflow which patches vulnerabilities based on a scan using Semgrep:

  ```bash
  patchwork AutoFix openai_api_key=<YOUR_OPENAI_API_KEY> github_api_key=<YOUR_GITHUB_TOKEN>
  ```

  The above command defaults to patching code in the current directory by running Semgrep to identify the vulnerabilities. You can view the `default.yml` [file](patchwork/patchflows/AutoFix/defaults.yml) for the list of configurations you can set to manage the AutoFix patchflow. For more details on how you can use a personal access token from GitHub on CLI, can read [this](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#using-a-personal-access-token-on-the-command-line).

  You can replace the OpenAI key with a key from our managed service
  by signing in at [https://app.patched.codes/signin](https://app.patched.codes/signin) and generating an API key from the integrations tab. You can then call the patchflow with the key as follows:

  ```bash
  patchwork AutoFix patched_api_key=<YOUR_PATCHED_API_KEY> github_api_key=<YOUR_GITHUB_TOKEN>
  ```

  To use Google's models you can set the `google_api_key` and `model`, this is useful if you want to work with large contexts as the `gemini-pro-1.5` model supports an input context length of 1 million tokens.

  The [patchwork-template](https://github.com/patched-codes/patchwork-configs) repository contains the default configuration and prompts for all the patchflows. You can clone that repo and pass it as a flag to the CLI:

  ```bash
  patchwork AutoFix --config /path/to/patchwork-configs/patchflows
  ```



  Patchwork supports any OpenAI compatible endpoint, allowing use of any LLM from various providers like Groq, Together AI, or Hugging Face.

  E.g. to use Llama 3.1 405B from Groq.com run:

  ```
  patchwork AutoFix client_base_url=https://api.groq.com/openai/v1 openai_api_key=your_groq_key model=llama-3.1-405b-reasoning
  ```

  You can also use a config file to do the same. To use Llama 3.1 405B from Hugging Face, create a config.yml file:

  ```yaml
  openai_api_key: your_hf_token
  client_base_url: https://api-inference.huggingface.co/models/meta-llama/Meta-Llama-3.1-405B-Instruct-FP8/v1
  model: Meta-Llama-3.1-405B-Instruct-FP8
  ```

  And run as:

  ```
  patchwork AutoFix --config=/path/to/config.yml
  ```

  This allows you to run local models via `llama.cpp`, `ollama`, `vllm` or `tgi`. For instance, you can run Llama 3.1 8B locally using `llama_cpp.server`:

  ```
  python -m llama_cpp.server --hf_model_repo_id bullerwins/Meta-Llama-3.1-8B-Instruct-GGUF --model 'Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf' --chat_format chatml
  ```

  Then run your patchflow:

  ```
  patchwork AutoFix client_base_url=http://localhost:8080/v1 openai_api_key=no_key_local_model
  ```



  Patchwork comes with predefined patchflows, with more added over time. Sample patchflows include:

  - [**GenerateDocstring**](patchwork/patchflows/GenerateDocstring): Generate docstrings for methods in your code.
  - [**AutoFix**](patchwork/patchflows/AutoFix): Generate and apply fixes to code vulnerabilities in a repository.
  - [**PRReview**](patchwork/patchflows/PRReview): On PR creation, extract code diff, summarize changes, and comment on PR.
  - [**GenerateREADME**](patchwork/patchflows/GenerateREADME): Create a README markdown file for a given folder, to add documentation to your repository.
  - [**DependencyUpgrade**](patchwork/patchflows/DependencyUpgrade): Update your dependencies from vulnerable to fixed versions.
  - [**ResolveIssue**](patchwork/patchflows/ResolveIssue): Identify the files in your repository that need to be updated to resolve an issue (or bug) and create a PR to fix it.



  Prompt templates are used by patchflows and passed as queries to LLMs. Templates contain prompts with placeholder variables enclosed by `{{}}` which are replaced by the data from the steps or inputs on every run.

  Below is a sample prompt template:

  ```json
  {
    "id": "diffreview_summary",
      "prompts": [
        {
          "role": "user",
          "content": "Summarize the following code change descriptions in 1 paragraph. {{diffreviews}}"
        }
      ]
  }
  ```

  Each patchflow comes with an optimized default prompt template. But you can specify your own using the `prompt_template_file=/path/to/prompt/template/file` option.



  Contributions for new patchflows and steps, or to the core framework are welcome. Please look at open issues for details.

  - To create a new patchflow, follow [these instructions](patchwork/patchflows/README.md).
  - To create a new step, follow [these instructions](patchwork/steps/README.md).

  We also provide a chat assistant to help you create new steps and patchflows easily.

  - [Patchwork Assistant on HuggingChat](https://hf.co/chat/assistant/66322701fd4787e0c1f7696b) (based on Llama-3.1)




  - Expand patchflow library and integration options
  - Patchflow debugger and validation module
  - Bug fixing and performance improvements
  - Refactor code and documentation


  - Support large-scale code embeddings in patchflows
  - Support parallelization and branching
  - Fine-tuned models that can be self-hosted
  - Open-source GUI



  Patchwork is licensed under [AGPL-3.0 terms](https://github.com/patched-codes/patchwork?tab=AGPL-3.0-1-ov-file#readme). However, custom patchflows and steps can be created and shared using the [patchwork template](https://github.com/patched-codes/patchwork-configs) repository which is licensed under [Apache-2.0 terms](https://github.com/patched-codes/patchwork-configs/blob/main/LICENSE).


pkgId: 18437e00f4b74b80bf47a319b4908d328b43e3c556e3db96328aeea6058b3ae9
name: python-patronus-help
arch: noarch
version: 0.0.15
epoch: 0
release: 1
summary: Development documents and examples for patronus
url: https://pypi.org/project/patronus/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-patronus-0.0.15-1.src.rpm
location_href: Packages/python-patronus-help-0.0.15-1.noarch.rpm
checksum_type: sha256
description:
  The Patronus Python SDK is a Python library for systematic evaluation of Large Language Models (LLMs).
  Build, test, and improve your LLM applications with customizable tasks, evaluators, and comprehensive experiment tracking.

  **Note:** This library is currently in **beta** and is not stable. The APIs may change in future releases.



  For detailed documentation, including API references and advanced usage, please visit our [documentation](https://docs.patronus.ai/docs/experimentation-framework).



  ```shell
  pip install patronus
  ```





  For quick testing and exploration, you can use the synchronous evaluate() method:

  ```python
  import os
  from patronus import Client

  client = Client(
      
      api_key=os.environ.get("PATRONUS_API_KEY"),
  )
  result = client.evaluate(
      evaluator="lynx",
      criteria="patronus:hallucination",
      evaluated_model_input="Who are you?",
      evaluated_model_output="My name is Barry.",
      evaluated_model_retrieved_context="My name is John.",
  )
  print(f"Pass: {result.pass_}")
  print(f"Explanation: {result.explanation}")
  ```

  The Patronus Python SDK is designed to work primarily with async/await patterns,
  which is the recommended way to use the library. Here's a feature-rich example using async evaluation:

  ```python
  import asyncio
  from patronus import Client

  client = Client()

  no_apologies = client.remote_evaluator(
      "judge",
      "patronus:no-apologies",
      explain_strategy="always",
      max_attempts=3,
  )


  async def evaluate():
      result = await no_apologies.evaluate(
          evaluated_model_input="How to kill a docker container?",
          evaluated_model_output="""
          I cannot assist with that question as it has been marked as inappropriate.
          I must respectfully decline to provide an answer."
          """,
      )
      print(f"Pass: {result.pass_}")
      print(f"Explanation: {result.explanation}")


  asyncio.run(evaluate())
  ```



  The Patronus Python SDK includes a powerful experimentation framework designed to help you evaluate, compare, and improve your AI models.
  Whether you're working with pre-trained models, fine-tuning your own, or experimenting with new architectures,
  this framework provides the tools you need to set up, execute, and analyze experiments efficiently.

  ```python
  import os
  from patronus import Client, Row, TaskResult, evaluator, task

  client = Client(
      
      api_key=os.environ.get("PATRONUS_API_KEY"),
  )


  @task
  def my_task(row: Row):
      return f"{row.evaluated_model_input} World"


  @evaluator
  def exact_match(row: Row, task_result: TaskResult):
      
      return task_result.evaluated_model_output == row.evaluated_model_gold_answer




  is_concise = client.remote_evaluator("judge", "patronus:is-concise")

  client.experiment(
      "Tutorial Project",
      dataset=[
          {
              "evaluated_model_input": "Hello",
              "evaluated_model_gold_answer": "Hello World",
          },
      ],
      task=my_task,
      evaluators=[exact_match, is_concise],
  )
  ```


pkgId: 0baa64273845498e6dcaaa2450f957d112a061a86e5f95c0c3eb97cbb04135fb
name: python-pav-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for pav
url: https://github.com/ArianN8610/PAV
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pav-1.0.1-1.src.rpm
location_href: Packages/python-pav-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  **PAV** is an advanced Python command-line tool that simplifies virtual environment (venv) management and streamlines project execution. With PAV, you can run files, manage dependencies, and execute commands in a virtual environment without needing to manually activate the venv. PAV automates environment detection, activation, and optimized dependency handling.


  Use the package manager [pip](https://pip.pypa.io/en/stable/) to install **PAV**.
  ```bash
  pip install pav
  ```


  You can use **PAV** through terminal. Hereâ€™s a quick example:
  ```bash
  pav file main.py
  ```
  For a complete list of available commands:
  ```bash
  pav --help
  ```



  It takes the file path for argument and if the venv path was not given manually, it detects the venv path if it exists and activates it and runs the Python file (If the venv is located in a specific path that the program may not automatically recognize, it is better to enter it manually)
  Here are some examples:
  ```bash
  pav file ./project/main.py
  ```
  To specify the venv path manually:
  ```bash
  pav file ./project/main.py --venv-path ../venv_dir
  ```
  If the file you want to execute needs to take some arguments, you can use --file-arguments:
  ```bash
  pav file ./project/main.py --file-arguments "create --name file_name -u"
  ```


  * Python 3.6 or higher
  * [Click](https://click.palletsprojects.com/en/stable/) library for command-line handling (automatically installed as a dependency)


pkgId: 035aa532dde1ed25d588f4af38d47baa73a38727ecaa72514f3017d85b062432
name: python-pawnlib-help
arch: noarch
version: 2.0.89
epoch: 0
release: 1
summary: Development documents and examples for pawnlib
url: https://pawnlib.readthedocs.io
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pawnlib-2.0.89-1.src.rpm
location_href: Packages/python-pawnlib-help-2.0.89-1.noarch.rpm
checksum_type: sha256
description:
  __________  _____  __      _________    _________
  \______   \/  _  \/  \    /  \      \  /   _____/
   |     ___/  /_\  \   \/\/   /   |   \ \_____  \
   |    |  /    |    \        /    |    \/        \
   |____|  \____|__  /\__/\  /\____|__  /_______  /
                   \/      \/         \/        \/
   - Description :
   - Version     : 2.0.15


pkgId: aea437492994d0c0a65672e42847581ec307a6e2f5270b7db566e97891544ee6
name: python-paymentsgate-help
arch: noarch
version: 1.4.1
epoch: 0
release: 1
summary: Development documents and examples for paymentsgate
url: https://github.com/paymentsgate/python-secure-api
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-paymentsgate-1.4.1-1.src.rpm
location_href: Packages/python-paymentsgate-help-1.4.1-1.noarch.rpm
checksum_type: sha256
description:
  - Python >= 3.8.1
  - dependencies:
    - [`requests`](https://github.com/kennethreitz/requests)
    - [`pydantic`](https://docs.pydantic.dev/latest/)
    - [`jwt`](https://pyjwt.readthedocs.io/en/stable/)



  The simplest way to install SDK is to use [PIP](https://docs.python.org/3/installing/):

  ```bash
  pip install paymentsgate
  ```



  ```python
  from paymentsgate import ApiClient, Credentials, Currencies



  config = Credentials().fromFile('/path/to/credentials.json');


  client = ApiClient(config, baseUrl='https://api.example.com');


  res = cli.Quote(
    {
      "amount": 10.10,
      "currency_from": Currencies.EUR,
      "currency_to": Currencies.AZN,
    }
  )
  print(res);
  ```

  The `credentials.json` file is used to connect to the client and contains all necessary data to use the API. This file can be obtained in your personal cabinet, in the service accounts section. Follow the instructions in the documentation to issue new keys. If you already have keys, but you don't feel comfortable storing them in a file, you can use client initialization via variables. In this case, the key data can be stored in external storage instead of on the file system:

  ```python
  from paymentsgate import ApiClient, Credentials

  config = Credentials(
    account_id="00000000-4000-4000-0000-00000000000a"
    public_key="LS0tLS1CRUdJTiBSU0EgUFJJVkFUNSUlFb3dJQk..."
  )

  client = ApiClient(config, baseUrl='https://api.example.com');

  ...
  ```
  *It is important to note that the data format for key transfer is base46.





  ```python
  res = cli.PayIn(
    {
      "amount": 10.10,
      "currency": Currencies.AZN,
      "invoiceId": "INVOICE-112123124",
      "clientId": "",
      "successUrl": "https://example.com/success",
      "failUrl": "https://example.com/fail",
      "type": InvoiceTypes.m10
    }
  )
  print(res);
  ```



  ```python
  res = cli.PayOut(
    {
      "amount": 5.12,
      "currencyTo": Currencies.EUR,
      "invoiceId": "INVOICE-112123124",
      "clientId": "CLIENT-003010023004",
      "baseCurrency": CurrencyTypes.fiat,
      "feesStrategy": FeesStrategy.add,
      "recipient": {
        "account_number": "4000000000000012",
        "account_owner": "CARD HOLDER",
        "type": CredentialsTypes.card
      }
    }
  )
  print(res);
  ```



  ```python
  try:
    res = cli.PayOut(
      {
        "amount": 5.12,
        "currencyTo": Currencies.EUR,
        "invoiceId": "INVOICE-112123124",
        "clientId": "CLIENT-003010023004",
        "baseCurrency": CurrencyTypes.fiat,
        "feesStrategy": FeesStrategy.add,
        "recipient": {
          "account_number": "4000000000000012",
          "account_owner": "CARD HOLDER",
          "type": CredentialsTypes.card
        }
      }
    )
    print(res);
  except APIAuthenticationError as err:
    print(f"Authentication fail: {err.message}")
  except APIResponseError as err:
    print(f"Exception: {err.error}; Message: {err.message}")
  ```


pkgId: c95a664b9196ea219c35ba56c3597a8ec8974b4fc36c6c71168cc79e14fd8eac
name: python-payu-help
arch: noarch
version: 1.1.6
epoch: 0
release: 1
summary: Development documents and examples for payu
url: https://pypi.org/project/payu/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-payu-1.1.6-1.src.rpm
location_href: Packages/python-payu-help-1.1.6-1.noarch.rpm
checksum_type: sha256
description:
  Payu is a climate model workflow management tool for supercomputing
  environments.
  Payu is currently only configured for use on computing clusters maintained by
  NCI (National Computational Infrastructure) in Australia.
  See the documentation_ for more details.


pkgId: dee4a7e36af0e64dcb40824c28f933db87067c5b6e49b6934231721b68307e52
name: python-pbip-tools-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for pbip-tools
url: https://github.com/moshemoshe137/pbip-tools
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pbip-tools-0.1.0-1.src.rpm
location_href: Packages/python-pbip-tools-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Python 3.12](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/release/python-312/)
  [![License: MIT](https://img.shields.io/github/license/moshemoshe137/pbip-tools)](https://github.com/moshemoshe137/pbip-tools/blob/main/LICENSE)
  [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)

  **PBIP-tools** is a Python package designed to process Power BI-generated JSON files for
  enhanced human-readability and seamless version control integration. The package
  provides two key executables:

  1. **`json-clean`**: Converts nested and complex Power BI-generated JSON files into a
     human-readable format.

  2. **`json-smudge`**: Reverses the cleaning process, restoring the JSON files to a
     format that Power BI can properly load.



  - **Human-readable JSON**: The `json-clean` utility de-nests JSON objects and JSON
    strings for easier understanding and editing.

  - **Restoration for Power BI**: The `json-smudge` utility ensures that files cleaned by
    `json-clean` can be reloaded into Power BI.

  - **Command-line utilities**: Both `json-clean` and `json-smudge` can be used directly
    from the command line for seamless file processing.



  You can install the package using pip:

  ```bash
  pip install pbip-tools
  ```





  To clean a Power BI-generated JSON file for readability, run the following command:

  ```bash
  json-clean <file-or-glob> [<file-or-glob2> ... ]
  ```

  Example:

  ```bash
  json-clean report.json my_folder/*.json
  ```



  To restore a cleaned JSON file to its original state for Power BI loading, run:

  ```bash
  json-smudge <file-or-glob> [<file-or-glob2> ...]
  ```

  Example:

  ```bash
  json-smudge cleaned_report.json cleaned/**/*.json
  ```



  This package depends solely on Python’s standard libraries. For contributing and
  testing, `pre-commit` and `pytest` may be required.



  This project is licensed under the MIT License. See the
  [LICENSE](https://github.com/moshemoshe137/pbip-tools/blob/main/LICENSE) file for
  details.



  If you would like to contribute, feel free to open issues or submit pull requests.

rpm_license:
  MIT License  Copyright (c) 2024 Moshe Rubin  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: f14ed261a9652aab8f7d2c8007471a0cb26cd0faa383c4b22184b3e819cb7004
name: python-pbipinspect-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for pbipinspect
url: https://github.com/matheussrod/pbipinspect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pbipinspect-0.1.0-1.src.rpm
location_href: Packages/python-pbipinspect-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  Parse, validate and document your Power BI Project



  ```
  pip install pbipinspect
  ```



  This library brings your Power BI project to a structured and validated state. It provides a set of tools to analyze, validate, and document your project.

  First, you need to create a inspect. The `create_inspect` function takes a path to your project and returns a `PbipInspect` object. You can create directly with `PbipInspect` class, but `create_inspect` is recommended.

  ```python
  >>> from pbipinspect import create_inspect
  >>> inspect = create_inspect('your-project.pbip')
  ```

  Inspect parse you Power BI Project and gives you the ability to validate and document it. You can see the model generated from your project acessing the attribute `model`.
  ```python
  >>> print(inspect.model)
  {'model': {
      'tables': [{
          'name': 'table',
          'lineageTag': 'id',
          'columns': [{...}],
          'measures': [{...}],
          'partitions': [{...}],
          'isHidden': False,
          'annotations': [{...}]
      }],
      'relationships': [{...}]
  }}
  ```

  Now, it's possible to validate your project. This is possible thanks to expects. Pbipinspect already comes with some expects that you can use to validate your project.

  ```python
  >>> from pbipinspect.expectations import *
  >>> inspect.expectations(steps=[
  ...     expect_col_starts_with(col_type='dateTime', pattern='dt_', state='Info'),
  ...     expect_measure_starts_with(pattern='m_'),
  ...     expect_table_starts_with(pattern='t_'),
  ...     expect_table_name_no_spaces(),
  ...     expect_cols_in_relationship_has_same_type(),
  ...     expect_dax_lines_length(max_length=60),
  ...     expect_m_lines_length(max_length=60),
  ...     expect_measures_in_specific_table('_measures'),
  ...     expect_no_calculated_columns(state='Error'),
  ...     expect_all_relationships_active()
  >>> ])
  >>> inspect.run_expectations()
  >>> print(inspect.expects)
  [{'expect': 'expect_col_starts_with',
     'state': 'Warning',
     'message': "Column 'Column1' in table 'Table1' must start with 'dt_'"},
   {'expect': 'expect_no_calculated_columns',
    'state': 'Error',
    'message': "Table 'Table1' has calculated columns: 'Column2' and 'Column3'"}
  ]
  ```



  If you encounter a clear bug, please file an issue with a minimal reproducible example on GitHub.


pkgId: fa519187472808cf7f1be559384158ea06d86859a03ef266685464b0d45ec1e1
name: python-pbs4py-help
arch: noarch
version: 1.0.8
epoch: 0
release: 1
summary: Development documents and examples for pbs4py
url: https://pypi.org/project/pbs4py/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pbs4py-1.0.8-1.src.rpm
location_href: Packages/python-pbs4py-help-1.0.8-1.noarch.rpm
checksum_type: sha256
description:
  pbs4py is a Python module for automating submission of compute jobs on High Performance
  Computing clusters, such as those that use the Portable Batch System (PBS).
  It includes pre-configured launchers for common NASA HPC systems: the Langley K cluster
  and NASA Advanced Supercomputing (NAS) systems.

  Examples uses are uncertainty quantification where many jobs are submitted
  simultaneously or optimization where sequences of jobs need to scripted.

  pbs4py also includes scripts for performing tasks associated with PBS jobs
  such as a script when given a job number will print the directory from which it was launched
  and a script that can delete multiple jobs based on filters.



  [Documentation is hosted using Github Pages](https://nasa.github.io/pbs4py/)

  The pbs4py documentation is generated from the source code with [Sphinx](https://www.sphinx-doc.org/en/master/).
  Once you have installed pbs4py, the documentation is built by running `make html` in the docs directory.
  The generated documentation will be in `docs/build/html`.


  pbs4py can be installed with

  ```
  pip install pbs4py
  ```



  After installation,

  On the K cluster:
  ```python
  from pbs4py import PBS
  pbs = PBS.k4()
  pbs.requested_number_of_nodes = 1
  pbs.launch(job_name='example_job',job_body=['echo "Hello World"'])
  ```

  On NAS:
  ```python
  from pbs4py import PBS
  group = 'a1111' # your project ID to charge here
  pbs = PBS.nas(group, proc_type='san', queue='devel', time=1)
  pbs.launch(job_name='example_job',job_body=['echo "Hello World"'])
  ```


  Notices:
  Copyright 2022 United States Government as represented by the Administrator of
  the National Aeronautics and Space Administration. No copyright is claimed in
  the United States under Title 17, U.S. Code. All Other Rights Reserved.

  Third Party Software:

  This software calls the following third party software, which is subject to the
  terms and conditions of its licensor, as applicable at the time of licensing.
  Third party software is not bundled with this software, but may be available
  from the licensor. License hyperlinks are provided here for information purposes
  only: numpy, BSD 3-Clause "New" or "Revised" License,
  https://github.com/numpy/numpy/blob/main/LICENSE.txt.

  Disclaimers
  No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF
  ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED
  TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY
  IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
  FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR
  FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE
  SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN
  ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS,
  RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS
  RESULTING FROM USE OF THE SUBJECT SOFTWARE.  FURTHER, GOVERNMENT AGENCY
  DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF
  PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS."

  Waiver and Indemnity:  RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE
  UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY
  PRIOR RECIPIENT.  IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY
  LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE,
  INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE
  OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED
  STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR
  RECIPIENT, TO THE EXTENT PERMITTED BY LAW.  RECIPIENT'S SOLE REMEDY FOR ANY SUCH
  MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT.


pkgId: 9c7622fff2a3b21b780da6651632215fc4a68e5b106811e11ea6551448dfd3e3
name: python-pca-scenery-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for pca-scenery
url: https://pointcarre.app
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pca-scenery-0.1.8-1.src.rpm
location_href: Packages/python-pca-scenery-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  For more information, examples, and advanced usage, please visit our [official documentation](https://pointcarre-app.github.io/pca-scenery/).

rpm_license:
  MIT License  Copyright (c) 2024 [Pointcarre.app]  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: 4c14439864e476d20945e5dd905add202ebad4e9134d8d18bc32463048f19e8f
name: python-pcntoolkit-help
arch: noarch
version: 0.32.0
epoch: 0
release: 1
summary: Development documents and examples for pcntoolkit
url: https://pypi.org/project/pcntoolkit/
rpm_license: GNU GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pcntoolkit-0.32.0-1.src.rpm
location_href: Packages/python-pcntoolkit-help-0.32.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/pcntoolkit/badge/?version=latest)](https://pcntoolkit.readthedocs.io/en/latest/?badge=latest) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5207839.svg)](https://doi.org/10.5281/zenodo.5207839)

  [Github](https://github.com/amarquand/PCNtoolkit)


  Predictive Clinical Neuroscience software toolkit (formerly nispat).

  Methods for normative modelling, spatial statistics and pattern recognition. Documentation, including tutorials can be found on [readthedocs](https://pcntoolkit.readthedocs.io/en/latest/). Click on the docs button above to visit the site.





  using the download here: https://www.anaconda.com/download


  ```
  conda create -n <env_name> python==3.12
  ```



  ```
  source activate <env_name>
  ```



  Using pip:
  ```
  pip install pcntoolkit
  ```

  Using a local clone of the repo:
  ```
  python -m pip install .
  ```


  ```
  python -c "import pcntoolkit as pk;print(pk.__file__)"
  ```




  On some older architectures, the installation of nutpie may fail due to a missing Rust compiler. If this is the case, you can install it manually using conda prior to installing PCNtoolkit:

  ```

  conda install -c conda-forge nutpie

  pip install pcntoolkit
  ```




  Otherwise install it first from https://www.anaconda.com/

  ```
  conda --version
  ```



  ```
  conda create -y python==3.12 --prefix=/shared/conda/<env_name>
  ```



  ```
  conda activate /shared/conda/<env_name>
  ```



  ```
  git clone https://github.com/amarquand/PCNtoolkit.git
  ```



  ```
  cd PCNtoolkit/
  python -m pip install .
  ```


  ```
  python -c "import pcntoolkit as pk;print(pk.__file__)"
  ```



  For normative modelling, functionality is handled by the normative.py script, which can be run from the command line, e.g.

  ```

  ```

  For more information, please see the following resources:

  * [documentation](https://github.com/amarquand/PCNtoolkit/wiki/Home)
  * [developer documentation](https://amarquand.github.io/PCNtoolkit/doc/build/html/)
  * a tutorial and worked through example on a [real-world dataset](https://github.com/predictive-clinical-neuroscience/PCNtoolkit-demo)


pkgId: 34023920f282947b82c51c2687e83b04acbe64153745acf821948c13889ef696
name: python-pdaqp-help
arch: noarch
version: 0.4.0
epoch: 0
release: 1
summary: Development documents and examples for pdaqp
url: https://github.com/darnstrom/pdaqp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdaqp-0.4.0-1.src.rpm
location_href: Packages/python-pdaqp-help-0.4.0-1.noarch.rpm
checksum_type: sha256
description:
  **pdaqp** is a Python package for solving multi-parametric quadratic programs of the form

  $$
  \begin{align}
  \min_{z} &  ~\frac{1}{2}z^{T}Hz+(f+F \theta)^{T}z \\
  \text{s.t.} & ~A z \leq b + B \theta \\
  & ~\theta \in \Theta
  \end{align}
  $$

  where $H \succ 0$ and $\Theta \triangleq \lbrace l \leq \theta \leq u : A_{\theta} \theta \leq b_{\theta}\rbrace$.

  **pdaqp** is based on the Julia package [ParametricDAQP.jl](https://github.com/darnstrom/ParametricDAQP.jl/) and the Python module [juliacall](https://juliapy.github.io/PythonCall.jl/stable/juliacall/).  More information about the underlying algorithm and numerical experiments can be found in the paper ["A High-Performant Multi-Parametric Quadratic Programming Solver"](https://arxiv.org/abs/2404.05511).



  ```bash
  pip install pdaqp
  ```

  The following code solves the mpQP in Section 7.1 in Bemporad et al. 2002
  ```python
  import numpy

  H =  numpy.array([[1.5064, 0.4838], [0.4838, 1.5258]])
  f = numpy.zeros((2,1))
  F = numpy.array([[9.6652, 5.2115], [7.0732, -7.0879]])
  A = numpy.array([[1.0, 0], [-1, 0], [0, 1], [0, -1]])
  b = 2*numpy.ones((4,1));
  B = numpy.zeros((4,2));

  thmin = -1.5*numpy.ones(2)
  thmax = 1.5*numpy.ones(2)

  from pdaqp import MPQP
  mpQP = MPQP(H,f,F,A,b,B,thmin,thmax)
  mpQP.solve()
  ```
  To construct a binary search tree for point location, and to generate corresponding C-code, run
  ```python
  mpQP.codegen(dir="codegen", fname="pointlocation")
  ```
  which will create the following directory:
  ```bash
  ├── codegen
  │   ├── pointlocation.c
  │   └── pointlocation.h
  ```
  The critical regions and the optimal solution can be plotted with the commands
  ```python
  mpQP.plot_regions()
  mpQP.plot_solution()
  ```
  which create the following plots
  <p align="center">
    <img src="https://github.com/darnstrom/pdaqp/raw/docs/docs/imgs/example_regions.png" width="600" alt="critical_regions" align="center"/>
  </p>
  <p align="center">
    <img src="https://github.com/darnstrom/pdaqp/raw/docs/docs/imgs/example_solution.png" width="600" alt="solution_component" align="center"/>
  </p>


pkgId: 44e2627df417f7a8b136ef81d7de1e12f9a85d19f91aab1d723cadee4fb3b74d
name: python-pddl-plus-parser-help
arch: noarch
version: 3.9.0
epoch: 0
release: 1
summary: Development documents and examples for pddl-plus-parser
url: https://pypi.org/project/pddl-plus-parser/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pddl-plus-parser-3.9.0-1.src.rpm
location_href: Packages/python-pddl-plus-parser-help-3.9.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
    <b>PDDL Plus Parser</b>
  </h1>

  <p align="center">
    <a href="https://pypi.org/project/pddl-plus-parser/">
      <img alt="PyPI" src="https://img.shields.io/pypi/v/pddl">
    </a>
    <a href="https://pypi.org/project/pddl">
      <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/pddl" />
    </a>
    <a href="">
      <img alt="PyPI - Status" src="https://img.shields.io/pypi/status/pddl" />
    </a>
    <a href="">
      <img alt="PyPI - Implementation" src="https://img.shields.io/pypi/implementation/pddl">
    </a>
    <a href="">
      <img alt="PyPI - Wheel" src="https://img.shields.io/pypi/wheel/pddl">
    </a>
    <a href="https://github.com/AI-Planning/pddl/blob/main/LICENSE">
      <img alt="GitHub" src="https://img.shields.io/github/license/AI-Planning/pddl">
    </a>
  </p>
  <p align="center">
    <a href="">
      <img alt="test" src="https://github.com/AI-Planning/pddl/workflows/test/badge.svg">
    </a>
    <a href="">
      <img alt="lint" src="https://github.com/AI-Planning/pddl/workflows/lint/badge.svg">
    </a>
    <a href="">
      <img alt="docs" src="https://github.com/AI-Planning/pddl/workflows/docs/badge.svg">
    </a>
    <a href="https://codecov.io/gh/AI-Planning/pddl">
      <img alt="codecov" src="https://codecov.io/gh/AI-Planning/pddl/branch/main/graph/badge.svg?token=FG3ATGP5P5">
    </a>
  </p>
  <p align="center">
    <a href="https://img.shields.io/badge/flake8-checked-blueviolet">
      <img alt="" src="https://img.shields.io/badge/flake8-checked-blueviolet">
    </a>
    <a href="https://img.shields.io/badge/mypy-checked-blue">
      <img alt="" src="https://img.shields.io/badge/mypy-checked-blue">
    </a>
    <a href="https://img.shields.io/badge/code%20style-black-black">
      <img alt="black" src="https://img.shields.io/badge/code%20style-black-black" />
    </a>
    <a href="https://www.mkdocs.org/">
      <img alt="" src="https://img.shields.io/badge/docs-mkdocs-9cf">
    </a>
  </p>








  * version 0.0.1 - Initial release. Support for discrete PDDL domain and problem parsing.
  * version 1.0.0 - Major extension to support PDDL 2.1 in terms of numeric actions.
  * version 1.1.0 - Added support for Metric-FF solutions parsing.
  * version 1.2.0 - Added support for ENHSP solution parsing.
  * version 1.3.0 - Added problem generators for some domains used in the experiments.
  * version 1.4.0 - Added negative preconditions for actions.
  * version 2.0.0 - Added support for multi-agent PDDL domains and problems.
  * version 2.1.0 - Added support for more complex type of multi-agent trajectories to support non-trivial interactions.
  * version 2.2.0 - Added support for domains with disjunctive numeric preconditions.
  * version 3.0.0 - Added support for conditional effect without existential quantification and only conjunctive conditions.
  * version 3.1.0 - Added support for universal effects containing only conjunctive conditions.
  * version 3.1.4 - Added support for inapplicable actions and fixed a minor logical bug in the universal effects.
  * version 3.3.0 - Added support for nested action schemas including universal preconditions.
  * version 3.5.0 - Added simplification of numeric expression. This helps to prevent getting too complicated preconditions.
  * version 3.5.7 - Added support for problem exportation to PDDL from a problem object.
  * version 3.5.8 - Fixed a bug that displayed power expressions in PDDL even though this is not supported by the language.
  * version 3.6.5 - performance **boost** for the tokenizer - credit @yarin-benyamin.
  * version 3.7.0 - Added the ability to simplify preconditions by eliminating variables that are redundant and thus reducing the general size of the conditions.
  * version 3.8.0 - Added code to better support multi-agent domains and problems.
  * version 3.8.9 - Added bug fixes to the numeric expressions simplification.
  * version 3.9.0 - Added the ability to query the size of an observation.


pkgId: 1f6cb598f5160bfb0dda6dc74727f94e99193f634aac814ac28674a771708bdb
name: python-pdf-combiner-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for pdf-combiner
url: https://github.com/sahil-kale/pdf-combiner
rpm_license: Prosperity 3.0.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdf-combiner-0.0.1-1.src.rpm
location_href: Packages/python-pdf-combiner-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A simple command-line utility to combine multiple PDF/image files into a single PDF.


  Combine individual PDF files or entire folders of PDFs.
  Support for recursive folder traversal.
  Specify custom output file paths.
  Works as a CLI tool for seamless integration into your workflows.


  Combine Specific Files
  To combine specific PDF files into a single output: `pdf_combiner path/to/file1.pdf path/to/file2.pdf --output_path output.pdf`

  Combine All PDFs in a Folder
  To combine all PDF files in a specific folder: `pdf_combiner -r path/to/folder --output_path output.pdf`

  Note: images (.png, .jpg) are supported as file input


  TBD


pkgId: 946798f68451da88815995de48312903e971b905703b171d9a52f9f5bbbac95f
name: python-pdf-utility-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for pdf-utility
url: https://github.com/sahil-kale/pdf-util
rpm_license: Prosperity 3.0.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdf-utility-0.0.1-1.src.rpm
location_href: Packages/python-pdf-utility-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  A simple command-line utility to combine multiple PDF/image files into a single PDF.


  - Combine individual PDF files or entire folders of PDFs.
  - Support for recursive folder traversal.
  - Specify custom output file paths.
  - Works as a CLI tool for seamless integration into your workflows.


  - File Size Reduction


  Using pip: `pip install pdf_util`

  *Note: the shortcut `pdf_util` can be directly used, but sometimes pip shortcuts do not work on windows. In this case, the module can be run with `python -m pdf_util <args>`.*

  Using executable:
  - Download the executable artifact from the latest `Build Windows Executable` job
  - Execute the executable, ex: `path/to/pdf_util.exe --help`


  Combine Specific Files
  To combine specific PDF files into a single output: `pdf_util --operation combine path/to/file1.pdf path/to/file2.png --output_path output.pdf`

  Combine All PDFs in a Folder
  To combine all PDF files in a specific folder: `pdf_util --operation combine -r path/to/folder --output_path output.pdf`

  Note: images (.png, .jpg) are supported as file input


pkgId: 111f9f57aa7d62add16074cc860e70a724cc9e9e414486a5994a0ed1256383ea
name: python-pdf2zh-help
arch: noarch
version: 1.8.8
epoch: 0
release: 1
summary: Development documents and examples for pdf2zh
url: https://github.com/Byaidu/PDFMathTranslate
rpm_license: AGPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdf2zh-1.8.8-1.src.rpm
location_href: Packages/python-pdf2zh-help-1.8.8-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  English | [简体中文](README_zh-CN.md) | [日本語](README_ja-JP.md)

  <img src="./docs/images/banner.png" width="320px"  alt="PDF2ZH"/>

  <h2 id="title">PDFMathTranslate</h2>

  <p>
    <!-- PyPI -->
    <a href="https://pypi.org/project/pdf2zh/">
      <img src="https://img.shields.io/pypi/v/pdf2zh"></a>
    <a href="https://pepy.tech/projects/pdf2zh">
      <img src="https://static.pepy.tech/badge/pdf2zh"></a>
    <a href="https://hub.docker.com/repository/docker/byaidu/pdf2zh">
      <img src="https://img.shields.io/docker/pulls/byaidu/pdf2zh"></a>
    <!-- License -->
    <a href="./LICENSE">
      <img src="https://img.shields.io/github/license/Byaidu/PDFMathTranslate"></a>
    <a href="https://huggingface.co/spaces/reycn/PDFMathTranslate-Docker">
      <img src="https://img.shields.io/badge/%F0%9F%A4%97-Online%20Demo-FF9E0D"></a>
    <a href="https://github.com/Byaidu/PDFMathTranslate/pulls">
      <img src="https://img.shields.io/badge/contributions-welcome-green"></a>
    <a href="https://t.me/+Z9_SgnxmsmA5NzBl">
      <img src="https://img.shields.io/badge/Telegram-2CA5E0?style=flat-squeare&logo=telegram&logoColor=white"></a>
  </p>

  <a href="https://trendshift.io/repositories/12424" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12424" alt="Byaidu%2FPDFMathTranslate | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

  </div>

  PDF scientific paper translation and bilingual comparison.

  - 📊 Preserve formulas, charts, table of contents, and annotations *([preview](#preview))*.
  - 🌐 Support [multiple languages](#language), and diverse [translation services](#services).
  - 🤖 Provides [commandline tool](#usage), [interactive user interface](#gui), and [Docker](#docker)

  Feel free to provide feedback in [GitHub Issues](https://github.com/Byaidu/PDFMathTranslate/issues), [Telegram Group](https://t.me/+Z9_SgnxmsmA5NzBl) or [QQ Group](https://qm.qq.com/q/DixZCxQej0).

  <h2 id="updates">Updates</h2>

  - [Nov. 26 2024] CLI now supports online file(s) *(by [@reycn](https://github.com/reycn))*
  - [Nov. 24 2024] [ONNX](https://github.com/onnx/onnx) support to reduce dependency sizes *(by [@Wybxc](https://github.com/Wybxc))*
  - [Nov. 23 2024] 🌟 [Public Service](#demo)  online! *(by [@Byaidu](https://github.com/Byaidu))*
  - [Nov. 23 2024] Firewall for preventing web bots *(by [@Byaidu](https://github.com/Byaidu))*
  - [Nov. 22 2024] GUI now supports Italian, and has been improved *(by [@Byaidu](https://github.com/Byaidu), [@reycn](https://github.com/reycn))*
  - [Nov. 22 2024] You can now share your deployed service to others *(by [@Zxis233](https://github.com/Zxis233))*
  - [Nov. 22 2024] Now supports Tencent Translation *(by [@hellofinch](https://github.com/hellofinch))*
  - [Nov. 21 2024] GUI now supports downloading dual-document *(by [@reycn](https://github.com/reycn))*
  - [Nov. 20 2024] 🌟 [Demo](#demo)  online! *(by [@reycn](https://github.com/reycn))*

  <h2 id="preview">Preview</h2>

  <div align="center">
  <img src="./docs/images/preview.gif" width="80%"/>
  </div>

  <h2 id="demo">Public Service 🌟</h2>



  You can try our [public service](https://pdf2zh.com/) online without installation.



  You can try [our demo on HuggingFace](https://huggingface.co/spaces/reycn/PDFMathTranslate-Docker) without installation.
  Note that the computing resources of the demo are limited, so please avoid abusing them.

  <h2 id="install">Installation and Usage</h2>

  We provide four methods for using this project: [Commandline](#cmd), [Portable](#portable), [GUI](#gui), and [Docker](#docker).

  <h3 id="cmd">Method I. Commandline</h3>

    1. Python installed (3.8 <= version <= 3.12)
    2. Install our package:

        ```bash
        pip install pdf2zh
        ```

    3. Execute translation, files generated in [current working directory](https://chatgpt.com/share/6745ed36-9acc-800e-8a90-59204bd13444):

        ```bash
        pdf2zh document.pdf
        ```

  <h3 id="portable">Method II. Portable</h3>

  No need to pre-install Python environment

  Download [setup.bat](https://raw.githubusercontent.com/Byaidu/PDFMathTranslate/refs/heads/main/setup.bat) and double-click to run

  <h3 id="gui">Method III. GUI</h3>

  1. Python installed (3.8 <= version <= 3.12)
  2. Install our package:

        ```bash
        pip install pdf2zh
        ```

  3. Start using in browser:

        ```bash
        pdf2zh -i
        ```

  4. If your browswer has not been started automatically, goto

      ```bash
      http://localhost:7860/
      ```

      <img src="./docs/images/gui.gif" width="500"/>

  See [documentation for GUI](./docs/README_GUI.md) for more details.

  <h3 id="docker">Method IV. Docker</h3>

  1. Pull and run:

      ```bash
      docker pull byaidu/pdf2zh
      docker run -d -p 7860:7860 byaidu/pdf2zh
      ```

  2. Open in browser:

      ```
      http://localhost:7860/
      ```

  For docker deployment on cloud service:

  <div>
  <a href="https://www.heroku.com/deploy?template=https://github.com/Byaidu/PDFMathTranslate">
    <img src="https://www.herokucdn.com/deploy/button.svg" alt="Deploy" height="26"></a>
  <a href="https://render.com/deploy">
    <img src="https://render.com/images/deploy-to-render-button.svg" alt="Deploy to Koyeb" height="26"></a>
  <a href="https://zeabur.com/templates/5FQIGX?referralCode=reycn">
    <img src="https://zeabur.com/button.svg" alt="Deploy on Zeabur" height="26"></a>
  <a href="https://app.koyeb.com/deploy?type=git&builder=buildpack&repository=github.com/Byaidu/PDFMathTranslate&branch=main&name=pdf-math-translate">
    <img src="https://www.koyeb.com/static/images/deploy/button.svg" alt="Deploy to Koyeb" height="26"></a>
  </div>

  <h2 id="usage">Advanced Options</h2>

  Execute the translation command in the command line to generate the translated document `example-mono.pdf` and the bilingual document `example-dual.pdf` in the current working directory. Use Google as the default translation service.

  <img src="./docs/images/cmd.explained.png" width="580px"  alt="cmd"/>

  In the following table, we list all advanced options for reference:

  | Option    | Function | Example |
  | -------- | ------- |------- |
  | files | Local files |  `pdf2zh ~/local.pdf` |
  | links | Online files |  `pdf2zh http://arxiv.org/paper.pdf` |
  | `-i`  | [Enter GUI](#gui) |  `pdf2zh -i` |
  | `-p`  | [Partial document translation](#partial) |  `pdf2zh example.pdf -p 1` |
  | `-li` | [Source language](#languages) |  `pdf2zh example.pdf -li en` |
  | `-lo` | [Target language](#languages) |  `pdf2zh example.pdf -lo zh` |
  | `-s`  | [Translation service](#services) |  `pdf2zh example.pdf -s deepl` |
  | `-t`  | [Multi-threads](#threads) | `pdf2zh example.pdf -t 1` |
  | `-o`  | Output dir | `pdf2zh example.pdf -o output` |
  | `-f`, `-c` | [Exceptions](#exceptions) | `pdf2zh example.pdf -f "(MS.*)"` |
  | `--share` | Get gradio public link | `pdf2zh -i --share` |

  <h3 id="partial">Full / partial document translation</h3>

  - Entire document

    ```bash
    pdf2zh example.pdf
    ```

  - Part of the document

    ```bash
    pdf2zh example.pdf -p 1-3,5
    ```

  <h3 id="language">Specify source and target languages</h3>

  See [Google Languages Codes](https://developers.google.com/admin-sdk/directory/v1/languages), [DeepL Languages Codes](https://developers.deepl.com/docs/resources/supported-languages)

  ```bash
  pdf2zh example.pdf -li en -lo ja
  ```

  <h3 id="services">Translate with Different Services</h3>

  The table below outlines the required [environment variables](https://chatgpt.com/share/6734a83d-9d48-800e-8a46-f57ca6e8bcb4) for each translation service. Make sure to set them before using the respective service.

  |**Translator**|**Service**|**Environment Variables**|**Default Values**|**Notes**|
  |-|-|-|-|-|
  |**Google (Default)**|`google`|None|N/A|None|
  |**Bing**|`bing`|None|N/A|None|
  |**DeepL**|`deepl`|`DEEPL_SERVER_URL`,`DEEPL_AUTH_KEY`|`https://api.deepl.com`, `[Your Key]`|See [DeepL](https://support.deepl.com/hc/en-us/articles/360020695820-API-Key-for-DeepL-s-API)|
  |**DeepLX**|`deeplx`|`DEEPLX_ENDPOINT`|`https://api.deepl.com/translate`|See [DeepLX](https://github.com/OwO-Network/DeepLX)|
  |**Ollama**|`ollama`|`OLLAMA_HOST`, `OLLAMA_MODEL`|`http://127.0.0.1:11434`, `gemma2`|See [Ollama](https://github.com/ollama/ollama)|
  |**OpenAI**|`openai`|`OPENAI_BASE_URL`, `OPENAI_API_KEY`, `OPENAI_MODEL`|`https://api.openai.com/v1`, `[Your Key]`, `gpt-4o-mini`|See [OpenAI](https://platform.openai.com/docs/overview)|
  |**AzureOpenAI**|`azure-openai`|`AZURE_OPENAI_BASE_URL`, `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_MODEL`|`[Your Endpoint]`, `[Your Key]`, `gpt-4o-mini`|See [Azure OpenAI](https://learn.microsoft.com/zh-cn/azure/ai-services/openai/chatgpt-quickstart?tabs=command-line%2Cjavascript-keyless%2Ctypescript-keyless%2Cpython&pivots=programming-language-python)|
  |**Zhipu**|`zhipu`|`ZHIPU_API_KEY`, `ZHIPU_MODEL`|`[Your Key]`, `glm-4-flash`|See [Zhipu](https://open.bigmodel.cn/dev/api/thirdparty-frame/openai-sdk)|
  |**Silicon**|`silicon`|`SILICON_API_KEY`, `SILICON_MODEL`|`[Your Key]`, `Qwen/Qwen2.5-7B-Instruct`|See [SiliconCloud](https://docs.siliconflow.cn/quickstart)|
  |**Gemini**|`gemini`|`GEMINI_API_KEY`, `GEMINI_MODEL`|`[Your Key]`, `gemini-1.5-flash`|See [Gemini](https://ai.google.dev/gemini-api/docs/openai)|
  |**Azure**|`azure`|`AZURE_ENDPOINT`, `AZURE_API_KEY`|`https://api.translator.azure.cn`, `[Your Key]`|See [Azure](https://docs.azure.cn/en-us/ai-services/translator/text-translation-overview)|
  |**Tencent**|`tencent`|`TENCENTCLOUD_SECRET_ID`, `TENCENTCLOUD_SECRET_KEY`|`[Your ID]`, `[Your Key]`|See [Tencent](https://www.tencentcloud.com/products/tmt?from_qcintl=122110104)|

  Use `-s service` or `-s service:model` to specify service:

  ```bash
  pdf2zh example.pdf -s openai:gpt-4o-mini
  ```

  Or specify model with environment variables:

  ```bash
  set OPENAI_MODEL=gpt-4o-mini
  pdf2zh example.pdf -s openai
  ```

  <h3 id="exceptions">Translate wih exceptions</h3>

  Use regex to specify formula fonts and characters that need to be preserved:

  ```bash
  pdf2zh example.pdf -f "(CM[^RT].*|MS.*|.*Ital)" -c "(\(|\||\)|\+|=|\d|[\u0080-\ufaff])"
  ```

  Preserve `Latex`, `Mono`, `Code`, `Italic`, `Symbol` and `Math` fonts by default:

  ```bash
  pdf2zh example.pdf -f "(CM[^R]|(MS|XY|MT|BL|RM|EU|LA|RS)[A-Z]|LINE|LCIRCLE|TeX-|rsfs|txsy|wasy|stmary|.*Mono|.*Code|.*Ital|.*Sym|.*Math)"
  ```

  <h3 id="threads">Specify threads</h3>

  Use `-t` to specify how many threads to use in translation:

  ```bash
  pdf2zh example.pdf -t 1
  ```

  <h2 id="todo">API</h2>



  ```python
  from pdf2zh import translate, translate_stream

  params = {"lang_in": "en", "lang_out": "zh", "service": "google", "thread": 4}
  file_mono, file_dual = translate(files=["example.pdf"], **params)[0]
  with open("example.pdf", "rb") as f:
      stream_mono, stream_dual = translate_stream(stream=f.read(), **params)
  ```



  ```bash
  pip install pdf2zh[backend]
  pdf2zh --flask
  pdf2zh --celery worker
  ```

  ```bash
  curl http://localhost:11008/v1/translate -F "file=@example.pdf" -F "data={\"lang_in\":\"en\",\"lang_out\":\"zh\",\"service\":\"google\",\"thread\":4}"
  {"id":"d9894125-2f4e-45ea-9d93-1a9068d2045a"}

  curl http://localhost:11008/v1/translate/d9894125-2f4e-45ea-9d93-1a9068d2045a
  {"info":{"n":13,"total":506},"state":"PROGRESS"}

  curl http://localhost:11008/v1/translate/d9894125-2f4e-45ea-9d93-1a9068d2045a
  {"state":"SUCCESS"}

  curl http://localhost:11008/v1/translate/d9894125-2f4e-45ea-9d93-1a9068d2045a/mono --output example-mono.pdf

  curl http://localhost:11008/v1/translate/d9894125-2f4e-45ea-9d93-1a9068d2045a/dual --output example-dual.pdf

  curl http://localhost:11008/v1/translate/d9894125-2f4e-45ea-9d93-1a9068d2045a -X DELETE
  ```

  <h2 id="todo">TODO</h2>

  - [ ] Parse layout with DocLayNet based models, [PaddleX](https://github.com/PaddlePaddle/PaddleX/blob/17cc27ac3842e7880ca4aad92358d3ef8555429a/paddlex/repo_apis/PaddleDetection_api/object_det/official_categories.py#L81), [PaperMage](https://github.com/allenai/papermage/blob/9cd4bb48cbedab45d0f7a455711438f1632abebe/README.md?plain=1#L102), [SAM2](https://github.com/facebookresearch/sam2)

  - [ ] Fix page rotation, table of contents, format of lists

  - [ ] Fix pixel formula in old papers

  - [ ] Async retry except KeyboardInterrupt

  - [ ] Knuth–Plass algorithm for western languages

  - [ ] Support non-PDF/A files

  - [ ] Plugins of [Zotero](https://github.com/zotero/zotero) and [Obsidian](https://github.com/obsidianmd/obsidian-releases)

  <h2 id="acknowledgement">Acknowledgements</h2>

  - Document merging: [PyMuPDF](https://github.com/pymupdf/PyMuPDF)

  - Document parsing: [Pdfminer.six](https://github.com/pdfminer/pdfminer.six)

  - Document extraction: [MinerU](https://github.com/opendatalab/MinerU)

  - Multi-threaded translation: [MathTranslate](https://github.com/SUSYUSTC/MathTranslate)

  - Layout parsing: [DocLayout-YOLO](https://github.com/opendatalab/DocLayout-YOLO)

  - Document standard: [PDF Explained](https://zxyle.github.io/PDF-Explained/), [PDF Cheat Sheets](https://pdfa.org/resource/pdf-cheat-sheets/)

  - Multilingual Font: [Go Noto Universal](https://github.com/satbyy/go-noto-universal)

  <h2 id="contrib">Contributors</h2>

  <a href="https://github.com/Byaidu/PDFMathTranslate/graphs/contributors">
    <img src="https://opencollective.com/PDFMathTranslate/contributors.svg?width=890&button=false" />
  </a>

  ![Alt](https://repobeats.axiom.co/api/embed/dfa7583da5332a11468d686fbd29b92320a6a869.svg "Repobeats analytics image")

  <h2 id="star_hist">Star History</h2>

  <a href="https://star-history.com/#Byaidu/PDFMathTranslate&Date">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=Byaidu/PDFMathTranslate&type=Date&theme=dark" />
     <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=Byaidu/PDFMathTranslate&type=Date" />
     <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=Byaidu/PDFMathTranslate&type=Date"/>
   </picture>
  </a>


pkgId: 809d00f02a1c2cdff8ac52a60e926879aa44c79264e205c26a9d8afa50af2e6e
name: python-pdfconduit-help
arch: noarch
version: 4.6.7
epoch: 0
release: 1
summary: Development documents and examples for pdfconduit
url: https://github.com/sfneal/pdfconduit
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdfconduit-4.6.7-1.src.rpm
location_href: Packages/python-pdfconduit-help-4.6.7-1.noarch.rpm
checksum_type: sha256
description:
  A Pure-Python library built as a PDF toolkit.  Prepare documents for distribution.

  Features:
  - Watermark: Dynamically generate watermarks and add watermark to existing document
  - Label: Overlay text labels such as filename or date to documents
  - Encrypt: Password protect and restrict permissions to print only
  - Rotate: Rotate by increments of 90 degrees
  - Upscale: Scale PDF size
  - Merge: Concatenate multiple documents into one file
  - Slice: Extract page ranges from documents
  - Extract Text and Images
  - Retrieve document metadata and information


pkgId: 5e924221a14acf8ab9f72c516b575f15adefcf78027988d573f932650743e02d
name: python-pdfdeal-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for pdfdeal
url: https://pypi.org/project/pdfdeal/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdfdeal-1.0.1-1.src.rpm
location_href: Packages/python-pdfdeal-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <div align=center>
  <h1 aligh="center">
  <img src="https://github.com/Menghuan1918/pdfdeal/assets/122662527/837cfd7f-4546-4b44-a199-d826d78784fc" width="45">  pdfdeal
  </h1>
  <a href="https://github.com/Menghuan1918/pdfdeal/actions/workflows/python-test.yml">
    <img src="https://github.com/Menghuan1918/pdfdeal/actions/workflows/python-test.yml/badge.svg"
    alt="Package Testing on Python 3.8-3.13 on Win/Linux/macOS">
  </a>
  <br>
  <br>

  [![Downloads](https://static.pepy.tech/badge/pdfdeal)](https://pepy.tech/project/pdfdeal) ![GitHub License](https://img.shields.io/github/license/Menghuan1918/pdfdeal) ![PyPI - Version](https://img.shields.io/pypi/v/pdfdeal) ![GitHub Repo stars](https://img.shields.io/github/stars/Menghuan1918/pdfdeal)

  <br>

  [📄Documentation](https://menghuan1918.github.io/pdfdeal-docs/guide/)

  <br>

  🗺️ ENGLISH | [简体中文](README_CN.md)

  </div>

  Handle PDF more easily and simply, utilizing Doc2X's powerful document conversion capabilities for retained format file conversion/RAG enhancement.

  <div align=center>
  <img src="https://github.com/user-attachments/assets/3db3c682-84f1-4712-bd70-47422616f393" width="500px">
  </div>





  [Doc2X](https://doc2x.com/) is a new universal document OCR tool that can convert images or PDF files into Markdown/LaTeX text with formulas and text formatting. It performs better than similar tools in most scenarios. `pdfdeal` provides abstract packaged classes to use Doc2X for requests.



  Use various OCR or PDF recognition tools to identify images and add them to the original text. You can set the output format to use PDF, which will ensure that the recognized text retains the same page numbers as the original in the new PDF. It also offers various practical file processing tools.

  After conversion and pre-processing of PDF using Doc2X, you can achieve better recognition rates when used with knowledge base applications such as [graphrag](https://github.com/microsoft/graphrag), [Dify](https://github.com/langgenius/dify), and [FastGPT](https://github.com/labring/FastGPT).



  `pdfdeal` also provides a series of powerful tools to handle Markdown documents:

  - **Convert HTML tables to Markdown format**: Allows conversion of HTML formatted tables to Markdown format for easy use in Markdown documents.
  - **Upload images to remote storage services**: Supports uploading local or online images in Markdown documents to remote storage services to ensure image persistence and accessibility.
  - **Convert online images to local images**: Allows downloading and converting online images in Markdown documents to local images for offline use.
  - **Document splitting and separator addition**: Supports splitting Markdown documents by headings or adding separators within documents for better organization and management.

  For detailed feature introduction and usage, please refer to the [documentation link](https://menghuan1918.github.io/pdfdeal-docs/guide/Tools/).






  See [how to use it with graphrag](https://menghuan1918.github.io/pdfdeal-docs/demo/graphrag.html), [its not supported to recognize pdf](https://github.com/microsoft/graphrag), but you can use the CLI tool `doc2x` to convert it to a txt document for use.

  <div align=center>
  <img src="https://github.com/user-attachments/assets/f9e8408b-9a4b-42b9-9aee-0d1229065a91" width="600px">
  </div>



  Or for knowledge base applications, you can use `pdfdeal`'s built-in variety of enhancements to documents, such as uploading images to remote storage services, adding breaks by paragraph, etc. See [Integration with RAG applications](https://menghuan1918.github.io/pdfdeal-docs/demo/RAG_pre.html).

  <div align=center>
  <img src="https://github.com/user-attachments/assets/034d3eb0-d77e-4f7d-a707-9be08a092a9a" width="450px">
  <img src="https://github.com/user-attachments/assets/6078e585-7c06-485f-bcd3-9fac84eb7301" width="450px">
  </div>



  For details, please refer to the [documentation](https://menghuan1918.github.io/pdfdeal-docs/)

  Or check out the [documentation repository pdfdeal-docs](https://github.com/Menghuan1918/pdfdeal-docs).



  For details, please refer to the [documentation](https://menghuan1918.github.io/pdfdeal-docs/)



  Install using pip:

  ```bash
  pip install --upgrade pdfdeal
  ```

  If you need [document processing tools](https://menghuan1918.github.io/pdfdeal-docs/guide/Tools/):

  ```bash
  pip install --upgrade "pdfdeal[rag]"
  ```



  ```python
  from pdfdeal import Doc2X

  client = Doc2X(apikey="Your API key",debug=True)
  success, failed, flag = client.pdf2file(
      pdf_file="tests/pdf",
      output_path="./Output",
      output_format="docx",
  )
  print(success)
  print(failed)
  print(flag)
  ```



  ```python
  from pdfdeal import Doc2X

  client = Doc2X(apikey="Your API key",debug=True)
  success, failed, flag = client.pdf2file(
      pdf_file="tests/pdf/sample.pdf",
      output_path="./Output/test/single/pdf2file",
      output_names=["sample1.zip"],
      output_format="md_dollar",
  )
  print(success)
  print(failed)
  print(flag)
  ```

  See the online documentation for details.


pkgId: dfa9b6d15454c7b80f5bb3e88f552977f67c9880033e7ad1119587b8100a35bd
name: python-pdstools-help
arch: noarch
version: 4.0.1
epoch: 0
release: 1
summary: Development documents and examples for pdstools
url: https://github.com/pegasystems/pega-datascientist-tools
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pdstools-4.0.1-1.src.rpm
location_href: Packages/python-pdstools-help-4.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <h1 class="no-underline" style="text-align:center"> Pega Data Scientist Tools </h1>
  </p>

  <p align="center">
  <img height="100px" src="https://raw.githubusercontent.com/pegasystems/pega-datascientist-tools/master/images/pegasystems-inc-vector-logo.svg" alt="Pega logo">
  </p>

  <p align="center">
    <!-- Tests -->
    <a href="https://github.com/pegasystems/pega-datascientist-tools/actions">
      <img src="https://github.com/pegasystems/pega-datascientist-tools/workflows/Python%20tests/badge.svg" alt="Python tests">
    </a>
    <!-- Code coverage -->
    <a href="https://codecov.io/gh/pegasystems/pega-datascientist-tools">
      <img src="https://codecov.io/gh/pegasystems/pega-datascientist-tools/branch/master/graph/badge.svg"/>
    </a>
    <!-- PyPi package-->
    <a href="https://badge.fury.io/py/pdstools"><img src="https://badge.fury.io/py/pdstools.svg" alt="PyPI version"></a>
    <!-- Wiki -->
    <a href="https://github.com/pegasystems/pega-datascientist-tools/wiki">
      <img src="https://img.shields.io/badge/wiki-up-success" alt="wiki">
    </a>
    <!-- Documentation -->
    <a href="https://pegasystems.github.io/pega-datascientist-tools/">
      <img src="https://img.shields.io/badge/Documentation-Up-brightgreen" alt="docs">
    </a>
    <!-- License -->
    <a href="https://github.com/pegasystems/pega-datascientist-tools/blob/master/LICENSE">
      <img src="https://img.shields.io/github/license/pegasystems/pega-datascientist-tools" alt="Apache License 2.0">
    </a>
  </p>

  Open source tooling that helps data scientists working with Pega AI to analyze Pega decisioning and modeling performance.

  We release this under the Apache 2.0 license and welcome contributing back, preferably through pull requests, but just submitting an Issue or sending a note to the authors is fine too. Pega does not make any representation or warranty with respect to this free software.

  The tools help to do analysis on Pega decisioning and predictive analytics as used in solutions such as Customer Decision Hub or Process AI, pull data from the platform, easily build meaningful plots and more. There is a pip-installable Python package, notebooks and other scripts. See the [Graph Gallery](https://pegasystems.github.io/pega-datascientist-tools/Python/articles/graph_gallery.html) for a sample of the graphs you can build to help get insights from the platform or jump right into the [examples](https://pegasystems.github.io/pega-datascientist-tools/Python/examples.html), and [browse the examples folder](https://github.com/pegasystems/pega-datascientist-tools/tree/master/examples).



  For instructions and information, see the [Pega Data Scientist Tools Wiki page](https://github.com/pegasystems/pega-datascientist-tools/wiki). For further examples and the API reference, see the [Documentation](https://pegasystems.github.io/pega-datascientist-tools/).



  We love feedback. If you have interesting analysis plots you would like to share, we are very interested in incoporating them. If you developed tools or library functions that may be of interest to others, consider sending us a pull request. See [Contributing](https://github.com/pegasystems/pega-datascientist-tools/wiki/Contributing) for guidelines.


pkgId: 333f472e85f441d36ceca8e68c301fa8eee2f5715b293773a22ef0860c1e6961
name: python-peakrdl-cli-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for peakrdl-cli
url: https://pypi.org/project/peakrdl-cli/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peakrdl-cli-1.2.0-1.src.rpm
location_href: Packages/python-peakrdl-cli-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  This package implements the command-line interface for the PeakRDL toolchain.


  See the [PeakRDL Documentation](http://peakrdl.readthedocs.io) for more details.

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


pkgId: cc079e8246e5a3021444cf06ef003b7d100a99614803e6ff8151d308ca01a1c0
name: python-peakrdl-python-help
arch: noarch
version: 0.9.4
epoch: 0
release: 1
summary: Development documents and examples for peakrdl-python
url: https://pypi.org/project/peakrdl-python/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peakrdl-python-0.9.4-1.src.rpm
location_href: Packages/python-peakrdl-python-help-0.9.4-1.noarch.rpm
checksum_type: sha256
description:
  ![CI](https://github.com/krcb197/PeakRDL-python/actions/workflows/action.yaml/badge.svg)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/peakrdl-python.svg)](https://pypi.org/project/peakrdl-python)
  [![Documentation Status](https://readthedocs.org/projects/peakrdl-python/badge/?version=latest)](https://peakrdl-python.readthedocs.io/en/latest/?badge=latest)
  [![Downloads](https://static.pepy.tech/badge/peakrdl-python)](https://pepy.tech/project/peakrdl-python)


  Generate Python Register Access Layer (RAL) from SystemRDL


  See the [peakrdl-python Documentation](https://peakrdl-python.readthedocs.io/) for more details



  In order to address a major limitation of peakrdl-python that prevented it from implementing the
  full systemRDL specification, a breaking API change was needed for handling blocks:
  * registers (in register array)
  * memory entries in a memory

  Users are encouraged to upgrade in order to avoid this limitation. However, there is a legacy mode
  to support users with existing designs, see: _Legacy Block Callback and Block Access_ in the
  documentation

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


pkgId: 0f0194e1e512171946d5e592d80a01fb207ef5b658d0f09dd9ef8aedc174487f
name: python-peakrdl-regblock-help
arch: noarch
version: 0.23.0
epoch: 0
release: 1
summary: Development documents and examples for peakrdl-regblock
url: https://pypi.org/project/peakrdl-regblock/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peakrdl-regblock-0.23.0-1.src.rpm
location_href: Packages/python-peakrdl-regblock-help-0.23.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/peakrdl-regblock/badge/?version=latest)](http://peakrdl-regblock.readthedocs.io)
  [![build](https://github.com/SystemRDL/PeakRDL-regblock/workflows/build/badge.svg)](https://github.com/SystemRDL/PeakRDL-regblock/actions?query=workflow%3Abuild+branch%3Amain)
  [![Coverage Status](https://coveralls.io/repos/github/SystemRDL/PeakRDL-regblock/badge.svg?branch=main)](https://coveralls.io/github/SystemRDL/PeakRDL-regblock?branch=main)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/peakrdl-regblock.svg)](https://pypi.org/project/peakrdl-regblock)


  Compile SystemRDL into a SystemVerilog control/status register (CSR) block.

  For the command line tool, see the [PeakRDL project](https://peakrdl.readthedocs.io).


  See the [PeakRDL-regblock Documentation](http://peakrdl-regblock.readthedocs.io) for more details


pkgId: d032700c81684e45364228d4272a8b954024d74b122cab3bd3bdab4552fe6d75
name: python-peblar-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for peblar
url: https://pypi.org/project/peblar/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peblar-0.1.1-1.src.rpm
location_href: Packages/python-peblar-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub Release][releases-shield]][releases]
  [![Python Versions][python-versions-shield]][pypi]
  ![Project Stage][project-stage-shield]
  ![Project Maintenance][maintenance-shield]
  [![License][license-shield]](LICENSE.md)

  [![Build Status][build-shield]][build]
  [![Code Coverage][codecov-shield]][codecov]
  [![Quality Gate Status][sonarcloud-shield]][sonarcloud]
  [![Open in Dev Containers][devcontainer-shield]][devcontainer]

  [![Sponsor Frenck via GitHub Sponsors][github-sponsors-shield]][github-sponsors]

  [![Support Frenck on Patreon][patreon-shield]][patreon]

  Asynchronous Python client for Peblar's Rocksolid EV chargers



  This package allows you to control and monitor [Peblar EV Chargers](https://peblar.com)
  programmatically. It is mainly created to allow third-party programs to
  automate the behavior of a Peblar charger.

  Additionally, this package contains a CLI tool, which can be used standalone,
  proving a command-line interface to control and monitor Peblar chargers.

  Known compatible and tested Peblar chargers:

  - Peblar Home



  ```bash
  pip install peblar
  ```

  In case you want to use the CLI tools, install the package with the following
  extra:

  ```bash
  pip install peblar[cli]
  ```



  The Peblar CLI tool provided in this library provides all the functionalities
  this library provides but from the command line.

  The CLI comes with built-in help, which can be accessed by using the `--help`

  ```bash
  peblar --help
  ```

  To scan for Peblar chargers on your network:

  ```bash
  peblar scan
  ```

  For more details, access the built-in help of the CLI using the `--help` flag.



  Using this library in Python:

  ```python
  import asyncio

  from peblar import Peblar


  async def main() -> None:
      """Show example of programmatically control a Peblar charger."""
      async with Peblar(host="192.168.1.123") as peblar:
          await peblar.login(password="Sup3rS3cr3t!")

          await peblar.identify()

          system_information = await peblar.system_information()
          print(system_information)


  if __name__ == "__main__":
      asyncio.run(main())
  ```



  This repository keeps a change log using [GitHub's releases][releases]
  functionality. The format of the log is based on
  [Keep a Changelog][keepchangelog].

  Releases are based on [Semantic Versioning][semver], and use the format
  of `MAJOR.MINOR.PATCH`. In a nutshell, the version will be incremented
  based on the following:

  - `MAJOR`: Incompatible or major changes.
  - `MINOR`: Backwards-compatible new features and enhancements.
  - `PATCH`: Backwards-compatible bugfixes and package updates.



  This is an active open-source project. We are always open to people who want to
  use the code or contribute to it.

  We've set up a separate document for our
  [contribution guidelines](CONTRIBUTING.md).

  Thank you for being involved! :heart_eyes:



  The easiest way to start is by opening a CodeSpace here on GitHub, or by using
  the [Dev Container][devcontainer] feature of Visual Studio Code.

  [![Open in Dev Containers][devcontainer-shield]][devcontainer]

  This Python project is fully managed using the [uv] dependency manager. But also relies on the use of NodeJS for certain checks during development.

  You need at least:

  - Python 3.11+
  - [uv][uv-install]
  - NodeJS 20+ (including NPM)

  To install all packages, including all development requirements:

  ```bash
  npm install
  uv sync --extra cli
  ```

  As this repository uses the [pre-commit][pre-commit] framework, all changes
  are linted and tested with each commit. You can run all checks and tests
  manually, using the following command:

  ```bash
  uv run pre-commit run --all-files
  ```

  To run just the Python tests:

  ```bash
  uv run pytest
  ```



  The original setup of this repository is by [Franck Nijhof][frenck].

  For a full list of all authors and contributors,
  check [the contributor's page][contributors].



  MIT License

  Copyright (c) 2024 Franck Nijhof

  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.

  [build-shield]: https://github.com/frenck/python-peblar/actions/workflows/tests.yaml/badge.svg
  [build]: https://github.com/frenck/python-peblar/actions/workflows/tests.yaml
  [codecov-shield]: https://codecov.io/gh/frenck/python-peblar/branch/master/graph/badge.svg
  [codecov]: https://codecov.io/gh/frenck/python-peblar
  [contributors]: https://github.com/frenck/python-peblar/graphs/contributors
  [devcontainer-shield]: https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode
  [devcontainer]: https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/frenck/python-peblar
  [frenck]: https://github.com/frenck
  [github-sponsors-shield]: https://frenck.dev/wp-content/uploads/2019/12/github_sponsor.png
  [github-sponsors]: https://github.com/sponsors/frenck
  [keepchangelog]: http://keepachangelog.com/en/1.0.0/
  [license-shield]: https://img.shields.io/github/license/frenck/python-peblar.svg
  [maintenance-shield]: https://img.shields.io/maintenance/yes/2023-2024.svg
  [patreon-shield]: https://frenck.dev/wp-content/uploads/2019/12/patreon.png
  [patreon]: https://www.patreon.com/frenck
  [uv-install]: https://docs.astral.sh/uv/getting-started/installation/
  [uv]: https://docs.astral.sh/uv/
  [pre-commit]: https://pre-commit.com/
  [project-stage-shield]: https://img.shields.io/badge/project%20stage-production%20ready-brightgreen.svg
  [pypi]: https://pypi.org/project/peblar/
  [python-versions-shield]: https://img.shields.io/pypi/pyversions/peblar
  [releases-shield]: https://img.shields.io/github/release/frenck/python-peblar.svg
  [releases]: https://github.com/frenck/python-peblar/releases
  [semver]: http://semver.org/spec/v2.0.0.html
  [sonarcloud-shield]: https://sonarcloud.io/api/project_badges/measure?project=frenck_python-peblar&metric=alert_status
  [sonarcloud]: https://sonarcloud.io/summary/new_code?id=frenck_python-peblar


pkgId: 904016c8def83f489d197c24ad97926a74242ca8e364f0193e4278a4ef0494ed
name: python-pedon-help
arch: noarch
version: 0.0.7
epoch: 0
release: 1
summary: Development documents and examples for pedon
url: https://pypi.org/project/pedon/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pedon-0.0.7-1.src.rpm
location_href: Packages/python-pedon-help-0.0.7-1.noarch.rpm
checksum_type: sha256
description:
  *from Greek: πέδον, pedon -> soil*

  [![PyPI](https://img.shields.io/pypi/v/pedon?style=flat-square)](https://pypi.org/project/pedon/)
  [![PyPi Supported Python Versions](https://img.shields.io/pypi/pyversions/pedon?style=flat-square)](https://pypi.org/project/pedon/)
  [![Code Size](https://img.shields.io/github/languages/code-size/martinvonk/pedon?style=flat-square)](https://pypi.org/project/pedon/)
  [![PyPi Downloads](https://img.shields.io/pypi/dm/pedon?style=flat-square) ![License](https://img.shields.io/pypi/l/pedon?style=flat-square)](https://pypi.org/project/pedon/)

  [![Tests](https://img.shields.io/github/actions/workflow/status/martinvonk/pedon/tests.yaml?style=flat-square)](https://github.com/martinvonk/pedon/actions/workflows/tests.yaml)
  [![MyPy](https://img.shields.io/badge/type_checker-mypy-2A6DB2?style=flat-square)](https://mypy-lang.org/)
  [![Format: isort](https://img.shields.io/badge/imports-isort-ef8336?style=flat-square)](https://pycqa.github.io/isort/index.html)
  [![Format: Black](https://img.shields.io/badge/code_style-black-black?style=flat-square)](https://github.com/psf/black)
  [![Linter: flake8](https://img.shields.io/badge/linter-flake8-yellowgreen?style=flat-square)](https://flake8.pycqa.org/)
  [![Linter: ruff](https://img.shields.io/badge/linter-ruff-red?style=flat-square)](https://github.com/charliermarsh/ruff)


  Python package for (unsaturated) soil properties including pedotransfer functions. This package takes an object-oriented approach to soils, soil samples and soil models. Soil models that are available in this package are:
    - [Mualem-Van Genuchten](http://www.soilphysics.okstate.edu/teaching/soil-6583/references-folder/van%20Genuchten%201980.pdf)
    - [Brooks-Corey](https://www.wipp.energy.gov/library/cra/2009_cra/references/Others/Brooks_Corey_1964_Hydraulic_Properties_ERMS241117.pdf)
    - [Fredlund & Xing](http://projects.mans.edu.eg/heepf/ilppp/cources/12/pdf%20course/1/pressure/osmotic%20soilsalinity22.pdf)
    - Gardner
    - Panday ([Modflow-USG](https://www.gsienv.com/product/modflow-usg/))

  This package can fit soil water retention curves and  using least squares (same as [RETC](https://www.pc-progress.com/Documents/programs/retc.pdf)) to measurements.

  Measurements for different soil properties and parameters are available from these datasets:
    - [HYDRUS](https://www2.pc-progress.com/downloads/Pgm_Hydrus3D5/HYDRUS_user_Manual_V5.pdf)
    - [VS2D](https://pubs.usgs.gov/wri/1983/4099/report.pdf)
    - Staring Series ([2001](https://edepot.wur.nl/43272) & [2018](https://edepot.wur.nl/512761))

  Additionaly, there are pedotransfer functions implemented such as:
    - Van Genuchten: [Wösten](https://www.sciencedirect.com/science/article/pii/S0016706198001323/pdfft?md5=6844f89c07deb81001c2a6eea6fc9e32&pid=1-s2.0-S0016706198001323-main.pdf)
    - Van Genuchten: [Staring Series](https://edepot.wur.nl/43272)
    - Brooks-Corey: [Cosby](https://hess.copernicus.org/articles/25/2445/2021/hess-25-2445-2021.pdf)


  To get the latest stable version install using:

  `pip install pedon`

  To get the development version download the GitHub code to your computer. Use cd to get to the download directory and install using:

  `pip install -e .`



  - [ ] Rosetta Pedotransfer Function
  - [ ] Other soil models such as Haverkamp

rpm_license:
  MIT License  Copyright (c) 2023 Martin Vonk  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: 74e5bd5d6dd9b49934ab442b5ccfcb8e6697638cd517172b192583e001f7d983
name: python-peepdf-3-help
arch: noarch
version: 4.1.0
epoch: 0
release: 1
summary: Development documents and examples for peepdf-3
url: https://github.com/digitalsleuth/peepdf-3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peepdf-3-4.1.0-1.src.rpm
location_href: Packages/python-peepdf-3-help-4.1.0-1.noarch.rpm
checksum_type: sha256
description:
  peepdf-3 is a **Python 3 tool to explore PDF files** in order to find out if the file can be harmful or not. The aim of this tool is to provide all the necessary components that
  a security researcher could need in a PDF analysis without using 3 or 4 tools to make
  all the tasks.

  With peepdf it's possible to see all the objects in the document showing
  the suspicious elements, supports all the most used filters and encodings, it can parse different versions of a file, object streams and encrypted files. With the installation
  of [STPyV8](https://github.com/cloudflare/stpyv8) and [Pylibemu](https://github.com/buffer/pylibemu) it provides **Javascript and shellcode analysis** wrappers too. Apart of this it's able to create new PDF files and to modify/obfuscate existent ones.

  As of version 3.0.0, peepdf-3 no longer includes pylibemu as a **requirement** in order to use peepdf-3 on Windows systems. However, all functionality of libemu, pylibemu, and sctest still exist, and will function on Linux systems.


  ![PyPI - Version](https://img.shields.io/pypi/v/peepdf-3)



  The main functionalities of peepdf are the following:

  **Analysis:**

    * Decodings: hexadecimal, octal, name objects
    * More used filters
    * References in objects and where an object is referenced
    * Strings search (including streams)
    * Physical structure (offsets)
    * Logical tree structure
    * Metadata
    * Modifications between versions (changelog)
    * Compressed objects (object streams)
    * Analysis and modification of Javascript (STPyV8): unescape, replace, join
    * Shellcode analysis (Libemu python wrapper, pylibemu)
    * Variables (set command)
    * Extraction of old versions of the document
    * Easy extraction of objects, Javascript code, shellcodes (>, >>, $>, $>>)
    * Checking hashes on **VirusTotal**
    * Detection of common encryption methods
    * Output of XML and JSON data


  **Creation/Modification:**

    * Basic PDF creation
    * Creation of PDF with Javascript executed wen the document is opened
    * Creation of object streams to compress objects
    * Embedded PDFs
    * Strings and names obfuscation
    * Malformed PDF output: without endobj, garbage in the header, bad header...
    * Filters modification
    * Objects modification


  **Ways to use peepdf:**

    * Basic execution
    * Interactive console
    * Script mode
    * JSON Output
    * XML Output
    * VirusTotal analysis
    * OCR


  **TODO:**

    * Embedded PDFs analysis
    * Improving automatic Javascript analysis
    * GUI


  **Related articles:**

    * [Spammed CVE-2013-2729 PDF exploit dropping ZeuS-P2P/Gameover](http://eternal-todo.com/blog/cve-2013-2729-exploit-zeusp2p-gameover)
    * [New peepdf v0.2 (Version Black Hat Vegas 2012)](http://eternal-todo.com/blog/peepdf-v0.2-black-hat-usa-arsenal-vegas)
    * [peepdf supports CCITTFaxDecode encoded streams](http://eternal-todo.com/blog/peepdf-ccittfaxdecode-support)
    * [Explanation of the changelog of peepdf for Black Hat Europe Arsenal 2012](http://eternal-todo.com/blog/peepdf-black-hat-arsenal-2012)
    * [How to extract streams and shellcodes from a PDF, the easy way](http://eternal-todo.com/blog/extract-streams-shellcode-peepdf)
    * [Static analysis of a CVE-2011-2462 PDF exploit](http://eternal-todo.com/blog/cve-2011-2462-exploit-analysis-peepdf)
    * [Analysis of a malicious PDF from a SEO Sploit Pack](http://eternal-todo.com/blog/seo-sploit-pack-pdf-analysis)
    * Analysing the [Honeynet Project challenge PDF file](http://www.honeynet.org/challenges/2010_6_malicious_pdf) with peepdf [Part 1](http://eternal-todo.com/blog/analysing-honeynet-pdf-challenge-peepdf-i) [Part 2](http://eternal-todo.com/blog/analysing-honeynet-pdf-challenge-peepdf-ii)
    * [Analyzing Suspicious PDF Files With Peepdf](http://blog.zeltser.com/post/6780160077/peepdf-malicious-pdf-analysis)


  **Included in:**

    * [REMnux](https://remnux.org)



  You can install / use peepdf-3 via these methods:

    * From PyPI via pip - `python3 -m pip install peepdf-3`
    * From GitHub via pip and git - `python3 -m pip install git+https://github.com/digitalsleuth/peepdf-3.git`
    * Clone the GitHub repo, cd into the `peepdf-3` folder, `chmod +x peepdf.py` and `./peepdf.py`



    * As of version 3.0.0, there are no limitations with the installation and usage of peepdf-3, as the hard requirement for pylibemu has been lifted. The functionality still remains for Linux systems.



    * The current maintainer of this project (Corey Forman - digitalsleuth), does not receive any funding for, and is not currently seeking any monetary contributions for this work. If you are willing to provide assistance, programming contributions, and feedback, that is always welcome.
    * As this project originated with Jose Miguel Esparza, I will continue to leave his sentiments, and PayPal link, below to acknowledge his original product.

  **You are free to contribute with feedback, bugs, patches, etc. Any help is welcome. Also, if you really enjoy using peepdf, you think it is worth it and you feel really generous today you can donate some bucks to the project ;) Thanks!**

  [![](https://www.paypal.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=X5RRGLX5DTNKS)

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: 62e037d322d8d49ace41cd15ece5a43826256cb44c1d27e97b86c50b4d539a3b
name: python-peepshow-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for peepshow
url: https://gergelyk.github.io/peepshow
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peepshow-0.3.0-1.src.rpm
location_href: Packages/python-peepshow-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/peepshow)
  ![PyPI - License](https://img.shields.io/pypi/l/peepshow)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/peepshow)

  Provides following utilities for debugging Python applications:

  * show - lightweight function that prints name and value of your variable(s) to the console.
  * peep - featured, interactive interface for data inspection.

  ![](https://raw.githubusercontent.com/gergelyk/peepshow/master/docs/demo.gif)



  * Documentation: <https://gergelyk.github.io/peepshow>
  * Repository: <https://github.com/gergelyk/peepshow>
  * Package: <https://pypi.python.org/pypi/peepshow>
  * Author: [Grzegorz Krasoń](mailto:grzegorz.krason@gmail.com)
  * License: [MIT](LICENSE)



  Install `peepshow` package:

  ```sh
  pip install peepshow
  ```

  PeepShow uses `clear`, `vim`, `man` commands which are available in most of Linux distributions. Users of other operating systems need to install them on their own.



  If you expect to use peepshow often, consider adding `peep` and `show` commands to Python's built-ins and enabling except hook. Edit either `{site-packages}/sitecustomize.py` or `{user-site-packages}/usercustomize.py` and append the following:

  ```python
  import peepshow
  import builtins
  builtins.peep = peepshow.peep
  builtins.show = peepshow.show
  builtins.peep_ = peepshow.peep_
  builtins.show_ = peepshow.show_
  peepshow.enable_except_hook(consider_env=True)
  ```



  It is also possible to invoke `peep()` as a result of calling built-in function `breakpoint()`. To enable such behavior use `PYTHONBREAKPOINT` system variable:

  ```sh
  export PYTHONBREAKPOINT=peepshow.peep
  ```



  * This software is expected to work with Python 3.6, 3.7, 3.8 and compatible.
  * It has never been tested under operating systems other than Linux.
  * It works fine when started in a plain Python script, in ipython or ptipython.
  * In these environments like interactive python console, in pdb and ipdb, peep and show cannot infer names of the variables in the user context, so they need to be provided explicitly (e.g. use `peep_` and `show_`).





  Running this script:

  ```python
  x = 123
  y = {'name': 'John', 'age': 123}
  z = "Hello World!"


  show()


  show(x, y)


  show(my_var=x)


  show_('x')


  show_('x + 321', zet='z')
  ```

  will result in following output:

  ```
  x = 123
  y = {'age': 123, 'name': 'John'}
  z = 'Hello World!'
  x = 123
  y = {'age': 123, 'name': 'John'}
  my_var = 123
  x = 123
  x + 321 = 444
  zet = 'Hello World!'
  ```



  Try running the following script:

  ```python
  x = 123
  y = {'name': 'John', 'age': 123}
  z = "Hello World!"


  peep()


  peep(x)


  peep_('x')
  ```

  When interactive interface pops up:

  * Hit ENTER to see list of available variables.
  * Type `10` and hit ENTER to select `y`.
  * Hit ENTER again to see items of your dictionary.
  * Type `dir` and hit ENTER to list attributes of `y` (excluding built-ins).
  * Type `continue` and hit ENTER to proceed or type `quit` and hit ENTER to terminate your script.

  Note that all the commands have their short aliases. E.g. `quit` and `q` is the same.

  For more help:

  * Type `help` and hit ENTER to see list of available commands.
  * Type `man` and hit ENTER to read the manual, hit `q` when you are done.



  Before running your script, set environment variable `PYTHON_PEEP_EXCEPTIONS` to `1`. Now run the script and see what happens when an exception is raised.



  ```sh

  pip install --user poetry  # unless already installed
  poetry install


  poetry run pytest --cov peepshow --cov tests


  poetry run mkdocs serve


  poetry build


  poetry version minor  # increment selected component
  git commit -am "bump version"
  git push
  git tag ${$(poetry version)[2]}
  git push --tags
  poetry build
  poetry publish
  poetry run mkdocs build
  poetry run mkdocs gh-deploy -b gh-pages
  ```



  If you find this software useful and you would like to repay author's efforts you are welcome to use following button:

  [![Donate](https://www.paypalobjects.com/en_US/PL/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=D9KUJD9LTKJY8&source=url)


pkgId: 318923db7d47b8c277efc32fa5bdb665561b2b520c98b5ff196cf32440a1457b
name: python-penaltyblog-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for penaltyblog
url: https://github.com/martineastwood/penaltyblog
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-penaltyblog-1.0.1-1.src.rpm
location_href: Packages/python-penaltyblog-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <img src="https://raw.githubusercontent.com/martineastwood/penaltyblog/refs/heads/master/logo.png" width="0" height="0" style="display:none;"/>

  <meta property="og:image" content="https://raw.githubusercontent.com/martineastwood/penaltyblog/refs/heads/master/logo.png" />
  <meta property="og:image:alt" content="penaltyblog python package for soccer modeling" />
  <meta name="twitter:image" content="https://raw.githubusercontent.com/martineastwood/penaltyblog/refs/heads/master/logo.png">
  <meta name="twitter:card" content="summary_large_image">



  <div align="center">

    <a href="">[![Python Version](https://img.shields.io/pypi/pyversions/penaltyblog)](https://pypi.org/project/penaltyblog/)</a>
  <a href="https://codecov.io/github/martineastwood/penaltyblog" >
  <img src="https://codecov.io/github/martineastwood/penaltyblog/branch/master/graph/badge.svg?token=P0WDHRGIG2"/>
  </a>
    <a href="">[![PyPI](https://img.shields.io/pypi/v/penaltyblog.svg)](https://pypi.org/project/penaltyblog/)</a>
    <a href="">[![Downloads](https://static.pepy.tech/badge/penaltyblog)](https://pepy.tech/project/penaltyblog)</a>
    <a href="">[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)</a>
    <a href="">[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)</a>
    <a href="">[![Code style: pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)</a>

  </div>


  <div align="center">
    <img src="logo.png" alt="Penalty Blog Logo" width="200">
  </div>



  The **penaltyblog** Python package contains lots of useful code from [pena.lt/y/blog](http://pena.lt/y/blog.html) for working with football (soccer) data.

  **penaltyblog** includes functions for:

  - Scraping football data from sources such as football-data.co.uk, FBRef, Club Elo, Understat and Fantasy Premier League
  - Modelling of football matches using Poisson-based models, such as Dixon and Coles, and Bayesian models
  - Predicting probabilities for many betting markets, e.g. Asian handicaps, over/under, total goals etc
  - Modelling football team's abilities using Massey ratings, Colley ratings and Elo ratings
  - Estimating the implied odds from bookmaker's odds by removing the overround using multiple different methods
  - Estimating goal expectancy from bookmaker's odds
  - Mathematically optimising your fantasy football team



  `pip install penaltyblog`




  The Bayesian models in `penaltyblog` require the [Stan probabilistic programming language](https://mc-stan.org/) to function. You can use the following command to install Stan directly from the penaltyblog package:

  ```python
  import penaltyblog as pb

  pb.install_stan()
  ```



  To learn how to use `penaltyblog`, you can read the [documentation](https://penaltyblog.readthedocs.io/en/stable/) and look at the
  examples for:

  - [Scraping football data](https://penaltyblog.readthedocs.io/en/stable/scrapers/index.html)
  - [Predicting football matches and betting markets](https://penaltyblog.readthedocs.io/en/stable/models/index.html)
  - [Estimating the implied odds from bookmakers odds](https://penaltyblog.readthedocs.io/en/stable/implied/index.html)
  - [Calculate Massey, Colley and Elo ratings](https://penaltyblog.readthedocs.io/en/stable/ratings/index.html)



  - Mark J. Dixon and Stuart G. Coles (1997) Modelling Association Football Scores and Inefficiencies in the Football Betting Market
  - Håvard Rue and Øyvind Salvesen (1999) Prediction and Retrospective Analysis of Soccer Matches in a League
  - Anthony C. Constantinou and Norman E. Fenton (2012) Solving the problem of inadequate scoring rules for assessing probabilistic football forecast models
  - Hyun Song Shin (1992) Prices of State Contingent Claims with Insider Traders, and the Favourite-Longshot Bias
  - Hyun Song Shin (1993) Measuring the Incidence of Insider Trading in a Market for State-Contingent Claims
  - Joseph Buchdahl (2015) The Wisdom of the Crowd
  - Gianluca Baio and Marta A. Blangiardo (2010) Bayesian Hierarchical Model for the Prediction of Football Results


pkgId: b90fa4aee97afa028a5330a9f71483cb9e6273d589b8bee1f7c80a76cd43126a
name: python-pennylane-sphinx-theme-help
arch: noarch
version: 0.6.1
epoch: 0
release: 1
summary: Development documents and examples for pennylane-sphinx-theme
url: https://github.com/XanaduAI/pennylane-sphinx-theme
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pennylane-sphinx-theme-0.6.1-1.src.rpm
location_href: Packages/python-pennylane-sphinx-theme-help-0.6.1-1.noarch.rpm
checksum_type: sha256
description:
  The PennyLane Sphinx Theme requires Python 3.7 or later. The latest version of the
  theme can be installed directly using ``pip``:
      pip install pennylane-sphinx-theme


pkgId: d20b8f473baafebad288fa17982d452caef27cd37c4a72b89cd1d10a221c7493
name: python-pepBridge-help
arch: noarch
version: 1.0.41
epoch: 0
release: 1
summary: Development documents and examples for pepBridge
url: https://github.com/carlos-madrid-aliste/pepBridge
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepBridge-1.0.41-1.src.rpm
location_href: Packages/python-pepBridge-help-1.0.41-1.noarch.rpm
checksum_type: sha256
description:
  Easy way to match MALDI-MSI (m/z) peaks to the peptides (m/z) from LC-MS/MS




  `pepBridge` is a Python package for processing and matching MALDI and LCMS mass spectrometry data.

  - Load MALDI and LCMS data from configuration files and CSVs.
  - Match MALDI masses with LCMS masses within a specified tolerance.
  - Output matched data to CSV.





  The easiest way to work with pepBridge is by using Anaconda and configuring a virtual environment. Anaconda
  is a Python distribution plus a packaging manager called conda.



  ```bash
  conda create --name pepBridge python=3.9
  ```


  ```bash
  conda activate pepBridge
  ```


  ```bash
  pip install pepBridge

  or

  pip install -i https://test.pypi.org/simple/ pepBridge

  ```



  ```bash
  (pepBridge)$ pepbridge --help
  usage: pepbridge [-h] [--maldi MALDI] [--lcms LCMS] [--mass MASS] [--output OUTPUT] [--version]

  Easy way to match MALDI-MSI (m/z) peaks to the peptides (m/z) from LC-MS/MS

  optional arguments:
    -h, --help       show this help message and exit
    --maldi MALDI    location of the MALDI INI file.
    --lcms LCMS      location of the LCMS INI file.
    --mass MASS      Mass tolerance in Da (float number) (default=1.0 Da)
    --output OUTPUT  Output file in CSV format.
    --version        Show the version of pepBridge.
  ```


  ```bash
  python pepbridge  --maldi maldi.ini --lcms lcms.ini --mass 1.0 --output matched_results_1.0.csv
  ```


  `pepBridge` requires two configuration files to run properly. By defaut the names of the files
  are maldi.ini and lcms.ini. Basic *.ini files can be copied to the current workign directory typing


  ```sh
      (pepBridge) C:\Users>copy_data
  ```

  The above command copy lcms.ini, maldi.ini and two csv files in the current working directory.

  ```sh
     IMS199_OTD196_GK_Thymus_ChemoL_v_CtrlR_MALDI_Match_LCMS_wTrypsinR05_4K_Oct2024_LCMS.csv
     IMS199_OTD196_GK_Thymus_ChemoL_v_CtrlR_MALDI_Match_LCMS_wTrypsinR05_4K_Oct2024_MALDI.csv
  ```

  lcms.ini and maldi.ini are text files consisting of key-value pairs of properties, and sections that organize
  the properties. lcms.ini/maldi.ini consist in seven sections; [file], [ms_level], [round_mz], [mz_column_name],
  [verbose], [column_names], [order_columns].


  ```bash


  [file]
  ; Specify the full file path of the MALDI CSV file that contains your data.
  ; This file is used as input for comparison with LCMS data.
  name=/home/cmadrid/DATA/199-196/4K/IMS199_OTD196_GK_Thymus_ChemoL_v_CtrlR_MALDI_Match_LCMS_4K_MALDI.csv

  [round_mz]
  ; Determine whether the m/z values should be rounded to the nearest integer
  ; before comparing them with LCMS data. Set to "True" to round m/z value
  value=True
  column_name=rounded_mz

  [mz_column_name]
  ; Specify the name of the column that hold the m/z values in the CSV file.
  name=${column_names:column1}

  [verbose]
  ; Enable or disable verbose output during the process.
  ; Set to "True" for detailed logs to help with troubleshooting or
  ; understanding the process.
  value=True


  [column_names]
  ; Define the names of the columns in the MALDI CSV file.
  ; These column names will be used for data extraction.
  column1=m/z
  column2=Average
  column3=IMS199_Chemo_Left_4K
  column4=IMS199_Control_Right_Bottom_4K
  column5=IMS199_Control_Right_Top_4K

  [order_columns]
  ; Specify the order in which columns should appear in the output file.
  ; The columns will be printed in the specified order, with optional
  ; modifications such as rounded m/z.
  column1=${column_names:column1}
  column2=${round_mz:column_name}
  column3=${column_names:column2}
  column4=${column_names:column3}
  column5=${column_names:column4}
  column6=${column_names:column5}
  ```



  ```bash
  [file]
  ; Specify the full file path of the MALDI CSV file that contains your data.
  ; This file is used as input for comparison with LCMS data.
  name=/home/cmadrid/DATA/withTrypsin/IMS199_OTD196_GK_Thymus_ChemoL_v_CtrlR_MALDI_Match_LCMS_wTrypsinR05_4K_Oct2024_LCMS.csv

  [round_mz]
  ; Determine whether the m/z values should be rounded to the nearest integer
  ; before comparing them with LCMS data. Set to "True" to round m/z value
  value=True
  column_name=rounded_mz

  [mz_column_name]
  ; Specify the name of the column that hold the m/z values in the CSV file.
  name=${column_names:column1}

  [verbose]
  ; Enable or disable verbose output during the process.
  ; Set to "True" for detailed logs to help with troubleshooting or
  ; understanding the process.
  value=True

  [column_names]
  ; Define the names of the columns in the MALDI CSV file.
  ; These column names will be used for data extraction.
  column1=Theo. MH+ [Da]
  column2=Master Protein Accessions
  column3=Master Protein Descriptions
  column4=Gene Name
  column5=Annotated Sequence
  column6=Modifications
  column7=196a_Left_1 Chemo
  column8=196a_Right_2 - Control
  column9=log2 ratio Chemo vs Control

  [order_columns]
  ; Specify the order in which columns should appear in the output file.
  ; The columns will be printed in the specified order, with optional
  ; modifications such as rounded m/z.
  column1=${column_names:column1}
  column2=${round_mz:column_name}
  column3=${column_names:column2}
  column4=${column_names:column3}
  column5=${column_names:column4}
  column6=${column_names:column5}
  column7=${column_names:column6}
  column8=${column_names:column7}
  column9=${column_names:column8}
  column10=${column_names:column9}
  ```

  ![UML Class Diagram](pepBridge/class_diagrams/pepBridge_class_diagram-1.png)


pkgId: 88ce86bdc422a3d519b36d29d559ebb086694e0c1f0a044e2f16c25c539e0ea0
name: python-pepecoin-help
arch: noarch
version: 0.0.12
epoch: 0
release: 1
summary: Development documents and examples for pepecoin
url: https://pypi.org/project/pepecoin/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepecoin-0.0.12-1.src.rpm
location_href: Packages/python-pepecoin-help-0.0.12-1.noarch.rpm
checksum_type: sha256
description:
  - **Simplified RPC Connection**: Easily connect to a Pepecoin node using RPC.
  - **Wallet Management**: Create, encrypt, lock, and unlock wallets.
  - **Address Generation**: Generate new Pepecoin addresses with optional labels.
  - **Balance Checking**: Check the balance of wallets.
  - **Payment Verification**: Verify if payments have been received at specific addresses.
  - **Mass Transfer**: Transfer funds from multiple wallets to a single address.


pkgId: 4e0d9b3fdc67e4c5c07ed38eace00b2a55be1ca3517a003886ecb7ac152e9f6f
name: python-pepperize.cdk-apigateway-swagger-ui-help
arch: noarch
version: 0.0.1155
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-apigateway-swagger-ui
url: https://github.com/pepperize/cdk-apigateway-swagger-ui.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-apigateway-swagger-ui-0.0.1155-1.src.rpm
location_href: Packages/python-pepperize.cdk-apigateway-swagger-ui-help-0.0.1155-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-apigateway-swagger-ui?style=flat-square)](https://github.com/pepperize/cdk-apigateway-swagger-ui/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-apigateway-swagger-ui?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-apigateway-swagger-ui)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-apigateway-swagger-ui?style=flat-square)](https://pypi.org/project/pepperize.cdk-apigateway-swagger-ui/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.ApigatewaySwaggerUi?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.ApigatewaySwaggerUi/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-apigateway-swagger-ui?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-apigateway-swagger-ui/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-apigateway-swagger-ui/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-apigateway-swagger-ui/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-apigateway-swagger-ui?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-apigateway-swagger-ui/releases)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/pepperize/cdk-apigateway-swagger-ui)



  Add SwaggerUI to your AWS Apigateway RestApi

  ![SwaggerUI Example](./images/swagger-ui-example.png)





  ```shell
  npm install @pepperize/cdk-apigateway-swagger-ui
  ```

  or

  ```shell
  yarn add @pepperize/cdk-apigateway-swagger-ui
  ```



  ```shell
  pip install pepperize.cdk-apigateway-swagger-ui
  ```



  ```
  dotnet add package Pepperize.CDK.ApigatewaySwaggerUi
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-apigateway-swagger-ui</artifactId>
    <version>${cdkApigatewaySwaggerUi.version}</version>
  </dependency>
  ```



  ```python
  import { Stack } from "aws-cdk-lib";
  import * as apigateway from "aws-cdk-lib/aws-apigateway";
  import { SwaggerUi } from "@pepperize/cdk-apigateway-swagger-ui";

  const stack = new Stack();
  const restApi = new apigateway.RestApi();

  new SwaggerUi(stack, "SwaggerUI", { resource: restApi.root });
  ```

  * Open your SwaggerUI: `https://<rest api id>.execute-api.<aws region>.amazonaws.com/<stage>/api-docs/swagger-ui.html`
  * View your API docs: `https://<rest api id>.execute-api.<aws region>.amazonaws.com/<stage>/api-docs.json`


pkgId: 2fbac0f4da20b9a8821e05614b926e9428973721372d0e0094cb7303fa8cb8a2
name: python-pepperize.cdk-autoscaling-gitlab-runner-help
arch: noarch
version: 0.2.625
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-autoscaling-gitlab-runner
url: https://github.com/pepperize/cdk-autoscaling-gitlab-runner.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-autoscaling-gitlab-runner-0.2.625-1.src.rpm
location_href: Packages/python-pepperize.cdk-autoscaling-gitlab-runner-help-0.2.625-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-autoscaling-gitlab-runner?style=flat-square)](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-autoscaling-gitlab-runner?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-autoscaling-gitlab-runner)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-autoscaling-gitlab-runner?style=flat-square)](https://pypi.org/project/pepperize.cdk-autoscaling-gitlab-runner/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.AutoscalingGitlabRunner?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.AutoscalingGitlabRunner/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-autoscaling-gitlab-runner?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-autoscaling-gitlab-runner/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-autoscaling-gitlab-runner/release.yml?bracnh=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-autoscaling-gitlab-runner?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/releases)



  This project provides a CDK construct to [execute jobs on auto-scaled EC2 instances](https://docs.gitlab.com/runner/configuration/runner_autoscale_aws/index.html) using the [Docker Machine](https://docs.gitlab.com/runner/executors/docker_machine.html) executor.

  > Running out of [Runner minutes](https://about.gitlab.com/pricing/),
  > using [Docker-in-Docker (dind)](https://docs.gitlab.com/ee/ci/docker/using_docker_build.html),
  > speed up jobs with [shared S3 Cache](https://docs.gitlab.com/runner/configuration/autoscale.html#distributed-runners-caching),
  > cross compiling/building environment [multiarch](https://hub.docker.com/r/multiarch/qemu-user-static/),
  > cost effective [autoscaling on EC2](https://docs.gitlab.com/runner/configuration/runner_autoscale_aws/#the-runnersmachine-section),
  > deploy directly from AWS accounts (without [AWS Access Key](https://docs.aws.amazon.com/general/latest/gr/aws-sec-cred-types.html#access-keys-and-secret-access-keys)),
  > running on [Spot instances](https://aws.amazon.com/ec2/spot/),
  > having a bigger [build log size](https://docs.gitlab.com/runner/configuration/advanced-configuration.html)

  [![View on Construct Hub](https://constructs.dev/badge?package=%40pepperize%2Fcdk-autoscaling-gitlab-runner)](https://constructs.dev/packages/@pepperize/cdk-autoscaling-gitlab-runner)





  ```shell
  npm install @pepperize/cdk-autoscaling-gitlab-runner
  ```

  or

  ```shell
  yarn add @pepperize/cdk-autoscaling-gitlab-runner
  ```



  ```shell
  pip install pepperize.cdk-autoscaling-gitlab-runner
  ```



  ```
  dotnet add package Pepperize.CDK.AutoscalingGitlabRunner
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-autoscaling-gitlab-runner</artifactId>
    <version>${cdkAutoscalingGitlabRunner.version}</version>
  </dependency>
  ```



  1. **Create a new AWS CDK App** in TypeScript with [projen](https://github.com/projen/projen)

     ```shell
     mkdir gitlab-runner
     cd gitlab-runner
     git init
     npx projen new awscdk-app-ts
     ```
  2. **Configure your project in `.projenrc.js`**

     * Add `deps: ["@pepperize/cdk-autoscaling-gitlab-runner"],`
  3. **Update project files and install dependencies**

     ```shell
     npx projen
     ```
  4. **Register a new runner**

     [Registering runners](https://docs.gitlab.com/runner/register/):

     * For a [shared runner](https://docs.gitlab.com/ee/ci/runners/#shared-runners), go to the GitLab Admin Area and click **Overview > Runners**
     * For a [group runner](https://docs.gitlab.com/ee/ci/runners/index.html#group-runners), go to **Settings > CI/CD** and expand the **Runners** section
     * For a [project runner](https://docs.gitlab.com/ee/ci/runners/index.html#specific-runners), go to **Settings > CI/CD** and expand the **Runners** section

     *Optionally enable: **Run untagged jobs** [x]
     Indicates whether this runner can pick jobs without tags*

     See also *[Registration token vs. Authentication token](https://docs.gitlab.com/ee/api/runners.html#registration-and-authentication-tokens)*
  5. **Retrieve a new runner authentication token**

     [Register a new runner](https://docs.gitlab.com/ee/api/runners.html#register-a-new-runner)

     ```shell
     curl --request POST "https://gitlab.com/api/v4/runners" --form "token=<your register token>" --form "description=gitlab-runner" --form "tag_list=pepperize,docker,production"
     ```
  6. **Store runner authentication token in SSM ParameterStore**

     [Create a String parameter](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html#param-create-cli-string)

     ```shell
     aws ssm put-parameter --name "/gitlab-runner/token" --value "<your runner authentication token>" --type "String"
     ```
  7. **Add to your `main.ts`**

     ```python
     import { Vpc } from "@aws-cdk/aws-ec2";
     import { App, Stack } from "@aws-cdk/core";
     import { GitlabRunnerAutoscaling } from "@pepperize/cdk-autoscaling-gitlab-runner";

     const app = new App();
     const stack = new Stack(app, "GitLabRunnerStack");
     const vpc = Vpc.fromLookup(app, "ExistingVpc", {
       vpcId: "<your vpc id>",
     });
     const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
       parameterName: "/gitlab-runner/token",
     });
     new GitlabRunnerAutoscaling(stack, "GitlabRunner", {
       network: {
         vpc: vpc,
       },
       runners: [
         {
           token: token,
           configuration: {
             // optionally configure your runner
           },
         },
       ],
     });
     ```
  8. **Create service linked role**

     *(If requesting spot instances, default: true)*

     ```sh
     aws iam create-service-linked-role --aws-service-name spot.amazonaws.com
     ```
  9. **Configure the AWS CLI**

     * [AWSume](https://awsu.me/)
     * [Configuring the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
     * [AWS Single Sign-On](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html)
  10. **Deploy the GitLab Runner**

      ```shell
      npm run deploy
      ```





  By default, an AWS S3 Bucket is created as GitLab Runner's distributed cache.
  It's encrypted and public access is blocked.
  A custom S3 Bucket can be configured:

  ```python
  const cache = new Bucket(this, "Cache", {
    // Your custom bucket
  });
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
      },
    ],
    cache: { bucket: cache },
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/cache.ts),
  [GitlabRunnerAutoscalingCacheProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#gitlabrunnerautoscalingcacheprops-)



  By default, the [amazonec2](https://gitlab.com/gitlab-org/ci-cd/docker-machine/-/blob/main/drivers/amazonec2/amazonec2.go) driver will create an EC2 key pair for each runner. To use custom ssh credentials provide a SecretsManager Secret with the private and public key file:

  1. [Create a key pair](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-key-pairs.html), download the private key file and remember the created key pair name
  2. Generate the public key file

     ```
     ssh-keygen -f <the downloaded private key file> -y
     ```
  3. Create an AWS SecretsManager Secret from the key pair

     ```shell
     aws secretsmanager create-secret --name <the secret name> --secret-string "{\"<the key pair name>\":\"<the private key>\",\"<the key pair name>.pub\":\"<the public key>\"}"
     ```
  4. Configure the job runner

     ```python
     const keyPair = Secret.fromSecretNameV2(stack, "Secret", "CustomEC2KeyPair");

     new GitlabRunnerAutoscaling(this, "Runner", {
       runners: [
         {
           keyPair: keyPair,
           configuration: {
             machine: {
               machineOptions: {
                 keypairName: "<the key pair name>",
               },
             },
           },
         },
       ],
       cache: { bucket: cache },
     });
     ```



  By default, docker machine is configured to run privileged with `CAP_SYS_ADMIN` to support [Docker-in-Docker using the OverlayFS driver](https://docs.gitlab.com/ee/ci/docker/using_docker_build.html#use-the-overlayfs-driver)
  and cross compiling/building with [multiarch](https://hub.docker.com/r/multiarch/qemu-user-static/).

  See [runners.docker section](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnersdocker-section)
  in [Advanced configuration](https://docs.gitlab.com/runner/configuration/advanced-configuration.html)

  ```python
  import { GitlabRunnerAutoscaling } from "@pepperize/cdk-autoscaling-gitlab-runner";
  import { StringParameter } from "aws-cdk-lib/aws-ssm";

  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
        configuration: {
          environment: [], // Reset the OverlayFS driver for every project
          docker: {
            capAdd: [], // Remove the CAP_SYS_ADMIN
            privileged: false, // Run unprivileged
          },
          machine: {
            idleCount: 2, // Number of idle machine
            idleTime: 3000, // Waiting time in idle state
            maxBuilds: 1, // Max builds before instance is removed
          },
        },
      },
    ],
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/docker-machine.ts),
  [DockerConfiguration](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#dockerconfiguration-)



  By default, t3.nano is used for the manager/coordinator and t3.micro instances will be spawned.
  For bigger projects, for example with [webpack](https://webpack.js.org/), this won't be enough memory.

  ```python
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    manager: {
      instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.SMALL),
    },
    runners: [
      {
        instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.LARGE),
        token: token,
        configuration: {
          // optionally configure your runner
        },
      },
    ],
  });
  ```

  > You may have to disable or configure [Spot instances](#spot-instances)

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/instance-type.ts),
  [GitlabRunnerAutoscalingManagerProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#gitlabrunnerautoscalingmanagerprops-),
  [GitlabRunnerAutoscalingJobRunnerProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#gitlabrunnerautoscalingjobrunnerprops-)



  By default, the latest [Amazon 2 Linux](https://aws.amazon.com/amazon-linux-2/) will be used for the manager/coordinator.
  The manager/coordinator instance's cloud init scripts requires [yum](https://access.redhat.com/solutions/9934) is installed, any RHEL flavor should work.
  The requested runner instances by default using Ubuntu 20.04, any OS implemented by the [Docker Machine provisioner](https://gitlab.com/gitlab-org/ci-cd/docker-machine/-/tree/main/libmachine/provision) should work.

  ```python
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    manager: {
      machineImage: MachineImage.genericLinux(managerAmiMap),
    },
    runners: [
      {
        machineImage: MachineImage.genericLinux(runnerAmiMap),
        token: token,
        configuration: {
          // optionally configure your runner
        },
      },
    ],
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/machine-image.ts),
  [GitlabRunnerAutoscalingManagerProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#gitlabrunnerautoscalingmanagerprops-),
  [GitlabRunnerAutoscalingJobRunnerProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#gitlabrunnerautoscalingjobrunnerprops-)



  Each runner defines one `[[runners]]` section in the [configuration file](https://docs.gitlab.com/runner/configuration/).
  Use [Specific runners](https://docs.gitlab.com/ee/ci/runners/runners_scope.html#specific-runners) when you want to use runners for specific projects.

  ```python
  const privilegedRole = new Role(this, "PrivilegedRunnersRole", {
    // role 1
  });

  const restrictedRole = new Role(this, "RestrictedRunnersRole", {
    // role 2
  });

  const token1 = StringParameter.fromStringParameterAttributes(stack, "Token1", {
    parameterName: "/gitlab-runner/token1",
  });

  const token2 = StringParameter.fromStringParameterAttributes(stack, "Token2", {
    parameterName: "/gitlab-runner/token2",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token1,
        configuration: {
          name: "privileged-runner",
        },
        role: privilegedRole,
      },
      {
        token: token2,
        configuration: {
          name: "restricted-runner",
          docker: {
            privileged: false, // Run unprivileged
          },
        },
        role: restrictedRole,
      },
    ],
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/machine-image.ts),
  [GitlabRunnerAutoscalingProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#@pepperize/cdk-autoscaling-gitlab-runner.GitlabRunnerAutoscalingProps)



  By default, EC2 Spot Instances are requested.

  ```python
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
        configuration: {
          machine: {
            machineOptions: {
              requestSpotInstance: false,
              spotPrice: 0.5,
            },
          },
        },
      },
    ],
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/on-demand-instances.ts),
  [EC2 spot price](https://aws.amazon.com/de/ec2/spot/pricing/),
  [MachineConfiguration](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#machineconfiguration-),
  [MachineOptions](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#machineoptions-),
  [Advanced configuration - runners.machine.autoscaling](https://docs.gitlab.com/runner/configuration/advanced-configuration.html#the-runnersmachineautoscaling-sections)



  To build binaries of different architectures can also use [Multiarch](https://wiki.debian.org/Multiarch)

  ```python
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
        configuration: {
          docker: {
            privileged: true,
          },
        },
      },
    ],
  });
  ```

  Configure your [.gitlab-ci.yml](https://docs.gitlab.com/ee/ci/yaml/) file

  ```yaml
  build:
    image: multiarch/debian-debootstrap:armhf-buster
    services:
      - docker:stable-dind
      - name: multiarch/qemu-user-static:register
        command:
          - "--reset"
    script:
      - make build
  ```

  See [multiarch/qemu-user-static](https://hub.docker.com/r/multiarch/qemu-user-static)



  To run your jobs on [AWS Graviton](https://aws.amazon.com/ec2/graviton/) you have to provide an AMI for arm64 architecture.

  ```python
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
        configuration: {
          instanceType: InstanceType.of(InstanceClass.M6G, InstanceSize.LARGE),
          machineImage: MachineImage.genericLinux({
            [this.region]: new LookupMachineImage({
              name: "ubuntu/images/hvm-ssd/ubuntu-focal-20.04-*-server-*",
              owners: ["099720109477"],
              filters: {
                architecture: [InstanceArchitecture.ARM_64],
                "image-type": ["machine"],
                state: ["available"],
                "root-device-type": ["ebs"],
                "virtualization-type": ["hvm"],
              },
            }).getImage(this).imageId,
          }),
        },
      },
    ],
  });
  ```

  See [Ubuntu Amazon EC2 AMI Locator](https://cloud-images.ubuntu.com/locator/ec2/)



  To deploy from within your GitLab Runner Instances, you may pass a Role with the IAM Policies attached.

  ```python
  const role = new Role(this, "RunnersRole", {
    assumedBy: new ServicePrincipal("ec2.amazonaws.com", {}),
    inlinePolicies: {},
  });
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        role: role,
        token: token,
        configuration: {
          // optionally configure your runner
        },
      },
    ],
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/runner-role.ts),
  [GitlabRunnerAutoscalingProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#@pepperize/cdk-autoscaling-gitlab-runner.GitlabRunnerAutoscalingProps)



  If no existing Vpc is passed, a cheap [VPC](https://docs.aws.amazon.com/cdk/api/latest/docs/@aws-cdk_aws-ec2.Vpc.html) with a NatInstance (t3.nano) and a single AZ will be created.

  ```python
  const natInstanceProvider = aws_ec2.NatProvider.instance({
    instanceType: aws_ec2.InstanceType.of(InstanceClass.T3, InstanceSize.NANO), // using a cheaper gateway (not scalable)
  });
  const vpc = new Vpc(this, "Vpc", {
    // Your custom vpc, i.e.:
    natGatewayProvider: natInstanceProvider,
    maxAzs: 1,
  });

  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
        configuration: {
          // optionally configure your runner
        },
      },
    ],
    network: { vpc: vpc },
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/vpc.ts),
  [GitlabRunnerAutoscalingProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#@pepperize/cdk-autoscaling-gitlab-runner.GitlabRunnerAutoscalingProps)



  Deploys the [Autoscaling GitLab Runner on AWS EC2](https://docs.gitlab.com/runner/configuration/runner_autoscale_aws/) with the default settings mentioned above.

  Happy with the presets?

  ```python
  const token = StringParameter.fromStringParameterAttributes(stack, "Token", {
    parameterName: "/gitlab-runner/token",
  });

  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        token: token,
        configuration: {
          // optionally configure your runner
        },
      },
    ],
  });
  ```

  See [example](https://github.com/pepperize/cdk-autoscaling-gitlab-runner-example/blob/main/src/zero-config.ts),
  [GitlabRunnerAutoscalingProps](https://github.com/pepperize/cdk-autoscaling-gitlab-runner/blob/main/API.md#@pepperize/cdk-autoscaling-gitlab-runner.GitlabRunnerAutoscalingProps)



  By default, the GitLab [amzonec2 driver](https://gitlab.com/gitlab-org/ci-cd/docker-machine/-/blob/main/drivers/amazonec2/amazonec2.go) will be configured to install the
  [amazon-ecr-credential-helper](https://docs.aws.amazon.com/AmazonECR/latest/userguide/registry_auth.html#registry-auth-credential-helper)
  on the runner's instances.

  To configure, override the default job runners environment:

  ```python
  new GitlabRunnerAutoscaling(this, "Runner", {
    runners: [
      {
        // ...
        environment: [
          "DOCKER_DRIVER=overlay2",
          "DOCKER_TLS_CERTDIR=/certs",
          'DOCKER_AUTH_CONFIG={"credHelpers": { "public.ecr.aws": "ecr-login", "<aws_account_id>.dkr.ecr.<region>.amazonaws.com": "ecr-login" } }',
        ],
      },
    ],
  });
  ```



  This project uses [projen](https://github.com/projen/projen) to maintain project configuration through code. Thus, the synthesized files with projen should never be manually edited (in fact, projen enforces that).

  To modify the project setup, you should interact with rich strongly-typed
  class [AwsCdkTypeScriptApp](https://github.com/projen/projen/blob/master/API.md#projen-awscdktypescriptapp) and
  execute `npx projen` to update project configuration files.

  > In simple words, developers can only modify `.projenrc.js` file for configuration/maintenance and files under `/src` directory for development.

  See also [Create and Publish CDK Constructs Using projen and jsii](https://github.com/seeebiii/projen-test).


pkgId: 9afd4b3226d4d3deb13cca5a0694cc3c58f83ce6ede57fa85efac225d6876aba
name: python-pepperize.cdk-github-help
arch: noarch
version: 0.0.907
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-github
url: https://github.com/pepperize/cdk-github.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-github-0.0.907-1.src.rpm
location_href: Packages/python-pepperize.cdk-github-help-0.0.907-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-github?style=flat-square)](https://github.com/pepperize/cdk-github/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-github?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-github)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-github?style=flat-square)](https://pypi.org/project/pepperize.cdk-github/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.Github?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.Github/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-github?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-github/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-github/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-github/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-github?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-github/releases)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/pepperize/cdk-github)



  Manage GitHub resources like repositories, teams, members, integrations and workflows with the AWS CDK as Custom Resources in CloudFormation with [cdk-github](https://github.com/pepperize/cdk-github).

  > You configure the endpoint, method and parameters documented by [@octokit/rest](https://octokit.github.io/rest.js/v19) and AWS CloudFormation runs them anytime you create, update (if you changed the custom resource), or delete stacks. When CloudFormation sends a lifecycle event notification, then your custom resource sends the request to the [GitHub REST API](https://docs.github.com/en/rest).

  [![View on Construct Hub](https://constructs.dev/badge?package=%40pepperize%2Fcdk-github)](https://constructs.dev/packages/@pepperize/cdk-github)



  <details><summary><strong>TypeScript</strong></summary>

  ```shell
  npm install @pepperize/cdk-github
  ```

  or

  ```shell
  yarn add @pepperize/cdk-github
  ```

  </details><details><summary><strong>Python</strong></summary>

  ```shell
  pip install pepperize.cdk-github
  ```

  </details><details><summary><strong>C#</strong></summary>

  ```
  dotnet add package Pepperize.CDK.Github
  ```

  </details><details><summary><strong>Java</strong></summary>

  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-github</artifactId>
    <version>${cdkGithub.version}</version>
  </dependency>
  ```

  </details>



  Contributions of all kinds are welcome :rocket: Check out our [contributor's guide](https://github.com/pepperize/cdk-github/blob/main/CONTRIBUTING.md).

  For a quick start, [fork and check out](https://github.com/pepperize/cdk-github/fork) a development environment:

  ```shell
  git clone git@github.com:pepperize/cdk-github
  cd cdk-github

  yarn

  yarn build
  ```



  1. [Creating a GitHub App](https://docs.github.com/en/developers/apps/building-github-apps/creating-a-github-app)
  2. [Installing GitHub Apps](https://docs.github.com/en/developers/apps/managing-github-apps/installing-github-apps)
  3. [Create an AWS Secrets Manager secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html)

     ```json
     {
       "appId": "123456",
       "privateKey": "-----BEGIN RSA PRIVATE KEY-----\nExample==\n-----END RSA PRIVATE KEY-----",
       "installationId": "12345678"
     }
     ```
  4. Add [@pepperize/cdk-github](https://github.com/pepperize/cdk-github) to your project dependencies

     ```shell
     yarn add @pepperize/cdk-github
     ```
  5. Add your `main.ts`

     ```python
     const app = new App();
     const stack = new Stack(app, "GithubCustomResources");
     ```

     > Just for simplicity, it's up to you how to organize your app :wink:
  6. Import your secret

     ```python
     const secret = secrets_manager.Secret.fromSecretNameV2(stack, "Auth", "cdk-github/github-token");
     ```
  7. Configure GitHub App authenticate as an installation

     ```python
     const authOptions = AuthOptions.appAuth(secret);
     ```
  8. Add your first GitHub Custom Resource with the AWS CDK

     ```python
     new GithubCustomResource(stack, "GithubRepo", {
       onCreate: {
         // 👇The endpoint of the GitHub API.
         endpoint: "repos",
         // 👇The method of the GitHub API.
         method: "createInOrg",
         // https://octokit.github.io/rest.js/v19/#repos-create-in-org
         parameters: {
           // 👇The request parameters to send.
           org: "pepperize",
           name: "cdk-github",
         },
         // 👇The object keys from the GitHub API response to return to CFN.
         outputPaths: ["id", "full_name"],
         // 👇This becomes the CFN Physical ID visible in the Console.
         physicalResourceId: custom_resources.PhysicalResourceId.fromResponse("full_name"),
         // 👇Don't throw an error if message matching this regex.
         ignoreErrorCodesMatching: "name already exists on this account",
       },
       // 👇The implemented authentication strategy.
       authOptions: AuthOptions.appAuth(secret),
     });
     ```
  9. Deploy your first GitHub Custom Resource

     ```shell
     npx cdk deploy
     ```





  Configure the AWS SecretsManager Secret with the AuthOptions that will be passed to `octokit.auth`. i.e. as an installation:

  ```json
  {
    "appId": "123456",
    "privateKey": "-----BEGIN RSA PRIVATE KEY-----\nExample==\n-----END RSA PRIVATE KEY-----",
    "installationId": "12345678"
  }
  ```

  Lookup the secret in your AWS CDK app:

  ```python
  // 👇Lookup your secret containing the AuthOptions
  const secret = secrets_manager.Secret.fromSecretNameV2(stack, "Auth", "cdk-github/github-token");
  // 👇This will send the secret arn to the custom resource handler
  const authOptions = AuthOptions.appAuth(secret);
  ```

  The custom resource handler will configure [octokit.js](https://github.com/octokit/octokit.js) with the `createAppAuth`:

  ```python
  const getSecretValueResponse = await SSM.getSecretValue({ SecretId: secret }).promise();
  const octokitOptions: OctokitOptions = {
    authStrategy: createAppAuth,
    auth: (auth = JSON.parse(getSecretValueResponse.SecretString)),
  };
  ```

  > Supported through [@octokit/auth-app](https://github.com/octokit/auth-app.js#readme)



  Just add your PAT to an SSM StringParameter

  ```python
  // 👇Lookup your parameter containing the TOKEN
  const parameter = ssm.StringParameter.fromStringParameterName(stack, "Auth", "cdk-github/github-token");
  // 👇This will send the parameter arn to the custom resource handler
  const authOptions = AuthOptions.tokenAuth(parameter);
  ```

  > Supported through [@octokit/auth-token](https://github.com/octokit/auth-token.js)



  ```python
  // 👇This will configure octokit without authentication
  const authOptions = AuthOptions.unauthenticated();
  ```



  [![Manage a GitHub Repository as custom CFN resource](https://raw.githubusercontent.com/pepperize/cdk-github/main/cloudformation-stack-github-custom-resource.png)](https://github.com/pepperize/cdk-github/blob/main/src/integ.default.ts)

  [@octokit/plugin-rest-endpoint-methods](https://github.com/octokit/plugin-rest-endpoint-methods.js/#usage)

  ```python
  const auth = secrets_manager.Secret.fromSecretNameV2(stack, "Auth", "cdk-github/github-token");

  const repo = new GithubCustomResource(stack, "GithubRepo", {
    onCreate: {
      // https://octokit.github.io/rest.js/v19/#repos-create-in-org
      endpoint: "repos",
      method: "createInOrg",
      parameters: {
        org: "pepperize",
        name: "cdk-github",
      },
      outputPaths: ["id", "full_name"],
      physicalResourceId: custom_resources.PhysicalResourceId.fromResponse("full_name"),
      ignoreErrorCodesMatching: "name already exists on this account",
    },
    onUpdate: {
      // https://octokit.github.io/rest.js/v19#repos-get
      endpoint: "repos",
      method: "get",
      parameters: {
        owner: "pepperize",
        repo: "cdk-github",
      },
      outputPaths: ["id", "full_name"],
      physicalResourceId: custom_resources.PhysicalResourceId.fromResponse("full_name"),
    },
    onDelete: {
      // https://octokit.github.io/rest.js/v19#repos-delete
      endpoint: "repos",
      method: "delete",
      parameters: {
        owner: "pepperize",
        repo: "cdk-github",
      },
      outputPaths: [],
    },
    authOptions: AuthOptions.appAuth(auth),
  });

  // 👇 This will return the created repository id as a CDK Token
  repo.getAtt("id");
  ```





  Manages an environment secret. Will fetch the source AWS SecretsManager secret and encrypt it to store in GitHub.

  ```python
  // 👇The GitHub API authentication secret
  const auth = secrets_manager.Secret.fromSecretNameV2(scope, "Auth", "cdk-github/github-token");

  // 👇The AWS SecretsManager Secret to configure as GitHub Action secret.
  const secret = secrets_manager.Secret.fromSecretNameV2(scope, "Secret", "any-secret/example");

  new GithubActionsSecretEnvironment(scope, "GithubRepo", {
    // 👇The repository id, which you may lookup from the page source or via a custom resource
    repositoryId: "558989134",
    environmentName: "production",
    // 👇The name of the created GitHub secret
    secretName: "example",
    // 👇The source AWS SecretsManager secret and JSON field to use
    source: GithubActionsSecret.fromSecretsManager(secret, "some-json-field"),
    authOptions: AuthOptions.appAuth(auth),
    // 👇Whether to delete or retain the GitHub secret on resource removal
    removalPolicy: RemovalPolicy.DESTROY,
  });
  ```

  > You may retrieve the `repository_id` from the GitHub Repository page source's meta tag i.e. `<meta name="octolytics-dimension-repository_id" content="558989134">` or from another `GithubCustomResource` via `getAtt()`.

  See [GitHub Developer Guide](https://docs.github.com/de/rest/actions/secrets#create-or-update-an-environment-secret), [API Reference](https://github.com/pepperize/cdk-github/blob/main/API.md)



  Manage an GitHib Actions organization secret. Will fetch the source AWS SecretsManager secret and encrypt it to store in GitHub.

  ```python
  // 👇The GitHub API authentication secret
  const auth = secrets_manager.Secret.fromSecretNameV2(scope, "Auth", "cdk-github/github-token");

  // 👇The AWS SecretsManager Secret to configure as GitHub Action secret.
  const secret = secrets_manager.Secret.fromSecretNameV2(scope, "Secret", "any-secret/example");

  new GithubActionsSecretOrganization(scope, "GithubRepo", {
    organizationName: "pepperize",
    // 👇The name of the created GitHub secret
    secretName: "example",
    // 👇The source AWS SecretsManager secret and JSON field to use
    source: GithubActionsSecret.fromSecretsManager(secret, "some-json-field"),
    visibility: Visibility.ALL,
    authOptions: AuthOptions.appAuth(auth),
    // 👇Whether to delete or retain the GitHub secret on resource removal
    removalPolicy: RemovalPolicy.DESTROY,
  });
  ```

  See [GitHub Developer Guide](https://docs.github.com/de/rest/actions/secrets#create-or-update-an-organization-secret), [API Reference](https://github.com/pepperize/cdk-github/blob/main/API.md)



  Manage an GitHib Actions Repository secret. Will fetch the source AWS SecretsManager secret and encrypt it to store in GitHub.

  ```python
  // 👇The GitHub API authentication secret
  const auth = secrets_manager.Secret.fromSecretNameV2(scope, "Auth", "cdk-github/github-token");

  // 👇The AWS SecretsManager Secret to configure as GitHub Action secret.
  const secret = secrets_manager.Secret.fromSecretNameV2(scope, "Secret", "any-secret/example");

  new GithubActionsSecretRepository(scope, "GithubRepo", {
    owner: "pepperize",
    repositoryName: "cdk-github",
    // 👇The name of the created GitHub secret
    secretName: "example",
    // 👇The source AWS SecretsManager secret and JSON field to use
    source: GithubActionsSecret.fromSecretsManager(secret, "some-json-field"),
    authOptions: AuthOptions.appAuth(auth),
    // 👇Whether to delete or retain the GitHub secret on resource removal
    removalPolicy: RemovalPolicy.DESTROY,
  });
  ```

  See [GitHub Developer Guide](https://docs.github.com/de/rest/actions/secrets#create-or-update-a-repository-secret), [API Reference](https://github.com/pepperize/cdk-github/blob/main/API.md)


pkgId: d5eb1602002e8dffddd2c1ab8636a8a6ae2cc136dc7a47bf2572f67cb6118286
name: python-pepperize.cdk-organizations-help
arch: noarch
version: 0.7.969
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-organizations
url: https://github.com/pepperize/cdk-organizations.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-organizations-0.7.969-1.src.rpm
location_href: Packages/python-pepperize.cdk-organizations-help-0.7.969-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-organizations?style=flat-square)](https://github.com/pepperize/cdk-organizations/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-organizations?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-organizations)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-organizations?style=flat-square)](https://pypi.org/project/pepperize.cdk-organizations/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.Organizations?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.Organizations/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-organizations?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-organizations/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-organizations/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-organizations/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-organizations?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-organizations/releases)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/pepperize/cdk-organizations)



  Manage AWS organizations, organizational units (OU), accounts and service control policies (SCP).

  Features:

  * [Organization](https://github.com/pepperize/cdk-organizations#organization)
  * [Organizational Unit (OU)](https://github.com/pepperize/cdk-organizations#organizational-unit-ou)
  * [Account](https://github.com/pepperize/cdk-organizations#account)
  * [Delegated Administrator](https://github.com/pepperize/cdk-organizations#delegated-administrator)
  * [Trusted Service](https://github.com/pepperize/cdk-organizations#enable-an-aws-service-trusted-service)
  * [Policies](https://github.com/pepperize/cdk-organizations#policy), [PolicyTypes](https://github.com/pepperize/cdk-organizations#enable-a-policy-type), [PolicyAttachment](https://github.com/pepperize/cdk-organizations#policyattachment)
  * [Tagging](https://github.com/pepperize/cdk-organizations#tagging-resources)

  [![View on Construct Hub](https://constructs.dev/badge?package=%40pepperize%2Fcdk-organizations)](https://constructs.dev/packages/@pepperize/cdk-organizations)





  ```shell
  npm install @pepperize/cdk-organizations
  ```

  or

  ```shell
  yarn add @pepperize/cdk-organizations
  ```



  ```shell
  pip install pepperize.cdk-organizations
  ```



  ```
  dotnet add package Pepperize.CDK.Organizations
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-organizations</artifactId>
    <version>${cdkOrganizations.version}</version>
  </dependency>
  ```



  Contributions of all kinds are welcome :rocket: Check out our [contributor's guide](https://github.com/pepperize/cdk-organizations/blob/main/CONTRIBUTING.md).

  For a quick start, [check out](https://github.com/pepperize/cdk-organizations/fork) a development environment:

  ```shell
  git clone git@github.com:pepperize/cdk-organizations
  cd cdk-organizations

  yarn

  yarn build
  ```



  1. Create a new account

     [Signup for AWS](https://portal.aws.amazon.com/billing/signup#/start)
  2. Prepare an IAM User with `AdministratorAccess`

     To deploy your new organization, you have to create an Administrator with an AccessKey

     * [Creating your first IAM admin user and user group](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html)
     * [Managing access keys for IAM users](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey)
  3. Create a new CDK TypeScript App project with [projen](https://github.com/projen/projen)

     ```shell
     mkdir my-project
     cd my-project
     git init -b main
     npx projen new awscdk-app-ts
     ```
  4. Add `@pepperize/cdk-organizations` to your dependencies in `.projenrc.js`

     ```python
     const project = new awscdk.AwsCdkTypeScriptApp({
       //...
       deps: ["@pepperize/cdk-organizations"],
     });
     ```
  5. Install the dependency

     ```shell
     npx projen
     ```
  6. Create a stack

     ```python
     import { Account, Organization, OrganizationalUnit } from "@pepperize/cdk-organizations";
     import { Stack } from "aws-cdk-lib";

     export class OrganizationStack extends Stack {
       constructor(scope: Construct, id: string, props: StackProps = {}) {
         super(scope, id, props);

         // Create your organization
         const organization = new Organization(stack, "Organization", {});

         // Create an organizational unit (OU)
         const organizationUnit = new OrganizationalUnit(stack, "OrganizationalUnit", {
           organizationalUnitName: "MyFirstOU",
           parent: organization.root,
         });

         // Create an account
         const account = new Account(stack, "Account", {
           accountName: "MyFirstAccount",
           email: "<your email for the member account>",
           parent: organizationUnit,
         });
       }
     }
     ```
  7. Configure your AWS CLI to deploy

     * [Configuring the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)
     * [AWSume](https://awsu.me/)

     The easiest is to export your access key

     ```shell
     export AWS_ACCESS_KEY_ID=<your created access key id>
     export AWS_SECRET_ACCESS_KEY=<your created secret access key>
     ```
  8. Deploy your first AWS organization

     ```shell
     export CDK_DEFAULT_REGION=<your AWS region>
     export CDK_DEFAULT_ACCOUNT=<your AWS account id>
     ```

     ```shell
     yarn deploy
     ```





  To create a new organization or import an existing organization, add the following construct to your stack:

  ```python
  const organization = new Organization(stack, "Organization", {
    featureSet: FeatureSet.ALL, // (default) required later on to enable SCPs, enable AWS services or delegate an administrator account
  });
  organization.root; // The organization's root is automatically created
  ```

  * `FeatureSet.ALL` is required for advanced features like Service Control Policies (SCP) and is the [preferred way to work with AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_support-all-features.html)
  * The account which deploys the stack, will automatically become the management account of the new organization.
  * If an organization already exists, it will be imported automatically. You can disable this behaviour by passing `importOnDuplicate: false` in the props.
  * If the construct is removed from the stack, the organization will remain and must be deleted manually. For deletion of an organization you must previously remove all the member accounts, OUs, and policies from the organization. [Deleting the organization by removing the management account](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_org_delete.html)
  * An organization root is automatically created for you when you create the new organization.

  See [IOrganization](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.IOrganization)



  To retrieve the AWS IAM organization principal in a member account, add the following to any construct:

  ```
  const organization = Organization.of(scope, "Organization");
  organization.principal; // The AWS IAM organization principal
  ```

  * This helper construct can be used in any member account in the organization.

  See [AWS Organization API Reference - DescribeOrganization](https://docs.aws.amazon.com/organizations/latest/APIReference/API_DescribeOrganization.html)



  To create a new organizational unit (OU), add the following construct to your stack:

  ```python
  const organizationUnit = new OrganizationalUnit(stack, "Organization", {
    organizationalUnitName: "Project2",
    parent: organization.root,
  });
  ```

  * The parent of an organizational unit (OU) can be either the organization's root or another OU within the organization.
  * An organizational unit (OU) can't be moved. You have to create a new OU first, move all the accounts and then delete the old OU.
  * For deletion of an organizational unit (OU) you must first move all accounts out of the OU and any child OUs, and then you can delete the child OUs. [Deleting an organizational unit](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_ous.html#delete-ou)

  See [IOrganizationalUnit](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.IOrganizationalUnit)



  * `importOnDuplicate` If an organizational unit (OU) with the name exists in the parent, it will be imported.
  * `removalPolicy` Default `RemovalPolicy.Retain` If you set `removalPolicy` to `RemovalPolicy.destroy`, the organizational unit (OU) will be deleted on Cloudformation delete event.

  See [OrganizationalUnitProps](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.OrganizationalUnitProps)



  To create a new account, add the following construct to your stack:

  ```python
  new Account(stack, "Account", {
    accountName: "MyAccount",
    email: "info@pepperize.com",
    parent: organization.root,
  });
  ```

  * The email address must not already be associated with another AWS account. You may suffix the email address, i.e. `info+account-123456789012@pepperize.com`.
  * The AWS Organizations supports only a one account creation `IN_PROGRESS`. Ensure account creation by using `account2.node.addDependency(account1)` [dependency relationship](https://docs.aws.amazon.com/cdk/api/v1/docs/core-readme.html#dependencies).
  * An account will be created and moved to the parent, if the parent is an organizational unit (OU).
  * An account can only be created from within the management account.

  See [IAccount](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.IAccount)



  * `importOnDuplicate` If an account with the same email address exists in the organization, it will be imported.
  * `removalPolicy` Default `RemovalPolicy.Retain` If you set `removalPolicy` to `RemovalPolicy.destroy`, the account will be closed. [Closing an AWS account](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_accounts_close.html)
  * `iamUserAccessToBilling` Default `IamUserAccessToBilling.ALLOW` If you set `iamUserAccessToBilling` to `ALLOW`, IAM users and roles that have appropriate permissions can view billing information for the account.
  * `roleName` Default `OrganizationAccountAccessRole` is preconfigures in the newly created account and grants users in the management account administrator permissions in the new member account.

  See [AccountProps](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.AccountProps)



  A compatible AWS service (trusted service) can register an AWS member account in the organization as an administrator in the organization on your behalf. To enable an AWS account as administrator of that trusted in your organization call `delegateAdministrator` on your account:

  ```python
  const account = new Account(stack, "Account", {
    accountName: "StackSetsDelegatedAdministrator",
    email: "info@pepperize.com",
  });
  account.delegateAdministrator("stacksets.amazonaws.com");
  ```

  * [AWS services that support Delegated Administrator](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services_list.html)
  * To be able to use Delegated Administrator, your organization must have [all features](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.FeatureSet) enabled.

  See [DelegatedAdministrator](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.DelegatedAdministrator)



  To enable trusted access for a supported AWS service (trusted service), which performs tasks in your organization and its accounts on your behalf, call `enableAwsService` on your organization:

  ```python
  const organization = new Organization(stack, "Organization", {
    featureSet: FeatureSet.ALL, // (default) the organization must be created with all features enabled
  });
  organization.enableAwsServiceAccess("ssm.amazonaws.com");
  ```

  * To enable trusted access, you must have [all features](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.FeatureSet) enabled.
  * It's recommended to use only the trusted service's console [How to enable or disable trusted access](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services.html#orgs_how-to-enable-disable-trusted-access)
  * [AWS services that you can use with AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_integrate_services_list.html)

  See [EnableAwsServiceAccess](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.EnableAwsServiceAccess)



  To enable a policy type call `enablePolicyType` on your organization.

  ```python
  const organization = new Organization(stack, "Organization", {
    featureSet: FeatureSet.ALL, // (default) the organization must be created with all features enabled
  });
  organization.enablePolicyType(PolicyType.SERVICE_CONTROL_POLICY);
  organization.enablePolicyType(PolicyType.TAG_POLICY);
  organization.enablePolicyType(PolicyType.BACKUP_POLICY);
  organization.enablePolicyType(PolicyType.AISERVICES_OPT_OUT_POLICY);
  ```

  * To create or attach policies later on, you have to [enable all features](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.FeatureSet) and the [policy type](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html#orgs-policy-types) .

  See [EnablePolicyType](https://github.com/pepperize/cdk-organizations/blob/main/API.md#enablepolicytype-), [PolicyType](https://github.com/pepperize/cdk-organizations/blob/main/API.md#policytype-).



  To create a new policy add the following construct to your stack:

  ```python
  new Policy(stack, "Policy", {
    content: '{\n"Version":"2012-10-17","Statement":{\n"Effect":"Allow","Action":"s3:*"\n}\n}',
    description: "Enables admins of attached accounts to delegate all S3 permissions",
    policyName: "AllowAllS3Actions",
    policyType: PolicyType.SERVICE_CONTROL_POLICY,
  });
  ```

  * To create or attach policies, you must have [all features](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.FeatureSet) and the [policy type](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html#orgs-policy-types) enabled.
  * The [SCP Syntax](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps_syntax.html) is quite similar to IAM policies, but way more limited.

  See [Policy](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.Policy)



  To attach a policy to a root, an organizational unit (OU), or an individual account call `attachPolicy` with the policy to attach:

  ```python
  organization.enablePolicyType(PolicyType.TAG_POLICY);

  const policy = new Policy(stack, "Policy", {
    content: '{\n"tags":{\n"CostCenter":{\n"tag_key":{\n"@@assign":"CostCenter"\n}\n}\n}\n}',
    description: "Defines the CostCenter tag key",
    policyName: "CostCenterTag",
    policyType: PolicyType.TAG_POLICY,
  });

  organization.attachPolicy(policy);
  organizationalUnit.attachPolicy(policy);
  account.attachPolicy(policy);
  ```

  * To create or attach policies, you must have [all features](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.FeatureSet) and the [policy type](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies.html#orgs-policy-types) enabled.



  To tag a resource you may follow the [AWS CDK Developer Guide - Tagging](https://docs.aws.amazon.com/cdk/v2/guide/tagging.html):

  You can add one or more tags to the following resources in AWS Organizations.

  * Account
  * Organization root
  * Organizational unit (OU)
  * Policy

  See [Tagging AWS Organizations resources](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_tagging.html), [ITaggableResource](https://github.com/pepperize/cdk-organizations/blob/main/API.md#@pepperize/cdk-organizations.ITaggableResource)



  ```python
  import { Tags } from "aws-cdk-lib";

  const organization = new Organization();
  Tags.of(organization.root).add("key", "value");
  ```



  ```python
  import { Tags } from "aws-cdk-lib";

  const organizationalUnit = new OrganizationalUnit();
  Tags.of(organizationalUnit).add("key", "value");
  ```



  ```python
  import { Tags } from "aws-cdk-lib";

  const account = new Account();
  Tags.of(account).add("key", "value");
  ```



  ```python
  import { Tags } from "aws-cdk-lib";

  const policy = new Policy();
  Tags.of(policy).add("key", "value");
  ```



  AWS Organizations has some limitations:

  * The stack's account must be the management account of an existing organization.
  * The stack's account becomes the management account of the new organization.
  * An account belongs to only one organization within a single root.
  * [Quotas for AWS Organizations](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_reference_limits.html)

  > AWS Organizations is a global service with service endpoints in `us-east-1`, `us-gov-west-1` and `cn-northwest-1`. Read also
  > [Endpoint to call When using the AWS CLI or the AWS SDK](https://docs.aws.amazon.com/organizations/latest/APIReference/Welcome.html).
  > Currently all custom resources of this library defaults to use `us-east-1`, but it can be configured to use `cn-northwest-1`
  > with the environment variable `CDK_AWS_PARTITION` set to `aws-cn`.



  See [example](https://github.com/pepperize/cdk-organizations-example/blob/main/src/example-stack.ts)

  ```python
  import { App, Stack } from "aws-cdk-lib/core";
  import {
    Account,
    DelegatedAdministrator,
    EnableAwsServiceAccess,
    EnablePolicyType,
    FeatureSet,
    IamUserAccessToBilling,
    Organization,
    OrganizationalUnit,
    Policy,
    PolicyAttachment,
    PolicyType,
  } from "@pepperize/cdk-organizations";

  const app = new App();
  const stack = new Stack(app);

  // Create an organization
  const organization = new Organization(stack, "Organization", {
    featureSet: FeatureSet.ALL,
  });
  // Enable AWS Service Access (requires FeatureSet: ALL)
  organization.enableAwsServiceAccess("service-abbreviation.amazonaws.com");

  // Create an account
  const account1 = new Account(stack, "SharedAccount", {
    accountName: "SharedAccount",
    email: "info+shared-account@pepperize.com",
    roleName: "OrganizationAccountAccessRole",
    iamUserAccessToBilling: IamUserAccessToBilling.ALLOW,
    parent: organization.root,
  });
  // Enable a delegated admin account
  account1.delegateAdministrator("service-abbreviation.amazonaws.com");

  // Create an OU in the current organizations root
  const projects = new OrganizationalUnit(stack, "ProjectsOU", {
    organizationalUnitName: "Projects",
    parent: organization.root,
  });
  const account2 = new Account(stack, "Project1Account", {
    accountName: "SharedAccount",
    email: "info+project1@pepperize.com",
    parent: projects,
  });
  account2.node.addDependency(account1);

  // Create a nested OU and attach two accounts
  const project2 = new OrganizationalUnit(stack, "Project2OU", {
    organizationalUnitName: "Project2",
    parent: projects,
  });
  const account3 = new Account(stack, "Project2DevAccount", {
    accountName: "Project 2 Dev",
    email: "info+project2-dev@pepperize.com",
    parent: project2,
  });
  account3.node.addDependency(account2);
  const account4 = new Account(stack, "Project2ProdAccount", {
    accountName: "Project 2 Prod",
    email: "info+project2-prod@pepperize.com",
    parent: project2,
  });
  account4.node.addDependency(account3);

  // Enable the service control policy (SCP) type within the organization
  organization.enablePolicyType(PolicyType.SERVICE_CONTROL_POLICY);
  // Create and attach and Service Control Policy (SCP)
  const policy = new Policy(stack, "Policy", {
    content: '{\n"Version":"2012-10-17","Statement":{\n"Effect":"Allow","Action":"s3:*"\n}\n}',
    description: "Enables admins of attached accounts to delegate all S3 permissions",
    policyName: "AllowAllS3Actions",
    policyType: PolicyType.SERVICE_CONTROL_POLICY,
  });
  organization.attachPolicy(policy);

  // Tagging AWS organization resources of this stack
  Tags.of(stack).add("tagKey", "tagValue");
  ```



  * [CDK Organizations API Reference](https://github.com/pepperize/cdk-organizations/blob/main/API.md)
  * [AWS Account Management Reference Guide](https://docs.aws.amazon.com/accounts/latest/reference/accounts-welcome.html)
  * [AWS Organizations User Guide](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html)
  * [AWS API Reference](https://docs.aws.amazon.com/organizations/latest/APIReference/Welcome.html)
  * [AWS CDK Custom Resources](https://docs.aws.amazon.com/cdk/api/v1/docs/custom-resources-readme.html#custom-resources-for-aws-apis)



  * [AWS Bootstrap Kit](https://github.com/awslabs/aws-bootstrap-kit)
  * [Terraform AWS Provider](https://registry.terraform.io/providers/hashicorp/aws/latest)
  * [AWS Deployment Framework (ADF)](https://github.com/awslabs/aws-deployment-framework)
  * [AWS Organization Formation](https://github.com/org-formation)
  * [AWS Control Tower Account Factory for Terraform (ATF)](https://github.com/aws-ia/terraform-aws-control_tower_account_factory)


pkgId: 2bc1452da3a497777783fbe78ef59444083dc3018383d6aec20cd1722f95d454
name: python-pepperize.cdk-private-bucket-help
arch: noarch
version: 0.0.517
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-private-bucket
url: https://github.com/pepperize/cdk-private-bucket.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-private-bucket-0.0.517-1.src.rpm
location_href: Packages/python-pepperize.cdk-private-bucket-help-0.0.517-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-private-bucket?style=flat-square)](https://github.com/pepperize/cdk-private-bucket/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-private-bucket?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-private-bucket)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-private-bucket?style=flat-square)](https://pypi.org/project/pepperize.cdk-private-bucket/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.PrivateBucket?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.PrivateBucket/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-private-bucket?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-private-bucket/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-private-bucket/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-private-bucket/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-private-bucket?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-private-bucket/releases)



  This project provides a CDK construct to create an S3 Bucket with some security pre-sets. It uses usual [s3.BucketProps](https://docs.aws.amazon.com/cdk/api/v1/docs/@aws-cdk_aws-s3.BucketProps.html) and overrides these key-value pairs:

  ```python
  {
    blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
    enforceSSL: true,
    encryption: s3.BucketEncryption.S3_MANAGED,
  }
  ```

  The result is a privacy-oriented S3 Bucket.





  ```shell
  npm install @pepperize/cdk-private-bucket
  ```

  or

  ```shell
  yarn add @pepperize/cdk-private-bucket
  ```



  ```shell
  pip install pepperize.cdk-private-bucket
  ```



  ```
  dotnet add package Pepperize.CDK.PrivateBucket
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-private-bucket</artifactId>
    <version>${cdkPrivateBucket.version}</version>
  </dependency>
  ```



  ```shell
  npm install @pepperize/cdk-private-bucket
  ```

  See [API.md](https://github.com/pepperize/cdk-private-bucket/blob/main/API.md).

  ```python
  import { PrivateBucket } from "@pepperize/cdk-private-bucket";

  const bucket = new PrivateBucket(this, "PrivateBucket", {});
  ```


pkgId: e3172a6fe3dddb47d5692548efa9dac5e689ea8bd6b4a83894d496d7d955cfcc
name: python-pepperize.cdk-route53-health-check-help
arch: noarch
version: 0.0.636
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-route53-health-check
url: https://github.com/pepperize/cdk-route53-health-check.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-route53-health-check-0.0.636-1.src.rpm
location_href: Packages/python-pepperize.cdk-route53-health-check-help-0.0.636-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-route53-health-check?style=flat-square)](https://github.com/pepperize/cdk-route53-health-check/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-route53-health-check?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-route53-health-check)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-route53-health-check?style=flat-square)](https://pypi.org/project/pepperize.cdk-route53-health-check/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.Route53HealthCheck?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.Route53HealthCheck/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-route53-health-check?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-route53-health-check/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-route53-health-check/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-route53-health-check/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-route53-health-check?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-route53-health-check/releases)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/pepperize/cdk-route53-health-check)



  Create Route53 HealthChecks to monitor TCP, HTTP, HTTPS endpoints, to monitor CloudWatch Alarms and to monitor other Route53 HealthChecks.

  Currently supported types of Route53 HealthChecks:

  * [Health checks that monitor an endpoint](https://github.com/pepperize/cdk-route53-health-check#healthcheck-for-an-endpoint)
  * [Health checks that monitor other health checks](https://github.com/pepperize/cdk-route53-health-check#healthcheck-to-monitor-cloudwatch-alarms)
  * [Health checks that monitor CloudWatch alarms](https://github.com/pepperize/cdk-route53-health-check#healthcheck-to-monitor-other-healthchecks)
  * [Configure DNS failover](https://github.com/pepperize/cdk-route53-health-check#configuring-dns-failover)

  Easily create a CloudWatch Alarm based on the Route53 HealthCheck:

  ```python
  const healthCheck = new EndpointHealthCheck(scope, "HealthCheck", {
    domainName: "pepperize.com",
  });

  const alarm = new cloudwatch.Alarm(scope, "Alarm", {
    metric: healthCheck.metricHealthCheckStatus(),
    comparisonOperator: cloudwatch.ComparisonOperator.LESS_THAN_THRESHOLD,
    threshold: 1,
    evaluationPeriods: 1,
  });
  ```

  See more options [API Reference](https://github.com/pepperize/cdk-route53-health-check/blob/main/API.md#@pepperize/cdk-route53-health-check.EndpointHealthCheckProps)





  ```shell
  npm install @pepperize/cdk-route53-health-check
  ```

  or

  ```shell
  yarn add @pepperize/cdk-route53-health-check
  ```



  ```shell
  pip install pepperize.cdk-route53-health-check
  ```



  ```
  dotnet add package Pepperize.CDK.Route53HealthCheck
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-route53-health-check</artifactId>
    <version>${cdkRoute53HealthCheck.version}</version>
  </dependency>
  ```



  ```shell
  npm install @pepperize/cdk-route53-health-check
  ```

  See [API.md](https://github.com/pepperize/cdk-route53-health-check/blob/main/API.md).



  **HTTPS health check**

  ```python
  new EndpointHealthCheck(scope, "HealthCheck", {
    domainName: "pepperize.com",
  });
  ```

  Generates

  ```yaml
  Resources:
    Type: AWS::Route53::HealthCheck
    Properties:
      HealthCheckConfig:
        FullyQualifiedDomainName: "pepperize.com"
        Port: 443
        Type: "HTTPS"
        EnableSNI: true
  ```

  **Additional configuration options**

  ```python
  new EndpointHealthCheck(scope, "HealthCheck", {
    domainName: "pepperize.com", // The domain name that Route53 performs health checks on. Route53 resolves the IP address and performs the lookup.
    enableSni: true, // Specify that Route53 sends the host name for TLS negotiation.
    failureThreshold: 3, // The number of consecutive health checks that an endpoint must pass or fail for Route53 to change the current status of the endpoint between healthy and unhealthy.
    healthCheckName: "pepperize.com", //	The display name of this Route53 HealthCheck.
    inverted: false, // Whether to invert the status of the Route53 health check status.
    ipAddress: "1.1.1.1", // The ip address that Route53 performs health checks on. Optionally a domain name may be given.
    latencyGraphs: true, // Whether Route53 measures the latency between health checkers in multiple AWS regions and your endpoint, and displays a CloudWatch latency graphs in the Route53 console.
    port: 443, // The port that Route53 performs health checks.
    protocol: Protocol.HTTPS, // The protocol that Route53 uses to communicate with the endpoint.
    regions: [HealthCheckerRegions.EU_WEST_1, HealthCheckerRegions.US_EAST_1, HealthCheckerRegions.US_WEST_1], // The list of regions from which Route53 health checkers check the endpoint.
    requestInterval: 30, // The number of seconds between the time that Route53 gets a response from your endpoint and the time that it sends the next health check request.
    resourcePath: "/health-check", // The path for HTTP or HTTPS health checks.
    searchString: "OK", // The search string for HTTP or HTTPS health checks.
  });
  ```

  See for more options [API Reference - EndpointHealthCheckProps](https://github.com/pepperize/cdk-route53-health-check/blob/main/API.md#endpointhealthcheckprops-)



  ```python
  const healthCheck1 = new EndpointHealthCheck(stack, "HealthCheck1", {
    domainName: "pepperize.com",
  });
  const healthCheck2 = EndpointHealthCheck.fromHealthCheckId(
    scope,
    "HealthCheck2",
    "9ebee2db-6292-4803-9838-327e6example"
  );
  new CalculatedHealthCheck(scope, "CalculatedHealthCheck", {
    childHealthChecks: [healthCheck1, healthCheck2],
  });
  ```

  See for more options [API Reference - CalculatedHealthCheckProps](https://github.com/pepperize/cdk-route53-health-check/blob/main/API.md#calculatedhealthcheckprops-)



  ```python
  const alarm = cloudwatch.Alarm.fromAlarmArn(
    scope,
    "Alarm",
    "arn:aws:cloudwatch:us-east-1:123456789012:alarm:any-alarm"
  );
  new AlarmHealthCheck(scope, "HealthCheck", {
    alarm: alarm,
  });
  ```

  See for more options [API Reference - AlarmHealthCheckProps](https://github.com/pepperize/cdk-route53-health-check/blob/main/API.md#alarmhealthcheckprops-)



  An example active-passive DNS failover configuration

  ![DNS failover](https://github.com/pepperize/cdk-route53-health-check/blob/main/diagram.png)

  **Primary**

  ```python
  // An alias record set for a CloudFront distribution
  const recordSetPrimary = new route53.ARecord(scope, "RecordSetPrimary", {
    recordName: "www.pepperize.com",
    zone: hostedZone,
    target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
  });
  // The health check for the CloudFront distribution
  const healthCheckPrimary = new EndpointHealthCheck(scope, "HealthCheckPrimary", {
    domainName: "www.pepperize.com",
  });
  // Configure the HealthCheckId and Failover on the record set
  healthCheckPrimary.failoverPrimary(recordSetPrimary);
  ```

  **Secondary**

  ```python
  // An alias record set for an Application Load Balancer
  const recordSetSecondary = new route53.ARecord(scope, "RecordSetSecondary", {
    recordName: "www-1.pepperize.com",
    zone: hostedZone,
    target: route53.RecordTarget.fromAlias(new targets.LoadBalancerTarget(alb)),
  });
  // The health check for the Application Load Balancer
  const healthCheckSecondary = new EndpointHealthCheck(scope, "HealthCheckSecondary", {
    domainName: "www-1.pepperize.com",
  });
  // Configure the HealthCheckId and Failover on the record set
  healthCheckSecondary.failoverSecondary(recordSetSecondary, true);
  ```

  See for more options [API Reference - IHealthCheck](https://github.com/pepperize/cdk-route53-health-check/blob/main/API.md#ihealthcheck-)

  [How health checks work in complex Amazon Route 53 configurations](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover-complex-configs.html)


pkgId: ceb1ddcde62f4a8aa5a552f039b208bb5e7d12a50ef5c5d691eaf42e9249060b
name: python-pepperize.cdk-security-group-help
arch: noarch
version: 0.0.569
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-security-group
url: https://github.com/pepperize/cdk-security-group.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-security-group-0.0.569-1.src.rpm
location_href: Packages/python-pepperize.cdk-security-group-help-0.0.569-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-security-group?style=flat-square)](https://github.com/pepperize/cdk-security-group/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-security-group?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-security-group)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-security-group?style=flat-square)](https://pypi.org/project/pepperize.cdk-security-group/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.SecurityGroup?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.SecurityGroup/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-security-group?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-security-group/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-security-group/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-security-group/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-security-group?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-security-group/releases)



  This project provides a CDK construct to create an EC2 SecurityGroup, which property `securityGroupName` returns the
  GroupName.

  > The [CDK EC2 SecurityGroup](https://docs.aws.amazon.com/cdk/api/v1/docs/@aws-cdk_aws-ec2.SecurityGroup.html)
  > returns the GroupId from the `Ref` return value of [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html),
  > rather than the GroupName.





  ```shell
  npm install @pepperize/cdk-security-group
  ```

  or

  ```shell
  yarn add @pepperize/cdk-security-group
  ```



  ```shell
  pip install pepperize.cdk-security-group
  ```



  ```
  dotnet add package Pepperize.CDK.SecurityGroup
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-security-group</artifactId>
    <version>${cdkSecurityGroup.version}</version>
  </dependency>
  ```



  ```shell
  npm install @pepperize/cdk-security-group
  ```

  See [API.md](https://github.com/pepperize/cdk-security-group/blob/main/API.md).

  ```python
  import { SecurityGroup } from "@pepperize/cdk-security-group";

  const securityGroup = new SecurityGroup(this, "SecurityGroup", {});

  // Pass to another construct
  new OtherConstruct(this, OtherConstruct, {
    SecurityGroupName: securityGroup.securityGroupName,
  });
  ```


pkgId: f6bcddee7fcd3867c18a91bfe9883b50a8090a85c456df1eae7c7e83e9e154fa
name: python-pepperize.cdk-ses-smtp-credentials-help
arch: noarch
version: 0.3.797
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-ses-smtp-credentials
url: https://github.com/pepperize/cdk-ses-smtp-credentials.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-ses-smtp-credentials-0.3.797-1.src.rpm
location_href: Packages/python-pepperize.cdk-ses-smtp-credentials-help-0.3.797-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-ses-smtp-credentials?style=flat-square)](https://github.com/pepperize/cdk-ses-smtp-credentials/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-ses-smtp-credentials?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-ses-smtp-credentials)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-ses-smtp-credentials?style=flat-square)](https://pypi.org/project/pepperize.cdk-ses-smtp-credentials/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.SesSmtpCredentials?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.SesSmtpCredentials/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-ses-smtp-credentials?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-ses-smtp-credentials/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-ses-smtp-credentials/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-ses-smtp-credentials/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-ses-smtp-credentials?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-ses-smtp-credentials/releases)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/pepperize/cdk-ses-smtp-credentials)



  Generate SES smtp credentials for a user and store the credentials in a SecretsManager Secret.

  [![View on Construct Hub](https://constructs.dev/badge?package=%40pepperize%2Fcdk-ses-smtp-credentials)](https://constructs.dev/packages/@pepperize/cdk-ses-smtp-credentials)





  ```shell
  npm install @pepperize/cdk-ses-smtp-credentials
  ```

  or

  ```shell
  yarn add @pepperize/cdk-ses-smtp-credentials
  ```



  ```shell
  pip install pepperize.cdk-ses-smtp-credentials
  ```



  ```
  dotnet add package Pepperize.CDK.SesSmtpCredentials
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-ses-smtp-credentials</artifactId>
    <version>${cdkSesSmtpCredentials.version}</version>
  </dependency>
  ```



  ```shell
  npm install @pepperize/cdk-ses-smtp-credentials
  ```

  See [API.md](https://github.com/pepperize/cdk-ses-smtp-credentials/blob/main/API.md).



  > Attaches an inline policy to the user allowing to send emails

  ```python
  import { User } from "@aws-cdk/aws-iam";
  import { SesSmtpCredentials } from "@pepperize/cdk-ses-smtp-credentials";

  const user = new User(stack, "SesUser", {
    userName: "ses-user",
  });
  const smtpCredentials = new SesSmtpCredentials(this, "SmtpCredentials", {
    user: user,
  });

  // smtpCredentials.secret contains json value {username: "<the generated access key id>", password: "<the calculated ses smtp password>"}
  ```

  See [API Reference - SesSmtpCredentials](https://github.com/pepperize/cdk-ses-smtp-credentials/blob/main/API.md#sessmtpcredentials-)



  > Attaches an inline policy to the user allowing to send emails

  ```python
  import { User } from "@aws-cdk/aws-iam";
  import { SesSmtpCredentials } from "@pepperize/cdk-ses-smtp-credentials";

  const smtpCredentials = new SesSmtpCredentials(this, "SmtpCredentials", {
    userName: "ses-user",
  });

  // smtpCredentials.secret contains json value {username: "<the generated access key id>", password: "<the calculated ses smtp password>"}
  ```

  See [API Reference - SesSmtpCredentials](https://github.com/pepperize/cdk-ses-smtp-credentials/blob/main/API.md#sessmtpcredentials-)



  ```python
  import * as AWS from "aws-sdk";
  import { calculateSesSmtpPassword } from "@pepperize/cdk-ses-smtp-credentials";

  const iam = new AWS.IAM();
  const accessKey = await iam
    .createAccessKey({
      UserName: username,
    })
    .promise();
  const accessKeyId = accessKey.AccessKey.AccessKeyId;
  const secretAccessKey = accessKey.AccessKey.SecretAccessKey;

  const password = calculateSesSmtpPassword(secretAccessKey, "us-east-1");

  console.log({
    username: accessKeyId,
    password: password,
  });
  ```

  See [Obtaining Amazon SES SMTP credentials by converting existing AWS credentials](https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html#smtp-credentials-convert)


pkgId: 0b02346483166bab778fc30b61e106bf5f9d934c525fb820ff916a08278a3bfe
name: python-pepperize.cdk-vpc-help
arch: noarch
version: 0.0.1081
epoch: 0
release: 1
summary: Development documents and examples for pepperize.cdk-vpc
url: https://github.com/pepperize/cdk-vpc.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.cdk-vpc-0.0.1081-1.src.rpm
location_href: Packages/python-pepperize.cdk-vpc-help-0.0.1081-1.noarch.rpm
checksum_type: sha256
description:
  [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
  [![GitHub](https://img.shields.io/github/license/pepperize/cdk-vpc?style=flat-square)](https://github.com/pepperize/cdk-vpc/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/cdk-vpc?style=flat-square)](https://www.npmjs.com/package/@pepperize/cdk-vpc)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.cdk-vpc?style=flat-square)](https://pypi.org/project/pepperize.cdk-vpc/)
  [![Nuget](https://img.shields.io/nuget/v/Pepperize.CDK.Vpc?style=flat-square)](https://www.nuget.org/packages/Pepperize.CDK.Vpc/)
  [![Sonatype Nexus (Releases)](https://img.shields.io/nexus/r/com.pepperize/cdk-vpc?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&style=flat-square)](https://s01.oss.sonatype.org/content/repositories/releases/com/pepperize/cdk-vpc/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/actions/workflow/status/pepperize/cdk-vpc/release.yml?branch=main&label=release&style=flat-square)](https://github.com/pepperize/cdk-vpc/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/cdk-vpc?sort=semver&style=flat-square)](https://github.com/pepperize/cdk-vpc/releases)
  [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod&style=flat-square)](https://gitpod.io/#https://github.com/pepperize/cdk-vpc)



  Utility constructs for tagging subnets or creating a cheaper vpc.

  * [Cheaper Vpc](#create-a-cheaper-vpc)
  * [Tagging subnets](#tag-your-imported-subnets)





  ```shell
  npm install @pepperize/cdk-vpc
  ```

  or

  ```shell
  yarn add @pepperize/cdk-vpc
  ```



  ```shell
  pip install pepperize.cdk-vpc
  ```



  ```shell
  dotnet add package Pepperize.CDK.Vpc
  ```



  ```xml
  <dependency>
    <groupId>com.pepperize</groupId>
    <artifactId>cdk-vpc</artifactId>
    <version>${cdkVpc.version}</version>
  </dependency>
  ```



  1. Create a new CDK TypeScript App project with [projen](https://github.com/projen/projen)

     ```shell
     mkdir my-project
     cd my-project
     git init -b main
     npx projen new awscdk-app-ts
     ```
  2. Add `@pepperize/cdk-vpc` to your dependencies in `.projenrc.js`

     ```python
     const project = new awscdk.AwsCdkTypeScriptApp({
       //...
       deps: ["@pepperize/cdk-vpc"],
     });
     ```
  3. Install the dependency

     ```shell
     npx projen
     ```





  Use this as a cheaper drop-in replacement to create a vpc with 2 AvailabilityZones and a `t3.nano` NatInstance.

  ```python
  import { App, Stack } from "aws-cdk-lib";
  import { CheapVpc } from "@pepperize/cdk-vpc";

  const app = new App();
  const stack = new Stack(app, "MyCheapVpcStack");

  new CheapVpc(stack, "MyCheapVpc");
  ```



  Subnets imported by `Vpc.fromLookup` wouldn't be tagged by `Tags.of` automatically. To tag them (or any other imported vpc resource) use:

  ```python
  import { CheapVpc } from "@pepperize/cdk-vpc";
  import * as ec2 from "aws-cdk-lib/aws-ec2";

  const app = new App();
  const stack = new Stack(app, "VpcStack");
  const vpc = ec2.Vpc.fromLookup(stack, "VpcLookup", {
    vpcId: "vpc-1234567890",
    region: env.region,
  });

  new CreateTags(vpcStack, "TagPrivateSubnets", {
    resourceIds: vpc.privateSubnets.map((subnet) => {
      return subnet.subnetId;
    }),
    tags: [
      {
        key: "kubernetes.io/role/internal-elb",
        value: "1",
      },
    ],
  });
  ```



  Contributions of all kinds are welcome :rocket: Check out our [contributor's guide](https://github.com/pepperize/cdk-vpc/blob/main/CONTRIBUTING.md).

  For a quick start, check out a development environment:

  ```shell
  git clone git@github.com:pepperize/cdk-vpc
  cd cdk-vpc
   
  yarn

  yarn build
  ```


pkgId: f4892be168fc0f4af78dc0bc20a8ab36f1775c5acc998a6e6d661bc021074c83
name: python-pepperize.projen-awscdk-construct-help
arch: noarch
version: 0.0.730
epoch: 0
release: 1
summary: Development documents and examples for pepperize.projen-awscdk-construct
url: https://github.com/pepperize/projen-awscdk-construct.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pepperize.projen-awscdk-construct-0.0.730-1.src.rpm
location_href: Packages/python-pepperize.projen-awscdk-construct-help-0.0.730-1.noarch.rpm
checksum_type: sha256
description:
  [![GitHub](https://img.shields.io/github/license/pepperize/projen-awscdk-construct?style=flat-square)](https://github.com/pepperize/projen-awscdk-construct/blob/main/LICENSE)
  [![npm (scoped)](https://img.shields.io/npm/v/@pepperize/projen-awscdk-construct?style=flat-square)](https://www.npmjs.com/package/@pepperize/projen-awscdk-construct)
  [![PyPI](https://img.shields.io/pypi/v/pepperize.projen-awscdk-construct?style=flat-square)](https://pypi.org/project/pepperize.projen-awscdk-construct/)
  [![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/pepperize/projen-awscdk-construct/release/main?label=release&style=flat-square)](https://github.com/pepperize/projen-awscdk-construct/actions/workflows/release.yml)
  [![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/pepperize/projen-awscdk-construct?sort=semver&style=flat-square)](https://github.com/pepperize/projen-awscdk-construct/releases)



  This project provides a projen project type providing presets for an AWS CDK construct library project.



  To create a new project, run the following command and follow the instructions:

  ```shell
  mkdir my-project
  cd my-project
  git init -b main
  npx projen new --from @pepperize/projen-awscdk-construct
  ```

  *If your git cli doesn't have a `-b` option, either update [git](https://git-scm.com/) or issue `git init && git checkout -b main`.*



  To init a new project from this module:

  ```shell
  npx projen new --from @pepperize/projen-awscdk-construct@latest
  ```

  *Note: it will install the `latest` version. If you don't specify the `latest` version, it won't be upgraded while running `yarn install`*



  1. Create a new project for the projen external jsii npm module

     ```shell
     mkdir my-project
     cd my-project
     git init -b main
     npx projen new jsii
     ```
  2. Your `src/index.ts` should export only one project.


pkgId: f05213abb1dcb765a71fb3c0f7544946cb4570e25037e309cd9cefbe650a0060
name: python-perin-parser-help
arch: noarch
version: 0.0.17
epoch: 0
release: 1
summary: Development documents and examples for perin-parser
url: https://github.com/ufal/perin
rpm_license: Mozilla Public License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-perin-parser-0.0.17-1.src.rpm
location_href: Packages/python-perin-parser-help-0.0.17-1.noarch.rpm
checksum_type: sha256
description:
  Unofficial package for the PERIN parser: https://github.com/ufal/perin

  Intended for easy installation and faster batching.



  ```bash
  pip install perin_parser
  ```




  ```
  Copyright 2020 Institute of Formal and Applied Linguistics, Faculty of
  Mathematics and Physics, Charles University, Czech Republic.

  This Source Code Form is subject to the terms of the Mozilla Public
  License, v. 2.0. If a copy of the MPL was not distributed with this
  file, You can obtain one at http://mozilla.org/MPL/2.0/.
  ```


pkgId: 6d55d71339fa3c4d96df2fe187f62629aeea47853e68e7b45f939f6c5177e39c
name: python-periodictable
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Extensible periodic table of the elements
url: https://pypi.org/project/periodictable/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-periodictable-2.0.2-1.src.rpm
location_href: Packages/python-periodictable-2.0.2-1.noarch.rpm
checksum_type: sha256
rpm_license:
  Periodictable is in the public domain.  Code in individual files has copyright and license set by individual authors.  periodictable/cromerman.py --------------------------  Copyright (c) 2009 Trustees of the Columbia University in the City of New York.  All rights reserved.  DANSE Diffraction group, Simon J. L. Billinge  File coded by:    Pavol Juhas  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.  * 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.  * Neither the name of Columbia University 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 OWNER 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: 9942641a6cdfa365229f1ccb5e94f5d0669f754cb3b19ff36e702c7c3a5b94e6
name: python-permit-broadcaster-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for permit-broadcaster
url: https://github.com/permitio/broadcaster
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-permit-broadcaster-0.2.6-1.src.rpm
location_href: Packages/python-permit-broadcaster-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  Broadcaster helps you develop realtime streaming functionality by providing
  a simple broadcast API onto a number of different backend services.
  It currently supports [Redis PUB/SUB](https://redis.io/topics/pubsub), [Apache Kafka](https://kafka.apache.org/), [Apache Pulsar](https://pulsar.apache.org/) and [Postgres LISTEN/NOTIFY](https://www.postgresql.org/docs/current/sql-notify.html), plus a simple in-memory backend, that you can use for local development or during testing.
  <img src="https://raw.githubusercontent.com/encode/broadcaster/master/docs/demo.gif" alt='WebSockets Demo'>
  Here's a complete example of the backend code for a simple websocket chat app:
  **app.py**
  ```python


  from broadcaster import Broadcast
  from starlette.applications import Starlette
  from starlette.concurrency import run_until_first_complete
  from starlette.routing import Route, WebSocketRoute
  from starlette.templating import Jinja2Templates
  broadcast = Broadcast("redis://localhost:6379")
  templates = Jinja2Templates("templates")
  async def homepage(request):
      template = "index.html"
      context = {"request": request}
      return templates.TemplateResponse(template, context)
  async def chatroom_ws(websocket):
      await websocket.accept()
      await run_until_first_complete(
          (chatroom_ws_receiver, {"websocket": websocket}),
          (chatroom_ws_sender, {"websocket": websocket}),
      )
  async def chatroom_ws_receiver(websocket):
      async for message in websocket.iter_text():
          await broadcast.publish(channel="chatroom", message=message)
  async def chatroom_ws_sender(websocket):
      async with broadcast.subscribe(channel="chatroom") as subscriber:
          async for event in subscriber:
              await websocket.send_text(event.message)
  routes = [
      Route("/", homepage),
      WebSocketRoute("/", chatroom_ws, name='chatroom_ws'),
  ]
  app = Starlette(
      routes=routes, on_startup=[broadcast.connect], on_shutdown=[broadcast.disconnect],
  )
  ```
  The HTML template for the front end [is available here](https://github.com/encode/broadcaster/blob/master/example/templates/index.html), and is adapted from [Pieter Noordhuis's PUB/SUB demo](https://gist.github.com/pietern/348262).

  Python 3.7+

  * `pip install permit-broadcaster`
  * `pip install permit-broadcaster[redis]`
  * `pip install permit-broadcaster[pulsar]`
  * `pip install permit-broadcaster[postgres]`
  * `pip install permit-broadcaster[kafka]`

  * `Broadcast('memory://')`
  * `Broadcast("redis://localhost:6379")`
  * `Broadcast("pulsar://localhost:6650")`
  * `Broadcast("postgres://localhost:5432/broadcaster")`
  * `Broadcast("kafka://localhost:9092")`
  * `Broadcast("kafka://broker_1:9092,broker_2:9092")`

  The following environment variables are exposed to allow SASL authentication with Kafka (along with their default assignment):
  ```
  KAFKA_SECURITY_PROTOCOL=PLAINTEXT   # PLAINTEXT, SASL_PLAINTEXT, SASL_SSL
  KAFKA_SASL_MECHANISM=PLAIN   # PLAIN, SCRAM-SHA-256, SCRAM-SHA-512
  KAFKA_PLAIN_USERNAME=None   # any str
  KAFKA_PLAIN_PASSWORD=None   # any str
  KAFKA_SSL_CAFILE=None   # CA Certificate file path for kafka connection
  KAFKA_SSL_CAPATH=None   # Path to directory of trusted PEM certificates for kafka connection
  KAFKA_SSL_CERTFILE=None   # Public Certificate path matching key to use for Kafka connection in PEM format
  KAFKA_SSL_KEYFILE=None   # Private key path to use for Kafka connection in PEM format
  KAFKA_SSL_KEY_PASSWORD=None   # Private key password
  ```
  For full details refer to the (AIOKafka options)[https://aiokafka.readthedocs.io/en/stable/api.html#producer-class] where the variable name matches the capitalised env var with an additional `KAFKA_` prefix.
  For SSL properties see (AIOKafka SSL Context)[https://aiokafka.readthedocs.io/en/stable/api.html#aiokafka.helpers.create_ssl_context].

  Support for Apache Pulsar, a distributed messaging system, has been added.
  To use Pulsar as a backend, ensure you have the necessary package installed:
  ```bash
  pip install permit-broadcaster[pulsar]
  ```
  You will also need a running Pulsar instance. Follow the [official Pulsar installation guide](https://pulsar.apache.org/docs/3.3.x/getting-started-home/) for detailed setup instructions. You can also start Pulsar via Docker using the provided `docker-compose.yaml` file in the repository:
  ```bash
  docker-compose up pulsar

  ```
  **In the Available backends section, add:**
  ```python
  Broadcast("pulsar://localhost:6650")
  ```
  Ensure you have a Pulsar server running before executing this example.

  * **Added Pulsar**: Apache Pulsar is now available as a backend in Broadcaster.

  At the moment `broadcaster` is in Alpha, and should be considered a working design document.
  The API should be considered subject to change. If you *do* want to use Broadcaster in its current
  state, make sure to strictly pin your requirements to `broadcaster==0.2.0`.
  To be more capable we'd really want to add some additional backends, provide API support for reading recent event history from persistent stores, and provide a serialization/deserialization API...
  * Serialization / deserialization to support broadcasting structured data.
  * Backends for Redis Streams, Apache Kafka, and RabbitMQ.
  * Add support for `subscribe('chatroom', history=100)` for backends which provide persistence. (Redis Streams, Apache Kafka) This will allow applications to subscribe to channel updates, while also being given an initial window onto the most recent events. We *might* also want to support some basic paging operations, to allow applications to scan back in the event history.
  * Support for pattern subscribes in backends that support it.


pkgId: e16fdbc787eca2cd51a6e7b1cc9c7b774cb7e12f4da7797b4b4ba4b421a160d8
name: python-perscache-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for perscache
url: https://github.com/leshchenko1979/perscache
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-perscache-0.7.0-1.src.rpm
location_href: Packages/python-perscache-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/pypi/dm/perscache.svg)
  ![](https://github.com/leshchenko1979/perscache/workflows/build/badge.svg)
  [![codecov](https://codecov.io/gh/leshchenko1979/perscache/branch/master/graph/badge.svg?token=IVIIFN8NDU)](https://codecov.io/gh/leshchenko1979/perscache)
  [![CodeFactor](https://www.codefactor.io/repository/github/leshchenko1979/perscache/badge)](https://www.codefactor.io/repository/github/leshchenko1979/perscache)

  An easy to use decorator for persistent memoization: like `functools.lrucache`, but results persist between runs and can be stored in any format to any storage.
  ```python
  from perscache import Cache

  cache = Cache()

  @cache
  def get_data():
      ...
  ```

  - [Use cases](#use-cases)
  - [Features](#features)
  - [Getting started](#getting-started)
  - [Make your own serialization and storage back-ends](#make-your-own-serialization-and-storage-backends)
  - [API Reference](docs/api_reference.md)



  - Cache the results of a function that uses a lot of resources: runs for a long time, consumes a lot of traffic, uses up paid API calls etc.
  - Speed up retreival of data that doesn't change often.
  - Inspect the results of a decorated function while debugging.
  - Build a simple data store.



  - Easy to swap out the cache configuration when switching environments.
  - Async functions supported.
  - Instance-specific caching for both sync and async class methods.
  - Time-to-live (TTL) support - automatically invalidate cache entries after a certain time.
  - Automatic cache invalidation when the decorated function arguments or code have been changed.
  - You can ignore changes in certain arguments of the decorated function.
  - Each instance of a class maintains its own separate cache.
  - Smart detection of instance methods vs standalone functions.


  - Various serialization formats: JSON, YAML, pickle, Parquet, CSV etc.
  - Various storage backends: local disk, GCS (Google Cloud Storage) and others to be implemented soon ([S3](https://github.com/leshchenko1979/perscache/issues/13), [Azure Blob Storage](https://github.com/leshchenko1979/perscache/issues/14)).
  - Serialization and storage are separated into two different classes, so that you can mix various serialization formats and storage back-ends as you like - JSON to local storage, Pickle to AWS, Parquet to Google Cloud Storage etc.
  - You can set default serialization format and storage backend and then change them on a per-function basis.
  - You can easily add new serialization formats and storage back-ends.
  - Local storage is file-based, so you can use human-readable serialization (JSON, YAML, CSV) and inspect cached results.
  - Automatic cleanup: least recently used results can be removed from storage when the total storage size exceeds a given threshold.



  ```bash
  pip install perscache
  ```
  There are also some optional dependencies you need to install to use some of the features:
  - `yaml` - for YAML serialization
  - `pyarrow` - for Parquet serialization
  - `pandas` - for CSV serialization
  - `gcsfs` - for GCS storage

  ```python
  from perscache import Cache

  cache = Cache()

  counter = 0

  @cache
  def get_data():
      print("Fetching data...")

      global counter
      counter += 1

      return "abc"

  print(get_data())  # the function is called



  print(get_data())  # the cache is used


  print(counter)  # the function was called only once

  ```


  The cache decorator works seamlessly with both regular functions and instance methods:

  ```python
  class Calculator:
      def __init__(self):
          self.compute_count = 0

      @cache
      def add(self, a: int, b: int) -> int:
          self.compute_count += 1
          return a + b

  calc1 = Calculator()
  calc2 = Calculator()


  result1 = calc1.add(5, 3)  # compute_count = 1

  result2 = calc1.add(5, 3)  # compute_count still 1


  result3 = calc2.add(5, 3)  # calc2.compute_count = 1
  ```

  The cache is instance-specific, so different instances of the same class maintain separate caches. This works for both synchronous and asynchronous methods.


  The cache works with async functions and methods:

  ```python
  @cache
  async def fetch_data(url: str):
      print("Fetching data...")
      response = await some_async_request(url)
      return response


  data1 = await fetch_data("example.com")

  data2 = await fetch_data("example.com")
  ```


  ```python
  @cache
  def get_data(key):
      print("The function has been called...")
      return key

  print(get_data("abc"))  # the function has been called



  print(get_data("fgh"))  # the function has been called again



  print(get_data("abc"))  # using the cache


  @cache
  def get_data(key):
      print("This function has been changed...")
      return key

  print(get_data("abc"))  # the function has been called again



  ```
  >NOTE: `perscache` hashes the function arguments, its code and the name of the class of the serializer, so that the cache is invalidated when any of these change. You can use the `ignore_args` parameter to [ignore changes in certain arguments](#ignoring-certain-arguments) of the decorated function.
  >
  >However, if you change the code of the serializer, the cache is not invalidated. (This is because we cannot hash the code of the serializer when in was made with the factory function `make_serializer`. See [Make your own serialization and storage back-ends](#make-your-own-serialization-and-storage-backends) for more details.)

  ```python
  import datetime as dt

  @cache(ttl=dt.timedelta(days=1))
  def get_data():
      """This function will be cached for 1 day
      and called again after this period expires."""
      ...
  ```

  By specifying the arguments that should be ignored, you can still use the cache even in the values of these arguments have changed.
  ```python
  @cache(ignore="ignore_this")
  def get_data(key, ignore_this):
      print("The function has been called...")
      return key

  print(get_data("abc", "ignore_1"))  # the function has been called




  print(get_data("abc", "ignore_2"))

  ```


  ```python

  cache = Cache(
      serializer=JSONSerializer(),
      storage=GoogleCloudStorage("/bucket/folder")
  )

  ...


  @cache(serialization=PickleSerializer())
  def get_data(key):
      ...
  ```


  ```python
  import os

  from perscache import Cache, NoCache
  from perscache.storage import LocalFileStorage

  if os.environ.get["DEBUG"]:
      cache = NoCache()  # turn off caching in debug mode
  else:
      cache = (
          GoogleCloudStorage("/bucket/folder")
          if os.environ.get["GOOGLE_PROJECT_NAME"]  # if running in the cloud
          else LocalFileStorage()
      )

  @cache
  def function():
      ...
  ```

  Use human-readable serialization (`JSONSerializer`, `YAMLSerializer`, `CSVSerializer`) and a file storage (`LocalFileStorage`, `GoogleCloudStorage`) to inspect cached results.


  When using `LocalFileStorage(max_size=...)` or `GoogleCloudStorage(max_size=...)` , the least recently used cache entries are automatically removed to keep the total cache size with the `max_size` limit.



  Although you can use the standard `CloudPickleSerializer()` for almost any type of data, sometimes you want to inspect the results of a decorated function by lookin into the cache files. This requires the data to be serialized in a human-readable format. But the included human-readable serializers (`JSONSerializer()`, `YAMLSerializer()`, `CSVSerializer()`) sometimes cannot process complex objects.

  >To see which serializers are compatible with which data types, see the [compatibility.py](/perscache/compatibility.py) file.

  That's when making your own serializer comes in handy.

  To do this, you should:
  1. Derive your own serialization classe from the abstract `Serializer` class and override the abstract methods. You should also provide the `extension` class variable that specifies the file extension.
  2. Use your class with the `Cache` class.

  ```python
  from perscache.serializers import Serializer

  class MySerializer(Serializer):

      extension = "data"

      def dumps(self, data: Any) -> bytes:
          ...

      def loads(self, data: bytes) -> Any:
          ...

  cache = Cache(serializer=MySerializer())
  ```

  You can also use the `perscache.serializers.make_serializer()` function to create a serializer for a given data type.
  ```python
  import pyrogram
  from perscache.serializers import make_serializer

  PyrogramSerializer = make_serializer(
      "PyrogramSerializer",
      "pyro",
      dumps_fn = lambda data: str(data).encode("utf-8"),
      loads_fn = lambda data: eval(data.decode("utf-8")),
  )

  cache = Cache(serializer=PyrogramSerializer())

  @cache
  async def some_pyrogram_func() -> pyrogram.Message:
      ...
  ```

  Making a custom storage backed is similar:
  ```python
  class MyStorage(Storage):
      def read(self, path, deadline: datetime.datetime) -> bytes:
          """Read the file at the given path and return its contents as bytes.
          If the file does not exist, raise FileNotFoundError. If the file is
          older than the given deadline, raise CacheExpired.
          """
          ...

      def write(self, path, data: bytes) -> None:
          """Write the file at the given path."""
          ...

  cache = Cache(storage=MyStorage())
  ```
  You can also derive your storage class from `perscache.storage.FileStorage` if you are building a filesystem-based storage back-end. Refer to the [storage.py](/perscache/storage.py#FileStorage) file for more information.


pkgId: 64ea1303db961a629236bed6da43259f254941f4d4ab137114b3565c4fba0b6a
name: python-persistable-help
arch: noarch
version: 1.2.3
epoch: 0
release: 1
summary: Development documents and examples for persistable
url: https://github.com/aloosley/persistable
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-persistable-1.2.3-1.src.rpm
location_href: Packages/python-persistable-help-1.2.3-1.noarch.rpm
checksum_type: sha256
description:
  Persistable is a lightweight framework that helps developers clearly define parametrized programmatic pipelines, and reproducibly generate, persist, and load artifacts using parameter based persisting and loading.


pkgId: 1462457146d95895504f3e9b4e795379c5b82f8bdf26e00840777fa47d3ee28b
name: python-personal-knowledge-library-help
arch: noarch
version: 2.4.3
epoch: 0
release: 1
summary: Development documents and examples for personal-knowledge-library
url: https://github.com/Wacom-Developer/personal-knowledge-library
rpm_license: Apache 2.0 License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-personal-knowledge-library-2.4.3-1.src.rpm
location_href: Packages/python-personal-knowledge-library-help-2.4.3-1.noarch.rpm
checksum_type: sha256
description:
      display_entity: ThingObject
          Entity with properties
      list_idx: int
          Index with a list
      client: WacomKnowledgeService
          Knowledge graph client
      short: bool
          Short summary
      """
      print(f'[{list_idx}] : {display_entity.uri} <{display_entity.concept_type.iri}>')
      if len(display_entity.label) > 0:
          print('    | [Labels]')
          for la in display_entity.label:
              print(f'    |     |- "{la.content}"@{la.language_code}')
          print('    |')
      if not short:
          if len(display_entity.alias) > 0:
              print('    | [Alias]')
              for la in display_entity.alias:
                  print(f'    |     |- "{la.content}"@{la.language_code}')
              print('    |')
          if len(display_entity.data_properties) > 0:
              print('    | [Attributes]')
              for data_property, labels in display_entity.data_properties.items():
                  print(f'    |    |- {data_property.iri}:')
                  for li in labels:
                      print(f'    |    |-- "{li.value}"@{li.language_code}')
              print('    |')
          relations_obj: Dict[OntologyPropertyReference, ObjectProperty] = client.relations(uri=display_entity.uri)
          if len(relations_obj) > 0:
              print('    | [Relations]')
              for r_idx, re in enumerate(relations_obj.values()):
                  last: bool = r_idx == len(relations_obj) - 1
                  print(f'    |--- {re.relation.iri}: ')
                  print(f'    {"|" if not last else " "}       |- [Incoming]: {re.incoming_relations} ')
                  print(f'    {"|" if not last else " "}       |- [Outgoing]: {re.outgoing_relations}')
          print()
  if __name__ == '__main__':
      parser = argparse.ArgumentParser()
      parser.add_argument("-u", "--user", help="External Id of the shadow user within the Wacom Personal Knowledge.",
                          required=True)
      parser.add_argument("-t", "--tenant", help="Tenant Id of the shadow user within the Wacom Personal Knowledge.",
                          required=True)
      parser.add_argument("-i", "--instance", default='https://private-knowledge.wacom.com',
                          help="URL of instance")
      args = parser.parse_args()
      TENANT_KEY: str = args.tenant
      EXTERNAL_USER_ID: str = args.user
      
      knowledge_client: WacomKnowledgeService = WacomKnowledgeService(application_name="Wacom Knowledge Listing",
                                                                      service_url=args.instance)
      knowledge_client.login(args.tenant, args.user)
      page_id: Optional[str] = None
      page_number: int = 1
      entity_count: int = 0
      print('-----------------------------------------------------------------------------------------------------------')
      print(' First step: Find Leonardo da Vinci in the knowledge graph.')
      print('-----------------------------------------------------------------------------------------------------------')
      res_entities, next_search_page = knowledge_client.search_labels(search_term=LEONARDO_DA_VINCI,
                                                                      language_code=LocaleCode('en_US'), limit=1000)
      leo: Optional[ThingObject] = None
      s_idx: int = 1
      for res_entity in res_entities:
          
          if res_entity.concept_type == PERSON_CLASS and LEONARDO_DA_VINCI in [la.content for la in res_entity.label]:
              leo = res_entity
              break
      print('-----------------------------------------------------------------------------------------------------------')
      print(' What artwork exists in the knowledge graph.')
      print('-----------------------------------------------------------------------------------------------------------')
      relations_dict: Dict[OntologyPropertyReference, ObjectProperty] = knowledge_client.relations(uri=leo.uri)
      print(f' Artwork of {leo.label}')
      print('-----------------------------------------------------------------------------------------------------------')
      idx: int = 1
      if CREATED in relations_dict:
          for e in relations_dict[CREATED].outgoing_relations:
              print(f' [{idx}] {e.uri}: {e.label}')
              idx += 1
      print('-----------------------------------------------------------------------------------------------------------')
      print(' Let us create a new piece of artwork.')
      print('-----------------------------------------------------------------------------------------------------------')
      
      artwork_labels: List[Label] = [
          Label('Ginevra Gherardini', EN_US),
          Label('Ginevra Gherardini', DE_DE)
      ]
      
      artwork_alias: List[Label] = [
          Label("Ginevra", EN_US),
          Label("Ginevra", DE_DE)
      ]
      
      artwork_description: List[Description] = [
          Description('Oil painting of Mona Lisa\' sister', EN_US),
          Description('Ölgemälde von Mona Lisa\' Schwester', DE_DE)
      ]
      
      artwork_object: ThingObject = ThingObject(label=artwork_labels, concept_type=ARTWORK_CLASS,
                                                description=artwork_description,
                                                icon=ICON)
      artwork_object.alias = artwork_alias
      print(f' Create: {artwork_object}')
      
      artwork_entity_uri: str = knowledge_client.create_entity(artwork_object)
      print(f' Entity URI: {artwork_entity_uri}')
      
      knowledge_client.create_relation(source=leo.uri, relation=IS_CREATOR, target=artwork_entity_uri)
      relations_dict = knowledge_client.relations(uri=artwork_entity_uri)
      for ontology_property, object_property in relations_dict.items():
          print(f'  {object_property}')
      
      
      
      res_entities, next_search_page = knowledge_client.search_description('Michelangelo\'s Sistine Chapel',
                                                                           EN_US, limit=1000)
      print('-----------------------------------------------------------------------------------------------------------')
      print(' Search results.  Description: "Michelangelo\'s Sistine Chapel"')
      print('-----------------------------------------------------------------------------------------------------------')
      s_idx: int = 1
      for e in res_entities:
          print_entity(e, s_idx, knowledge_client)
      
      res_entities, next_search_page = knowledge_client.search_labels(search_term=SELF_PORTRAIT_STYLE,
                                                                      language_code=EN_US, limit=1000)
      art_style: Optional[ThingObject] = None
      s_idx: int = 1
      for entity in res_entities:
          
          if entity.concept_type == ART_STYLE_CLASS and SELF_PORTRAIT_STYLE in [la.content for la in entity.label]:
              art_style = entity
              break
      res_entities, next_search_page = knowledge_client.search_relation(subject_uri=None,
                                                                        relation=HAS_ART_STYLE,
                                                                        object_uri=art_style.uri,
                                                                        language_code=EN_US)
      print('-----------------------------------------------------------------------------------------------------------')
      print(' Search results.  Relation: relation:=has_topic  object_uri:= unknown')
      print('-----------------------------------------------------------------------------------------------------------')
      s_idx: int = 1
      for e in res_entities:
          print_entity(e, s_idx, knowledge_client, short=True)
          s_idx += 1
      
      entities, relations = knowledge_client.activations(uris=[leo.uri], depth=1)
      print('-----------------------------------------------------------------------------------------------------------')
      print(f'Activation.  URI: {leo.uri}')
      print('-----------------------------------------------------------------------------------------------------------')
      s_idx: int = 1
      for e in res_entities:
          print_entity(e, s_idx, knowledge_client)
          s_idx += 1
      
      print('-----------------------------------------------------------------------------------------------------------')
      for r in relations:
          print(f'Subject: {r[0]} Predicate: {r[1]} Object: {r[2]}')
      print('-----------------------------------------------------------------------------------------------------------')
      page_id = None
      
      idx: int = 1
      while True:
          
          entities, total_number, next_page_id = knowledge_client.listing(ART_STYLE_CLASS, page_id=page_id, limit=100)
          pulled_entities: int = len(entities)
          entity_count += pulled_entities
          print('-------------------------------------------------------------------------------------------------------')
          print(f' Page: {page_number} Number of entities: {len(entities)}  ({entity_count}/{total_number}) '
                f'Next page id: {next_page_id}')
          print('-------------------------------------------------------------------------------------------------------')
          for e in entities:
              print_entity(e, idx, knowledge_client)
              idx += 1
          if pulled_entities == 0:
              break
          page_number += 1
          page_id = next_page_id
      print()
      
      while True:
          
          entities, total_number, next_page_id = knowledge_client.listing(THING_OBJECT, page_id=page_id,
                                                                          limit=100)
          pulled_entities: int = len(entities)
          if pulled_entities == 0:
              break
          delete_uris: List[str] = [e.uri for e in entities]
          print(f'Cleanup. Delete entities: {delete_uris}')
          knowledge_client.delete_entities(uris=delete_uris, force=True)
          page_number += 1
          page_id = next_page_id
      print('-----------------------------------------------------------------------------------------------------------')
  ```

  Performing Named Entity Linking (NEL) on text and Universal Ink Model.
  ```python
  import argparse
  from typing import List, Dict
  import urllib3
  from knowledge.base.language import EN_US
  from knowledge.base.ontology import OntologyPropertyReference, ThingObject, ObjectProperty
  from knowledge.nel.base import KnowledgeGraphEntity
  from knowledge.nel.engine import WacomEntityLinkingEngine
  from knowledge.services.graph import WacomKnowledgeService
  urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
  TEXT: str = "Leonardo da Vinci painted the Mona Lisa."
  def print_entity(entity: KnowledgeGraphEntity, list_idx: int, auth_key: str, client: WacomKnowledgeService):
      """
      Printing entity details.


pkgId: d215ee3b191d09bb22e15b8a4672665e37f255ff867ac13689a51e993ee6ff4f
name: python-perturbopy-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for perturbopy
url: https://pypi.org/project/perturbopy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-perturbopy-0.7.0-1.src.rpm
location_href: Packages/python-perturbopy-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  This package provides utilities to postprocess and test the Perturbo code, which is an open-source software to compute from first principles the scattering processes between charge carriers (electrons and holes) and phonons, defects, and photons in solid state materials, including metals, semiconductors, oxides, and insulators. Perturbo is written in modern Fortran, including efficient MPI and OpenMP parallelization, allowing to perform calculations efficient on supercomputers using up to ~100,000 cores. Read more about the main code Perturbo [here](https://perturbo-code.github.io/index.html).

  Perturbopy provides a user-friendly object-oriented environment to postprocess Perturbo calculations, such as band structure interpolation, electron transport, ultrafast carrier dynamics, and many more. Using Perturbopy, a user can easily load the Perturbo output files (HDF5 or YAML) into Python objects, perform calculations, and visualize data.

  The second purpose of the Perturbopy package is to test the main Perturbo code. After a compilation of the Perturbo code on a new machine or after a new implementation, it is always a good practice to run the testsuite, verifying that the existing functionality was not affected, and add new test cases to ensure that the newly implemented features will be compatible with future implementations. Perturbopy, using the `pytest` package, provides extensive testing of Perturbo, allowing for both serial and parallel runs.

  Find more about Perturbopy on its [documentation website](https://perturbopy.readthedocs.io). We are open to collaboration! Please create a fork and submit a pull request with detailed description of your work, and we will be happy to discuss and include your contribution.


pkgId: 33bf3a88075c47079f56cc220faaf47dba5f6b9fdd1440476a99e2c95bf953fb
name: python-perun-help
arch: noarch
version: 0.8.9
epoch: 0
release: 1
summary: Development documents and examples for perun
url: https://github.com/Helmholtz-AI-Energy/perun
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-perun-0.8.9-1.src.rpm
location_href: Packages/python-perun-help-0.8.9-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
    <img src="https://raw.githubusercontent.com/Helmholtz-AI-Energy/perun/main/docs/images/full_logo.svg">
  </div>

  &nbsp;
  &nbsp;

  [![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green)](https://fair-software.eu)
  [![OpenSSF Best Practices](https://bestpractices.coreinfrastructure.org/projects/7253/badge)](https://bestpractices.coreinfrastructure.org/projects/7253)
  [![DOI](https://zenodo.org/badge/523363424.svg)](https://zenodo.org/badge/latestdoi/523363424)
  ![PyPI](https://img.shields.io/pypi/v/perun)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/perun)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![codecov](https://codecov.io/gh/Helmholtz-AI-Energy/perun/graph/badge.svg?token=9O6FSJ6I3G)](https://codecov.io/gh/Helmholtz-AI-Energy/perun)
  [![](https://img.shields.io/badge/Python-3.8+-blue.svg)](https://www.python.org/downloads/)
  [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
  [![Documentation Status](https://readthedocs.org/projects/perun/badge/?version=latest)](https://perun.readthedocs.io/en/latest/?badge=latest)

  perun is a Python package that calculates the energy consumption of Python scripts by sampling usage statistics from your Intel, Nvidia or AMD hardware components. It can handle MPI applications, gather data from hundreds of nodes, and accumulate it efficiently. perun can be used as a command-line tool or as a function decorator in Python scripts.

  Check out the [docs](https://perun.readthedocs.io/en/latest/) or a working [example](https://github.com/Helmholtz-AI-Energy/perun/blob/main/examples/torch_mnist/README.md)!



   - Measures energy consumption of Python scripts using Intel RAPL, ROCM-SMI, Nvidia-NVML, and psutil
   - Capable of handling MPI application, gathering data from hundreds of nodes efficiently
   - Monitor individual functions using decorators
   - Tracks energy usage of the application over multiple executions
   - Easy to benchmark applications and functions
   - Experimental!: Can monitor any non-distributed command line application



  From PyPI:

  ```console
  pip install perun
  ```

  > Extra dependencies like nvidia-smi, rocm-smi and mpi can be installed using pip as well:
  ```console
  pip install perun[nvidia, rocm, mpi]
  ```

  From Github:

  ```console
  pip install git+https://github.com/Helmholtz-AI-Energy/perun
  ```





  To use perun as a command-line tool, run the monitor subcommand followed by the path to your Python script and its arguments:

  ```console
  $ perun monitor path/to/your/script.py [args]
  ```

  perun will output two files, and HDF5 style containing all the raw data that was gathered, and a text file with a summary of the results.


  ```text
  PERUN REPORT

  App name: finetune_qa_accelerate
  First run: 2023-08-15T18:56:11.202060
  Last run: 2023-08-17T13:29:29.969779


  RUN ID: 2023-08-17T13:29:29.969779

  |   Round # | Host                | RUNTIME   | ENERGY     | CPU_POWER   | CPU_UTIL   | GPU_POWER   | GPU_MEM    | DRAM_POWER   | MEM_UTIL   |
  |----------:|:--------------------|:----------|:-----------|:------------|:-----------|:------------|:-----------|:-------------|:-----------|
  |         0 | hkn0432.localdomain | 995.967 s | 960.506 kJ | 231.819 W   | 3.240 %    | 702.327 W   | 55.258 GB  | 29.315 W     | 0.062 %    |
  |         0 | hkn0436.localdomain | 994.847 s | 960.469 kJ | 235.162 W   | 3.239 %    | 701.588 W   | 56.934 GB  | 27.830 W     | 0.061 %    |
  |         0 | All                 | 995.967 s | 1.921 MJ   | 466.981 W   | 3.240 %    | 1.404 kW    | 112.192 GB | 57.145 W     | 0.061 %    |

  The application has been run 7 times. In total, it has used 3.128 kWh, released a total of 1.307 kgCO2e into the atmosphere, and you paid 1.02 € in electricity for it.
  ```

  Perun will keep track of the energy of your application over multiple runs.



  perun is capable of monitoring simple applications written in other languages, as long as they don't make use of MPI or are distributed over multiple computational nodes.

  ```console
  $ perun monitor --binary path/to/your/executable [args]
  ```



  Using a function decorator, information can be calculated about the runtime, power draw and component utilization while the function is executing.

  ```python

  import time
  from perun import monitor

  @monitor()
  def main(n: int):
      time.sleep(n)
  ```

  After running the script with ```perun monitor```, the text report will add information about the monitored functions.

  ```text
  Monitored Functions

  |   Round # | Function                    |   Avg Calls / Rank | Avg Runtime     | Avg Power        | Avg CPU Util   | Avg GPU Mem Util   |
  |----------:|:----------------------------|-------------------:|:----------------|:-----------------|:---------------|:-------------------|
  |         0 | main                        |                  1 | 993.323±0.587 s | 964.732±0.499 W  | 3.244±0.003 %  | 35.091±0.526 %     |
  |         0 | prepare_train_features      |                 88 | 0.383±0.048 s   | 262.305±19.251 W | 4.541±0.320 %  | 3.937±0.013 %      |
  |         0 | prepare_validation_features |                 11 | 0.372±0.079 s   | 272.161±19.404 W | 4.524±0.225 %  | 4.490±0.907 %      |
  ```



  Perun is compatible with MPI applications that make use of ```mpi4py```, and requires changes in the code or in the perun configuration. Simply replace the ```python``` command with ```perun monitor```.

  ```console
  mpirun -n 8 perun monitor path/to/your/script.py
  ```



  To get more information, check out our [docs page](https://perun.readthedocs.io/en/latest/) or check the [examples](https://github.com/Helmholtz-AI-Energy/perun/tree/main/examples).



  If you found perun usefull, please consider citing the conference paper:

   * Gutiérrez Hermosillo Muriedas, J.P., Flügel, K., Debus, C., Obermaier, H., Streit, A., Götz, M.: perun: Benchmarking Energy Consumption of High-Performance Computing Applications. In: Cano, J., Dikaiakos, M.D., Papadopoulos, G.A., Pericàs, M., and Sakellariou, R. (eds.) Euro-Par 2023: Parallel Processing. pp. 17–31. Springer Nature Switzerland, Cham (2023). https://doi.org/10.1007/978-3-031-39698-4_2.


  ```bibtex
  @InProceedings{10.1007/978-3-031-39698-4_2,
    author="Guti{\'e}rrez Hermosillo Muriedas, Juan Pedro
    and Fl{\"u}gel, Katharina
    and Debus, Charlotte
    and Obermaier, Holger
    and Streit, Achim
    and G{\"o}tz, Markus",
    editor="Cano, Jos{\'e}
    and Dikaiakos, Marios D.
    and Papadopoulos, George A.
    and Peric{\`a}s, Miquel
    and Sakellariou, Rizos",
    title="perun: Benchmarking Energy Consumption of High-Performance Computing Applications",
    booktitle="Euro-Par 2023: Parallel Processing",
    year="2023",
    publisher="Springer Nature Switzerland",
    address="Cham",
    pages="17--31",
    abstract="Looking closely at the Top500 list of high-performance computers (HPC) in the world, it becomes clear that computing power is not the only number that has been growing in the last three decades. The amount of power required to operate such massive computing machines has been steadily increasing, earning HPC users a higher than usual carbon footprint. While the problem is well known in academia, the exact energy requirements of hardware, software and how to optimize it are hard to quantify. To tackle this issue, we need tools to understand the software and its relationship with power consumption in today's high performance computers. With that in mind, we present perun, a Python package and command line interface to measure energy consumption based on hardware performance counters and selected physical measurement sensors. This enables accurate energy measurements on various scales of computing, from a single laptop to an MPI-distributed HPC application. We include an analysis of the discrepancies between these sensor readings and hardware performance counters, with particular focus on the power draw of the usually overlooked non-compute components such as memory. One of our major insights is their significant share of the total energy consumption. We have equally analyzed the runtime and energy overhead perun generates when monitoring common HPC applications, and found it to be minimal. Finally, an analysis on the accuracy of different measuring methodologies when applied at large scales is presented.",
    isbn="978-3-031-39698-4"
  }
  ```

rpm_license:
  BSD 3-Clause License  Copyright (c) 2022, Helmholtz AI Energy 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: 6d22d778f166a750561822cc4e5668b30aa9ad939ef43f412975870c33a37880
name: python-pest-py-help
arch: noarch
version: 0.4.4
epoch: 0
release: 1
summary: Development documents and examples for pest-py
url: https://pest.lucode.ar
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pest-py-0.4.4-1.src.rpm
location_href: Packages/python-pest-py-help-0.4.4-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img height="150" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/logo.svg">
  </p>
  <br/>

  <p align="center">
  <b>pest</b> <img height="16" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/icons/pest.svg" /> is a python <img height="16" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/icons/python.svg" /> web application framework designed for constructing scalable APIs, drawing inspiration from <a href="https://docs.nestjs.com/"> nest.js</a> <img height="16" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/icons/nestjs.svg" /> and based on <a href="https://fastapi.tiangolo.com/"> fastapi</a> <img height="16" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/icons/fastapi.svg" />.
  </p>

  <br/>

  <p align="center">Check the <a href="https://pest.lucode.dev" target="_blank">Documentation</a></p>

  <br/>

  <p align="center">
    <img height="74" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/latex.svg">
  </p>

  <br />
  <p align="center">
  ━━━&nbsp&nbsp&nbsp&nbsp<img height="16" src="https://raw.githubusercontent.com/lucas-labs/pest/master/.github/img/icons/pest.svg" />&nbsp&nbsp&nbsp&nbsp━━━
  </p>
  <br />

  <p align="center">
  <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/pest-py?style=flat-square&logo=python&labelColor=%23020101&color=%23db4a01">&nbsp
  <a href="https://pypi.org/project/pest-py/"><img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/pest-py?style=flat-square&logo=pypi&logoColor=%23db4901&labelColor=%23020101&color=%23db4901&link=https%3A%2F%2Fpypi.org%2Fproject%2Fpest-py%2F"></a>&nbsp
  <a href="https://pypi.org/project/pest-py/">
  <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/pest-py?style=flat-square&logo=pypi&labelColor=%23020101&color=%23db4a01">
  </a>
  </p>

  <br/>



  With pip:

  ```bash
  pip install pest-py
  ```

  With poetry:

  ```bash
  poetry add pest-py
  ```

  <br/>



  Head to the [documentation](https://pest.lucode.dev) to learn more about **pest**.

  <br/>



  Follow the [tutorial](https://pest.lucode.dev/docs/learn/getting-started) to learn how to build a simple API with **pest**.


pkgId: a11d22476aa85739bf094c6b76d859e04cc9126a7ed308884579281057975c5f
name: python-petal-qc-help
arch: noarch
version: 0.0.16
epoch: 0
release: 1
summary: Development documents and examples for petal-qc
url: https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-petal-qc-0.0.16-1.src.rpm
location_href: Packages/python-petal-qc-help-0.0.16-1.noarch.rpm
checksum_type: sha256
description:
  The folder contains a collections of scripts to make the analysis of the Petal
  QC metrology and thermal tests.

  They will also upload the tests to the DB if required.


pkgId: 7a7832f897baa6e9293f2f1e4ad81ad6d7c932a26b023bcc6332560afbb322e1
name: python-petaly-help
arch: noarch
version: 0.0.8.post2
epoch: 0
release: 1
summary: Development documents and examples for petaly
url: https://petaly.org
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-petaly-0.0.8.post2-1.src.rpm
location_href: Packages/python-petaly-help-0.0.8.post2-1.noarch.rpm
checksum_type: sha256
description:
  data_objects_spec:
  - object_spec:
      object_name: stocks
      destination_object_name:
      recreate_destination_object: true
      cleanup_linebreak_in_fields: false
      exclude_columns:
      -
      object_source_dir: /your-directory-path-to-csv-files
      file_names:
      - stocks.csv
  - object_spec:
      object_name: options
      destination_object_name:
      recreate_destination_object: true
      cleanup_linebreak_in_fields: false
      exclude_columns:
      -
      object_source_dir: /your-directory-path-to-csv-files
      file_names:
      - options.csv
  ```
  <a id="petaly-pipeline-explained"></a>

  This tutorial provides a step-by-step guide for getting started with Petaly after installation. It begins with an explanation of the petaly.ini configuration file and then dives into the details of the pipeline.yaml file.

  To avoid mistakes during configuration, it is recommended to use the pipeline wizard. The configuration differs depending on the endpoints.
  To use pipeline wizard run following command:
  `$ python3 -m petaly init -p my_pipeline -c /path_to_config_dir/petaly.ini`

  After creating the pipeline, let's review the structure and each parameter.
  Here is an example of an export table from mysql to postgres
  The pipeline.yaml file contains two documents `pipeline:` and `data_objects_spec:`.
  The `pipeline:` document defines `pipeline_attributes:`, `source_attributes:`, `target_attributes:` and `data_attributes:`
  The second document in the pipeline.yaml file, separated by three dashes, is the `data_objects_spec:` document which contains the definition of each object/table.
  Here is the skeleton of the whole pipeline.yaml document:
  ```
  pipeline:
    pipeline_attributes:
    source_attributes:
    target_attributes:

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


pkgId: dc20c667916d0325ac01304c94085b4d57a5f1bef7c27128353f3a44a1203c78
name: python-petercat-utils-help
arch: noarch
version: 0.1.40
epoch: 0
release: 1
summary: Development documents and examples for petercat-utils
url: https://pypi.org/project/petercat-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-petercat-utils-0.1.40-1.src.rpm
location_href: Packages/python-petercat-utils-help-0.1.40-1.noarch.rpm
checksum_type: sha256
description:
  ![Frame 303](https://github.com/user-attachments/assets/01cf3bb2-650a-47a4-88b3-a63f961ae5e2)
  ![image](https://github.com/user-attachments/assets/77670023-4fab-4ac9-bbe1-c7ea36363e02)

  <h1 align="center"> PeterCat</h1>

  <div  align="center">

    <img src="https://gw.alipayobjects.com/zos/antfincdn/R8sN%24GNdh6/language.svg" width="18"> 简体中文 | [English](./README.en-US.md) | [日本語](./README.ja-JP.md)

    **专为社区维护者和开发者打造的智能答疑机器人解决方案。**

    [![npm](https://img.shields.io/npm/dm/@petercatai/assistant.svg)](https://www.npmjs.com/package/@petercatai/assistant)
    [![Version](https://img.shields.io/npm/v/petercat-lui/latest.svg)](https://www.npmjs.com/package/petercat-lui)
    [![DockerHub Version](https://img.shields.io/docker/v/petercatai/petercat?logo=docker&logoColor=white)](https://hub.docker.com/r/petercatai/petercat)
    [![CI Test Status](https://github.com/petercat-ai/petercat/actions/workflows/pr-tests.yml/badge.svg)](https://github.com/petercat-ai/petercat/actions/workflows/pr-tests.yml)
    [![codecov](https://codecov.io/github/petercat-ai/petercat/graph/badge.svg?token=2HAO18FB6X)](https://codecov.io/github/petercat-ai/petercat)
    [![License](https://img.shields.io/badge/License-MIT%40Peter%20Cat-yellow.svg)](https://github.com/petercat-ai/petercat/blob/master/LICENSE)

  </div>




  [🐱窝: petercat.ai](https://petercat.ai)




  我们提供对话式答疑 Agent 配置系统、自托管部署方案和便捷的一体化应用 SDK，让您能够为自己的 GitHub 仓库一键创建智能答疑机器人，并快速集成到各类官网或项目中， 为社区提供更高效的技术支持生态。



  仅需要告知你的仓库地址或名称，PeterCat 即可自动完成创建机器人的全部流程

  ![对话即创造](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*aQ9uRoNZGe8AAAAAAAAAAAAADrPSAQ/original)




  机器人创建后，所有相关Github 文档和 issue 将自动入库，作为机器人的知识依据

  ![知识自动入库](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*hkkFSaR1UqgAAAAAAAAAAAAADrPSAQ/original)



  多种集成方式自由选择，如对话应用 SDK 集成至官网，Github APP一键安装至 Github 仓库等

  | ![官网](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*REw3QYgdJ44AAAAAAAAAAAAADrPSAQ/original) | ![GitHub](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*jlYzSqlcpRIAAAAAAAAAAAAADrPSAQ/original) |
  |:--------------------------------------------------------------------------------------------------------:|:-------------------------------------------------------------------------------------------------------------:|

  [完整演示视频](https://www.bilibili.com/video/BV1KiHUeFE4p)



  | 项目信息查询                              | 回复 Discussion                                |
  | ----------------------------------------- | --------------------------------------- |
  | ![search_repo](https://github.com/user-attachments/assets/a7e6d37b-4674-4fd0-a89b-678e10ec01c8) | ![ discussion replay](https://github.com/user-attachments/assets/e28a3ded-dc6c-4ba5-9543-05c41bbff331)|


  | PR Summary       | Code Review     |
  | ----------------------------------------- | --------------------------------------- |
  | ![image](https://github.com/user-attachments/assets/28bd546b-0c00-48a2-a57e-982448d37ef2)| ![image](https://github.com/user-attachments/assets/a39c4d71-1368-4508-bca4-018a00549528) ｜

  | 查 Issue                          | 提 Issue                             | 回 Issue      |
  | ----------------------------------------- | --------------------------------------- | --------------------------------------- |
  | ![image](https://github.com/user-attachments/assets/501c6ba0-20c4-480f-97ff-1f20d0a99136)| ![image](https://github.com/user-attachments/assets/d020b03d-74cd-49d2-a199-5d21154b7793)| ![image](https://github.com/user-attachments/assets/f6093cb1-b089-4ac9-ad2c-f1c8126fb86b) |

  [完整演示视频](https://www.bilibili.com/video/BV12eHUe8EkT/)




  我们为猫猫预置了一个创建机器人的机器人，当得到用户 GitHub 仓库地址或名称时，它会使用创建工具，生成该仓库答疑机器人的各项配置（Prompt，、名字、 头像、开场白、引导语、工具集……），同时触发 Issue 和 Markdown 的入库任务。这些任务会拆分为多个子任务，将该仓库的所有已解决 issue 、高票回复以及所有 Markdown 文件内容经过 load -> split -> embed -> store 的加工过程进行知识库构建，作为机器人的回复知识依据。

  ![Agent workflow](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*m24tTIZpW7cAAAAAAAAAAAAADrPSAQ/original)



  部署方案：[AWS](https://aws.amazon.com) + [Supabase](https://supabase.com)

  你可以在这里看到完整方案：
  - [私有化部署 - 本地启动服务](./docs/guides/self_hosted_local_cn.md)
  - [私有化部署 - 部署到 AWS ](./docs/guides/self_hosted_aws_cn.md)

  ![架构方案](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*0_aUTJpyx1YAAAAAAAAAAAAADrPSAQ/original)

  [![演示视频](https://mdn.alipayobjects.com/huamei_j8gzmo/afts/img/A*spdZSbWsVhkAAAAAAAAAAAAADrPSAQ/fmt.webp)](https://www.youtube.com/watch?v=Al6R9Ye5mBY)





  本项目需要进行环境变量进行设置：


  `.env.local`


  | 环境变量            | 类型 | 描述                                                                                                                          | 示例                                                                                                   |
  | ------------------- | ---- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
  | `NEXT_PUBLIC_API_DOMAIN`    | 必选 |   后端服务的 API 域名。         | `https://api.petercat.ai`                                                                                   |




  `.env`


  | 环境变量            | 类型 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;         | 描述                                                                                                                          | 示例                                                                                                   |
  | ------------------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
  |  **应用基础环境变量** |
  | `API_URL` | 必选 |  后端服务的 API 域名 | `https://api.petercat.ai`
  | `WEB_URL` | 必选 |  前端 Web 服务的域名 | `https://petercat.ai`
  | `STATIC_URL` | 必选 | 静态资源域名 | `https://static.petercat.ai`
  |  **AWS 相关环境变量** |
  | `AWS_GITHUB_SECRET_NAME` | 必选 |  AWS 托管的 Github 私钥文件名 | `prod/githubapp/petercat/pem`
  | `AWS_STATIC_SECRET_NAME` | 可选 | AWS 托管的 CloudFront 签名私钥名称。如果配置了该项，将使用 CloudFront 签名 URL 来保护你的资源。更多信息请参阅 [AWS 文档](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html)。 | `prod/petercat/static` |
  | `AWS_LLM_TOKEN_SECRET_NAME` | 可选 | AWS 托管的 llm 签名私钥名称。如果配置了该项，petercat 将使用 RSA 算法托管用户的 LLM Token | `prod/petercat/llm` |
  | `AWS_LLM_TOKEN_PUBLIC_NAME` | 可选 | AWS 托管的 llm 签名公钥名称。如果配置了该项，petercat 将使用 RSA 算法托管用户的 LLM Token | `prod/petercat/llm/pub` |
  | `AWS_STATIC_KEYPAIR_ID` | 可选 | AWS CloudFront 的 Key Pair ID。如果配置了该项，将使用 CloudFront 签名 URL 来保护你的资源。更多信息请参阅 [AWS 文档](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-trusted-signers.html)。 | `APKxxxxxxxx` |
  | `S3_TEMP_BUCKET_NAME` | 可选 | 用于托管 AWS 临时图片文件 S3 的 bucket | `xxx-temp`
  | `SQS_QUEUE_URL`| 必选 | AWS SQS 消息队列 URL | `https://sqs.ap-northeast-1.amazonaws.com/xxx/petercat-task-queue`
  | **SUPABASE 相关 env** |
  | `SUPABASE_URL`    | 必选 |    supabase 服务的 URL，可以在[这里](https://supabase.com/dashboard/project/_/settings/database)找到                                                                    | `https://***.supabase.co`                                                                                   |
  | `SUPABASE_SERVICE_KEY`  | 必选 |    supabase 服务密钥，可以在[这里](https://supabase.com/dashboard/project/_/settings/database)找到                                     | `{{SUPABASE_SERVICE_KEY}}` |
  |  **Auth0 相关 env**|
  | `AUTH0_DOMAIN` | 必选 |   auth0 服务域名，从 auth0 / Application / Basic Information 下获取 |  `petercat.us.auth0.com`
  | `AUTH0_CLIENT_ID` | 必选 | auth0 客户端 ID，从 auth0 / Application / Basic Information 下获取  | `artfiUxxxx`
  | `AUTH0_CLIENT_SECRET` | 必选 | auth0 客户端密钥， 从 auth0 / Application / Basic Information 下获取 | `xxxx-xxxx-xxx`
  | `API_IDENTIFIER` | 必选 | auth0 的 API Identifier | `https://petercat.us.auth0.com/api/v2/`
  |  **LLM相关的 env** |
  | `OPENAI_API_KEY` | 必选 | OpenAI 的密钥 | `sk-xxxx`
  | `OPENAI_BASE_URL` | 可选 | API 请求的基础 URL。仅在使用代理或服务模拟器时指定。| `https://api.openai.com/v1`
  | `GEMINI_API_KEY` | 可选 | Gemini 的密钥 | `xxxx`
  | `TAVILY_API_KEY` | 必选 | Tavily 的密钥 | `tvly-xxxxx`
  |  **注册为 Github App 的 env** |
  | `X_GITHUB_APP_ID` | 可选 |  注册为 Github App 时，APPID | `123456`
  | `X_GITHUB_APPS_CLIENT_ID` | 可选 | 注册为 Github App 时，APP 的 Client ID | `Iv1.xxxxxxx`
  | `X_GITHUB_APPS_CLIENT_SECRET` | 可选 |  注册为 Github App 时，APP 的 Client 密钥 | `xxxxxxxx`
  |  **限流配置** |
  | `RATE_LIMIT_ENABLED` | 可选 |  限流配置是否开启 | `True`
  | `RATE_LIMIT_REQUESTS` | 可选 | 限流的请求数量 | `100`
  | `RATE_LIMIT_DURATION` | 可选 |  限流的统计时长，单位为分钟 | `1`



  > PeterCat 使用 yarn 作为包管理器

  ```bash
  git clone https://github.com/petercat-ai/petercat.git


  yarn run bootstrap


  yarn run client


  yarn run assistant


  yarn run server


  yarn run client:server


  yarn run assistant:server


  cd assistant
  yarn run build
  npm publish


  yarn run build:docker


  yarn run build:pypi
  yarn run publish:pypi

  ```




  请把您的项目地址，使用场景，使用频率等信息发送至 [petercat.assistant@gmail.com ](petercat.assistant@gmail.com)




  猫猫还在养成阶段，难免有些 “小脾气”，遇到问题请对它宽容一些，可以通过以下两种途径告知铲屎官：


  * [提交 Issue](https://github.com/petercat-ai/petercat/issues/new/choose)
  *  [Discussions](https://github.com/petercat-ai/petercat/discussions) 提问



  ![https://github.com/petercat-ai/petercat/graphs/contributors](https://contrib.rocks/image?repo=petercat-ai/petercat)



  [Ant Design](https://ant.design/)



  MIT@[PeterCat](https://github.com/petercat-ai/petercat/blob/main/LICENSE)


pkgId: f229114a395781989f67a9bf8e849054c1cb55417a609bb7c6479d85cae94ac8
name: python-petpropy-help
arch: noarch
version: 1.0.4
epoch: 0
release: 1
summary: Development documents and examples for petpropy
url: https://github.com/EverJRamosI/petpropy
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-petpropy-1.0.4-1.src.rpm
location_href: Packages/python-petpropy-help-1.0.4-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
  <img src="https://raw.githubusercontent.com/EverJRamosI/petpropy/main/docs/images/PETPROPY.png" width="250">
  </h1>

  ![stars](https://img.shields.io/github/stars/EverJRamosI/petpropy)
  ![forks](https://img.shields.io/github/forks/EverJRamosI/petpropy)
  ![watchers](https://img.shields.io/github/watchers/EverJRamosI/petpropy)
  ![license](https://img.shields.io/github/license/EverJRamosI/petpropy)
  ![issues](https://img.shields.io/github/issues/EverJRamosI/petpropy)




  PetProPy is the fundamental package for petroleum, chemical engineering, and other similar industries.
  This package is useful for determining the Physical Properties of Gas, Oil, and Water.



  - [Installation](#installation)
  - [Usage](#usage)
  - [Theory](#theory)
  - [Dependencies](#dependencies)
  - [License](#license)


  You can install [PetProPy](https://github.com/EverJRamosI/petpropy/tree/main/petpropy) using pip:
  ```bash
  pip install petpropy
  ```


  Here is a quick example of how to use PetProPy to calculate the compressibility factor of gas at a given temperature and pressure:

  **INPUT**
  ```python
  import matplotlib.pyplot as plt
  import numpy as np
  from petpropy import z_g

  pressures = np.arange(500, 10500, 500)
  temperature = 654
  temp_critica = 485.9
  pres_critica = 680

  z_factor = z_g.dranchuk_purvis_robinson(pressures, temperature,pres_critica, temp_critica)
  print(z_factor)

  plt.plot(pressures, z_factor)
  plt.xlabel('Pressures')
  plt.ylabel('Z Factor')
  plt.show()
  ```
  **OUTPUT**
  ```bash
  [0.89438476 0.78880765 0.7035361  0.6662592  0.67374447 0.70713281
   0.75391071 0.80757742 0.86484302 0.92400223 0.98413323 1.04471578
   1.10544521 1.16613807 1.22668188 1.28700724 1.34707163 1.40684971
   1.46632734 1.52549774]
  ```
  ![Z Factor](https://raw.githubusercontent.com/EverJRamosI/petpropy/main/docs/images/output.png)
  > Pressures vs Z Factor (***[FOR MORE INFORMATION](https://github.com/EverJRamosI/petpropy/tree/main/tests)***)


  In the analysis of reservoir behavior, calculation of reserves and equipment design, knowledge of the physical properties of fluids is required.
  The set of tests necessary to determine these properties is called Pressure-Volume-Temperature (PVT) analysis, and consists of determining the relationships between pressure, volume and temperature for a particular mixture of hydrocarbons (liquids and gases).

  <details>
  <summary>
  Click to expand the theory section
  </summary>


  The properties of gases are calculated using the different correlations, for example:
  - **Weight Molecular Gas**
  - **Specific Gravity Gas**
  - **Pseudocritical Properties Gas**
    - Kay W.D.
    - Stewart W.F., Burkhardt S.F. & Voo D.
    - Brown G.G., Katz D.L., Oberfell G.G. & Alden R.C.
  - **Gas Compressibility Factor Z**
    - Correction of Whichert & Aziz
    - Standing M.B. & Katz D.L.
    - Papay J.
    - Hall K.R. & Yarborough L.
    - Brill J.P. & Beggs H.D.
    - Dranchuk P.M., Purvis R.A. & Robinson D.B
    - Dranchuk P.M. & Abou-Kassem J.H.
    - Gopal V.N.
  - **Gas Volumetric Factor**
  - **Gas Compressibility**
  - **Gas Viscosity**
    - Lee A.L., Gonzalez M.H. & Eakin B.E.
  - **Gas Density**

  The properties of oils are calculated using the different correlations, for example:
  - **Specific Gravity Oil**
  - **Bubble Pressure**
    - Standing M.B.
    - Lasater J.A.
    - Vazquez M.E. & Beggs H.D.
    - Glaso O.
    - TOTAL C.F.P.
    - Al-Marhoun M.A.
    - Dokla M.E. & Osman M.E.
    - Petrosky G.E. & Farshad F.F.
    - Kartoatmodjo T. & Schmidt Z.
  - **Solution Gas-Oil Ratio**
    - Standing M.B.
    - Lasater J.A.
    - Vazquez M.E. & Beggs H.D.
    - Glaso O.
    - TOTAL C.F.P.
    - Al-Marhoun M.A.
    - Dokla Petrosky G.E. & Farshad F.F.
    - Kartoatmodjo T. & Schmidt Z.
  - **Oil Volumetric Factor**
    - Standing M.B.
    - Vazquez M.E. & Beggs H.D.
    - Glaso O.
    - TOTAL C.F.P.
    - Al-Marhoun M.A.
    - Dokla M.E. & Osman M.E.
    - Petrosky G.E. & Farshad F.F.
    - Kartoatmodjo T. & Schmidt Z.
  - **Total Volumetric Factor**
    - Glaso O.
    - Al-Marhoun M.A.
  - **Oil Compressibility**
    - Vazquez M.E. & Beggs H.D.
    - Petrosky G.E. & Farshad F.F.
    - Kartoatmodjo T. & Schmidt Z.
    - McCain W.D., Rollins J.B. & Villena-Lanzi A.J.
  - **Oil Viscosity**
    - **Dead Oil Viscosity**
      - Beal C.
      - Beggs H.B. & Robinson J.R.
      - Glaso O.
      - Egbogah E.O.
      - Kartoatmodjo T. & Schmidt Z.
    - **Saturated Oil Viscosity**
      - Chew J.N. & Connally C.A.
      - Beggs H.D. & Robinson J.R.
      - Kartoatmodjo T. & Schmidt Z.
    - **Unsaturated Oil Viscosity**
      - Beal C.
      - Vazquez M.E. & Beggs H.D.
      - Kartoatmodjo T. & Schmidt Z.
  - **Oil Density**
  - **Gas-Oil Interfacial Tension**
    - Baker O. & Swerdloff W.

  - **Solution Gas-Water Ratio**
    - Culberson O.L. & McKetta J.J.
    - McCoy R.L.
  - **Water Volumetric Factor**
    - McCain W.D.
    - McCoy R.L.
  - **Water Compressibility**
    - Dodson C.R. & Standing M.B.
    - Osif T.L.
    - Ramey H.J.
  - **Water Viscosity**
    - Van Wingen N.
    - Matthews C.S. & Russel D.G.
    - McCain W.D.
    - McCoy R.L.
  - **Water Density**
    - McCain W.D.
  - **Gas-Water Interfacial Tension**
    - Jennings H.Y. & Newman G.H.

  </details>


  PetProPy requires the following Python (=>3.12) libraries:
  1. NumPy
  2. Pandas

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


  This project is licensed under the GNU Lesser General Public License v3.0 - see the [LICENSE](https://github.com/EverJRamosI/petpropy/blob/main/LICENSE) file for details.


  For detailed API documentation, please refer to the [official documentation](https://github.com/EverJRamosI/petpropy).

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


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

  Pewlib is a library for importing, processing and exporting LA-ICP-MS data.
  Currently exports from Agilent, Thermo and PerkinElmer software is supported, as well as delimited text images.



  Pewlib is availble on PyPI and installable via pip.

  ```pip install pewlib```



  Documenation is available at <https://djdt.github.io/pewlib>.

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


pkgId: 9530261fe003d355e9e56d981dd70b7fda9a400569087a135b4b2f816bf9c8c1
name: python-pex-help
arch: noarch
version: 2.27.0
epoch: 0
release: 1
summary: Development documents and examples for pex
url: https://github.com/pex-tool/pex
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pex-2.27.0-1.src.rpm
location_href: Packages/python-pex-help-2.27.0-1.noarch.rpm
checksum_type: sha256
description:
  pex is a library for generating .pex (Python EXecutable) files which are
  executable Python environments in the spirit of `virtualenvs <http://virtualenv.org>`_.
  pex is an expansion upon the ideas outlined in
  `PEP 441 <https://peps.python.org/pep-0441/>`_
  and makes the deployment of Python applications as simple as ``cp``.  pex files may even
  include multiple platform-specific Python distributions, meaning that a single pex file
  can be portable across Linux and OS X.
  pex files can be built using the ``pex`` tool.  Build systems such as `Pants
  <http://pantsbuild.org/>`_, `Buck <http://facebook.github.io/buck/>`_, and  `{py}gradle <https://github.com/linkedin/pygradle>`_  also
  support building .pex files directly.
  Still unsure about what pex does or how it works?  Watch this quick lightning
  talk: `WTF is PEX? <http://www.youtube.com/watch?v=NmpnGhRwsu0>`_.
  pex is licensed under the Apache2 license.


pkgId: 4bc93c0b2b3400d52fbbc6658cdbff4bf99603575885ad43c983c9e122eda2f0
name: python-peyes-help
arch: noarch
version: 0.0.9.2
epoch: 0
release: 1
summary: Development documents and examples for peyes
url: https://github.com/huji-hcnl/pEYES
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-peyes-0.0.9.2-1.src.rpm
location_href: Packages/python-peyes-help-0.0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  pEYES is a Python package that enables researchers to perform robust, quantitative comparisons of eye-tracking
  segmentation algorithms. It provides implementations of several widely used algorithms and allows users to evaluate
  their performance against ground-truth, human-annotated datasets. The package simplifies the process of selecting an
  optimal algorithm by offering over 20 metrics to quantify performance, enhancing analysis reliability and reproducibility.


  pEYES offers several core functionalities designed to facilitate the processing, analysis, and comparison of
  eye-tracking data:
  - **Downloading & Parsing Datasets**: Provides functions to easily download and parse publicly available,
  human-annotated eye-tracking datasets, streamlining the setup process for benchmarking algorithms.
  - **Configuring & Running Detection Algorithms**: Allows users to configure various eye-tracking segmentation algorithms
  and apply them to either the built-in datasets or their own custom data.
  - **Algorithm Comparison & Analysis**: Offers tools to analyze the results of detection algorithms, compare their
  performance against human-annotated ground-truth data, or evaluate differences between multiple algorithms.
  - **Visualization Tools**: Includes visualization capabilities, such as generating fixation heatmaps and saccade
  trajectories, to help users intuitively interpret the results of different detection algorithms.

  This functionality makes pEYES a versatile tool for researchers aiming to enhance the accuracy and reliability of their
  eye-tracking data analysis.



  This package has been created and tested with python ```3.12```.

  To install this package as a user, use
  ```angular2html
  pip install peyes
  ```
  To install this package as a developer, clone the package from GitHub and run the following commands:
  ```angular2html
  python -m venv env
  git pull
  pip install -e .
  git checkout -b dev
  ```


  This package is intended for scientific use, and is designed to be easy to use for anyone with basic python knowledge.
  Most of the functions in this package are documented, and can be accessed by running:
  ```angular2html
  import peyes
  help(peyes)
  ```
  For more detailed information, please refer to the user tutorials provided in the `docs` directory of this repository.


  This package is distributed under the MIT License, but some of the datasets & detection algorithms that are implemented
  in this package are distributed under different licenses. Please refer to the documentation of the specific dataset or
  detection algorithm for more information.

  If you use this package in your research, please cite it as follows:
  ```angular2html

  ```

  If you use a specific dataset or detection algorithm that is implemented in this package, please also cite the original
  authors of that dataset or detection algorithm. This information, like the license, can be found in the documentation
  of the specific dataset or detection algorithm.


  We are grateful for the support of the [Center for Interdisciplinary Data Science Research (CIDR)](https://cidr.huji.ac.il/) at the [Hebrew University of Jerusalem](https://new.huji.ac.il/). In particular, we would like to thank Haimasree Bhattacharya from CIDR for her contributions.


pkgId: 2531d22d15bc821695507957fed727b28d618503dc923a89ec763e75b5992dc1
name: python-pg-upsert-help
arch: noarch
version: 1.4.4
epoch: 0
release: 1
summary: Development documents and examples for pg-upsert
url: https://pg-upsert.readthedocs.io
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pg-upsert-1.4.4-1.src.rpm
location_href: Packages/python-pg-upsert-help-1.4.4-1.noarch.rpm
checksum_type: sha256
description:
  [![ci/cd](https://github.com/geocoug/pg_upsert/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/geocoug/pg_upsert/actions/workflows/ci-cd.yml)
  [![Documentation Status](https://readthedocs.org/projects/pg-upsert/badge/?version=latest)](https://pg-upsert.readthedocs.io/en/latest/?badge=latest)
  [![PyPI Latest Release](https://img.shields.io/pypi/v/pg_upsert.svg)](https://pypi.org/project/pg_upsert/)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/pg_upsert.svg?label=pypi%20downloads)](https://pypi.org/project/pg_upsert/)
  [![Python Version Support](https://img.shields.io/pypi/pyversions/pg_upsert.svg)](https://pypi.org/project/pg_upsert/)

  **pg_upsert** is a Python package that provides a method to *interactively* update and insert (upsert) rows of a base table or base tables from the staging table(s) of the same name. The package is designed to work exclusively with PostgreSQL databases.

  The program will perform initial table checks in the form of *not-null*, *primary key*, *foreign key*, and *check constraint* checks. If any of these checks fail, the program will exit with an error message. If all checks pass, the program will display the number of rows to be inserted and updated, and ask for confirmation before proceeding (when the `interactive` flag is set to `True`). If the user confirms, the program will perform the upserts and display the number of rows inserted and updated. If the user does not confirm, the program will exit without performing any upserts.



  This project was created using inspiration from [ExecSQL](https://execsql.readthedocs.io/en/latest/index.html) and the example script [`pg_upsert.sql`](https://osdn.net/projects/execsql-upsert/). The goal of this project is to provide a Python implementation of `pg_upsert.sql` without the need for ExecSQL.



  A sample database is provided in the [tests/data.sql](./tests/data.sql) file and can be used to test the functionality of the `pg_upsert` package. See the [Running Tests Locally](#running-tests-locally) section for more information on how to set up the test database locally with Docker.



  Run PgUpsert using a URI:

  ```python
  import logging

  from pg_upsert import PgUpsert

  logger = logging.getLogger("pg_upsert")
  logger.setLevel(logging.INFO)
  logger.addHandler(logging.StreamHandler())


  PgUpsert(
      uri="postgresql://user@localhost:5432/database", # Note the missing password. pg_upsert will prompt for the password.
      encoding="utf-8",
      tables=("genres", "publishers", "books", "authors", "book_authors"),
      stg_schema="staging",
      base_schema="public",
      do_commit=True,
      upsert_method="upsert",
      interactive=True,
      exclude_cols=("rev_user", "rev_time", "created_at", "updated_at"),
      exclude_null_check_cols=("rev_user", "rev_time", "created_at", "updated_at", "alias"),
  ).run()
  ```

  Run PgUpsert using an existing connection:

  ```py
  import logging

  import psycopg2
  from pg_upsert import PgUpsert

  logger = logging.getLogger("pg_upsert")
  logger.setLevel(logging.INFO)
  logger.addHandler(logging.StreamHandler())

  conn = psycopg2.connect(
      host="localhost",
      port=5432,
      dbname="database",
      user="user",
      password="password",
  )

  PgUpsert(
      conn=conn,
      encoding="utf-8",
      tables=("genres", "publishers", "books", "authors", "book_authors"),
      stg_schema="staging",
      base_schema="public",
      do_commit=True,
      upsert_method="upsert",
      interactive=True,
      exclude_cols=("rev_user", "rev_time", "created_at", "updated_at"),
      exclude_null_check_cols=("rev_user", "rev_time", "created_at", "updated_at", "alias"),
  ).run()
  ```



  `pg_upsert` can be run from the command line. There are two key ways to run `pg_upsert` from the command line: using a configuration file or using command line arguments.

  > [!IMPORTANT]
  > If the user specifies a configuration file **and** command line arguments, the configuration file will override any command line arguments specified.



  Running `pg_upsert --help` will display the following help message:

  ```txt
  usage: pg_upsert [--help] [--version] [--debug] [--docs] [-q] [-l LOGFILE] [-e EXCLUDE_COLUMNS] [-n NULL_COLUMNS] [-c] [-i] [-m {upsert,update,insert}] [-h HOST] [-p PORT] [-d DATABASE] [-u USER] [-s STAGING_SCHEMA] [-b BASE_SCHEMA]
                   [--encoding ENCODING] [-f CONFIG_FILE] [-t TABLES [TABLES ...]]

  Run not-NULL, Primary Key, Foreign Key, and Check Constraint checks on staging tables then update and insert (upsert) data from staging tables to base tables.

  options:
    --help                show this help message and exit
    --version             show program's version number and exit
    --debug               display debug output
    --docs                open the documentation in a web browser
    -q, --quiet           suppress all console output
    -l LOGFILE, --logfile LOGFILE
                          write log to LOGFILE
    -e EXCLUDE_COLUMNS, --exclude-columns EXCLUDE_COLUMNS
                          comma-separated list of columns to exclude from null checks
    -n NULL_COLUMNS, --null-columns NULL_COLUMNS
                          comma-separated list of columns to exclude from null checks
    -c, --commit          commit changes to database
    -i, --interactive     display interactive GUI of important table information
    -m {upsert,update,insert}, --upsert-method {upsert,update,insert}
                          method to use for upsert
    -h HOST, --host HOST  database host
    -p PORT, --port PORT  database port
    -d DATABASE, --database DATABASE
                          database name
    -u USER, --user USER  database user
    -s STAGING_SCHEMA, --staging-schema STAGING_SCHEMA
                          staging schema name
    -b BASE_SCHEMA, --base-schema BASE_SCHEMA
                          base schema name
    --encoding ENCODING   encoding of the database
    -f CONFIG_FILE, --config-file CONFIG_FILE
                          path to configuration yaml file
    -t TABLES [TABLES ...], --tables TABLES [TABLES ...]
                          table name(s)
  ```

  An example of running `pg_upsert` from the command line is shown below:

  ```sh
  pg_upsert -l pg_upsert.log -h localhost -p 5432 -d postgres -u postgres -s staging -b public -t authors publishers books book_authors genres
  ```



  To use a configuration file, create a YAML file with the format below. This example is also provided in the [pg_upsert.example.yaml](./pg_upsert.example.yaml) file. The configuration file can be passed to `pg_upsert` using the `-f` or `--config-file` flag.

  ```yaml
  debug: false
  quiet: false
  commit: false
  interactive: false
  upsert_method: "upsert"
  logfile: "pg_upsert.log"
  host: "localhost"
  port: 5432
  user: "postgres"
  database: "postgres"
  staging_schema: "staging"
  base_schema: "public"
  encoding: "utf-8"
  tables:
    - "authors"
    - "publishers"
    - "books"
    - "book_authors"
    - "genres"
  exclude_columns:
    - "alias"
    - "rev_time"
    - "rev_user"
  null_columns:
    - "alias"
    - "created_at"
    - "updated_at"
  ```

  Then, run `pg_upsert -f pg_upsert.yaml`.



  Pull the latest image from the GitHub Container Registry (GHCR) using the following command:

  ```sh
  docker pull ghcr.io/geocoug/pg_upsert:latest
  ```

  Once the image is pulled, you can run the image using either of the [cli](#cli) options. Below is an example:

  ```sh
  docker run -it --rm ghcr.io/geocoug/pg_upsert:latest -v $(pwd):/app pg_upsert --help
  ```

  > [!NOTE]
  > The `-v` flag is used to mount the current directory to the `/app` directory in the container. This is useful for mounting configuration files or retaining log files.




  1. Fork the repository
  2. Create a new branch (`git checkout -b feature-branch`)
  3. Create a Python virtual environment (`python -m venv .venv`)
  4. Activate the virtual environment (`source .venv/bin/activate`)
  5. Install dependencies (`pip install -r requirements.txt`)
  6. Install pre-commit hooks (`python -m pre-commit install --install-hooks`)
  7. Make your changes and run tests (`make test`)
  8. Push your changes to the branch (`git push origin feature-branch`)
  9. Create a pull request



  Running tests locally requires a PostgreSQL database. The easiest way to set up a PostgreSQL database is to use Docker. The following command will create a PostgreSQL database called `dev` with the user `docker` and password `docker`.

  ```sh
  docker run --name postgres -e POSTGRES_USER=docker -e POSTGRES_PASSWORD=docker -e POSTGRES_DB=dev -p 5432:5432 -d postgres
  ```

  Once initialized, import the test data by running the following command.

  ```sh
  docker exec -i postgres psql -U docker -d dev < tests/data.sql
  ```

  Create a `.env` file in the root directory with the following content, modifying the values as needed.

  ```sh
  POSTGRES_HOST=localhost
  POSTGRES_PORT=5432
  POSTGRES_DB=dev
  POSTGRES_USER=docker
  POSTGRES_PASSWORD=docker
  ```

  Now you can run the tests using `make test`.

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


pkgId: 80f96180f4eaa08930b00984f98ec35c8153263e870a7ee2e529aadcc7741f8b
name: python-pggm-datalab-utils-help
arch: noarch
version: 2.17
epoch: 0
release: 1
summary: Development documents and examples for pggm-datalab-utils
url: https://pypi.org/project/pggm-datalab-utils/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pggm-datalab-utils-2.17-1.src.rpm
location_href: Packages/python-pggm-datalab-utils-help-2.17-1.noarch.rpm
checksum_type: sha256
description:
  Well-specified utilities from the Datalab of PGGM. Our aim with this package is to provide some tooling to make our lives a bit easier.
  So far the package contains:
  - Database utilities, allowing you to connect to cloud databases using pyodbc in a standard pattern.
  - Helpers around nested lists (flattening and unflattening).
  - Helpers to make working with lists of dictionaries a bit easier so you don't have to resort to Pandas as fast.


  ```python
  from pggm_datalab_utils.db import cursor, query

  bbg_id = 'WOW'

  with cursor('pggm-sql-lre-o.database.windows.net', 'lre') as c:
      data = query(c, 'select sedol, name from portfolio where bbg_id=?', bbg_id)
  ```


pkgId: dd6ef0ad163b613e75d403729646f28af999e4b2e4fa7469a748d11574314ae0
name: python-pglast-debuginfo
arch: aarch64
version: 7.1
epoch: 0
release: 1
summary: Debug information for package python-pglast
url: https://github.com/lelit/pglast
rpm_license: GPLv3+
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-pglast-7.1-1.src.rpm
location_href: Packages/python-pglast-debuginfo-7.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-pglast.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 52827dd0e63a3280ee511da40f9d6efd4dfd53493165b1db05bc0e7b399a7237
name: python-pglast-debugsource
arch: aarch64
version: 7.1
epoch: 0
release: 1
summary: Debug sources for package python-pglast
url: https://github.com/lelit/pglast
rpm_license: GPLv3+
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-pglast-7.1-1.src.rpm
location_href: Packages/python-pglast-debugsource-7.1-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-pglast.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: fbd08375b555ac88fcf896622242b0523555c5db394aaa2066617d7dac94360a
name: python-pgliveapp-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for pgliveapp
url: https://pypi.org/project/pgliveapp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pgliveapp-0.1.0-1.src.rpm
location_href: Packages/python-pgliveapp-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This project is a live plotting application using PyQt6 and pglive. It allows you to create real-time plots with customizable settings.



  - Real-time data plotting
  - Multiple plot support
  - Customizable plot titles and layout
  - UDP socket communication for data input



  To install the required dependencies, run:
  ```sh
  uv add pgliveapp
  ```

  Usage
  To run the application, execute:
  ```sh
  pgliveapp --plots-cnt <number_of_plots> --cols <number_of_columns> --port <port_number> --ip <ip_address>
  ```

  For example:
  ```sh
  pgliveapp --plots-cnt 2 --cols 1 --port 4000 --ip localhost
  ```

  Arguments
  --plots-cnt: Number of plots to display (default: 1)
  --cols: Number of columns in the plot layout (default: 1)
  --port: UDP port to listen for incoming data (default: 4000)
  --ip: IP address to bind the UDP socket (default: localhost)


pkgId: 8b2d34d71961d3d72eba14756b3e81340119722f675ec0aa593b8606750d8d8d
name: python-pgpyui-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for pgpyui
url: https://pypi.org/project/pgpyui/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pgpyui-0.1.3-1.src.rpm
location_href: Packages/python-pgpyui-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  pgpyui is an add-on module for pygame to create a user interface.



  ```
  pip install pgpyui
  ```





  Imports
  ```python
  from pgpyui import button
  import pygame
  ```

  Creating a button
  ```python
  button = button.Button((100, 100), (200, 100), "Some text", func, sprites=["sprites/sprite1.png", "sprites/sprite2.png"])
  ```

  Event handling
  ```python
  button.check_events(event)
  ```

  Drawing
  ```python
  button.draw(window)
  ```



  Imports
  ```python
  from pgpyui import textarea
  import pygame
  ```

  Creating a text area
  ```python
  textarea = textarea.TextArea((200, 100), (100, 100), 20, 15, is_enter=False, font="Arial")
  ```

  Event handling
  ```python
  textarea.check_events(event)
  ```

  Drawing
  ```python
  textarea.draw(window)
  ```

  Information output
  ```python
  text: list[str] = textarea.data_return()
  ```




  Imports
  ```python
  from pgpyui import slider
  import pygame
  ```

  Creating a slider
  ```python
  slider = slider.Slider((200, 100), (100, 100), 100, orientation="True")
  ```

  Event handling
  ```python
  slider.check_events(event)
  ```

  Drawing
  ```python
  slider.draw(window)
  ```

  Information output
  ```python
  prgrs: int = slider.data_return()
  ```




  Imports
  ```python
  from pgpyui import checkbox
  import pygame
  ```

  Creating a checkbox
  ```python
  chkbox = checkbox.CheckBox((100, 100), (50, 50), 3, 75, color=(0, 0, 0), ["passive.png", "active.png"])
  ```

  Event handling
  ```python
  chkbox.check_events(event)
  ```

  Drawing
  ```python
  chkbox.draw(window)
  ```

  Information output
  ```python
  prgrs: list = chkbox.data_return()
  ```




  Imports
  ```python
  from pgpyui import radio
  import pygame
  ```

  Creating a radio-button
  ```python
  radiob = radio.Radio((100, 100), 25, 10, 100)
  ```

  Event handling
  ```python
  radiob.check_events(event)
  ```

  Drawing
  ```python
  radiob.draw(window)
  ```

  Information output
  ```python
  rt: list = radiob.data_return()
  ```





  **Parameters:**

  * `position`: The position of the button.
  * `size`: The size of the button.
  * `text`: The text on the button.
  * `function`: The function to be called when the button is clicked.
  * `sprite`: A sprite to use for the button (optional).



  **Parameters:**

  * `position`: The position of the text area.
  * `size`: The size of the text area.
  * `font_size`: The size of the font.
  * `max_symbols`: The maximum number of symbols that can be entered.
  * `is_enter`: Whether or not the enter key should be allowed.
  * `font`: The name of the font to use (optional).



  **Parameters:**

  * `position`: The position of the slider.
  * `size_block`: The size of the block slider.
  * `len`: Length of slide.
  * `max_symbols`: The maximum number of symbols that can be entered.
  * `orientation`: Horisontal or vertical slider. (optional)



  **Parameters:**

  * `position`: The position of the CheckBox.
  * `size`: The size of the block Checkbox.
  * `num_boxes`: The num of CheckBoxes.
  * `step`: The distance between the boxes.
  * `color`: Color of the box. (optional)
  * `sprites`: Two sprites - the first without a check mark, the second with a check mark. (optional)



  **Parameters:**

  * `position`: The position of the radio-button.
  * `radius`: Radius of radio-button.
  * `num_rb`: The num of radio-buttons.
  * `step`: The distance between the buttons.
  * `color`: Color of the box. (optional)




  MIT



  mixail.vilyukov@icloud.com


pkgId: 9e8ff5e888c9b8c9207554c9a35d3df6a2577bfa65266ddff624b579caf113cf
name: python-pgss-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for pgss
url: https://github.com/masashi2ueda/pgss
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pgss-0.2.0-1.src.rpm
location_href: Packages/python-pgss-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Per-page session state management**: Ensures that session state variables are unique to each page.
  - **Simple API**: Use the same variable names across pages without conflicts.


pkgId: c0cf9384bd14d2189d53cf5f4d6fe080f971c3803ebade46ad9cba960e0c195f
name: python-phc-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for phc
url: https://github.com/lifeomic/phc-sdk-py
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phc-1.0.0-1.src.rpm
location_href: Packages/python-phc-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  The phc-sdk-py is a developer kit for interfacing with the
  [PHC API](https://api.docs.lifeomic.com/) on Python 3.7 and above.



  ![GitHub](https://img.shields.io/github/license/lifeomic/phc-sdk-py.svg?style=for-the-badge)
  ![PyPI status](https://img.shields.io/pypi/status/phc.svg?style=for-the-badge)
  ![Downloads](https://img.shields.io/pypi/dw/phc?style=for-the-badge)
  ![GitHub release](https://img.shields.io/github/release/lifeomic/phc-sdk-py.svg?style=for-the-badge)
  [![Docs](https://img.shields.io/badge/DOCS-PASSING-green?style=for-the-badge)](https://lifeomic.github.io/phc-sdk-py/)
  [![User Guides](https://img.shields.io/badge/DOCS-PASSING-green?style=for-the-badge)](https://devcenter.docs.lifeomic.com/guides/python-sdk)





  - [Python 3](https://www.python.org/download/releases/3.0/) version >= 3.9



  This project is [hosted on GitHub](https://github.com/lifeomic/phc-sdk-py).



  A `Session` needs to be created first that stores the token and account
  information needed to access the PHC API. One can currently using API Key tokens
  generated from the PHC Account, or OAuth tokens generated using the
  [CLI](https://github.com/lifeomic/cli).

  ```python
  from phc import Session

  session = Session(token=<TOKEN VALUE>, account="myaccount")
  ```

  Once a `Session` is created, you can then access the different parts of the
  platform.

  ```python
  from phc.services import Accounts

  accounts = Accounts(session)
  myaccounts = accounts.get_list()
  ```



  We encourage public contributions! Please review
  [CONTRIBUTING.md](CONTRIBUTING.md) and [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)
  for details on our code of conduct and development process.



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



  See the list of
  [contributors](https://github.com/lifeomic/phc-sdk-py/contributors) who
  participate in this project.



  This project is built with the following:

  - [aiohttp](https://aiohttp.readthedocs.io/en/stable/) - Asynchronous HTTP
    Client/Server for asyncio and Python.


pkgId: 20d01b795ffec8f5e3799dc5520366350cdb101d920d51c8eb26b8ab5fdaadfc
name: python-phdu-help
arch: noarch
version: 2.8.7
epoch: 0
release: 1
summary: Development documents and examples for phdu
url: https://github.com/medinajorge/PhD-utils
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phdu-2.8.7-1.src.rpm
location_href: Packages/python-phdu-help-2.8.7-1.noarch.rpm
checksum_type: sha256
description:
  For people that have to compute and store a large variety of data and/or perform statistical inference.



  Don't spend time creating directories, deciding filenames, saving, loading, etc. Decorators `savefig` & `savedata` will do it for you with optimal compression. More info at the `tidypath` [repository](https://github.com/medinajorge/tidypath).


  The module `phdu.resample` allows calls to the `resample` [R package](https://cran.r-project.org/web/packages/resample/resample.pdf).
  - Provides CI and permutation tests.
  - CIs can account narrowness bias, skewness and other errors in CI estimation, as indicated in the [article](https://arxiv.org/abs/1411.5279)
  - Alternatively, use `phdu.stats.bootstrap` for numba-accelerated computation (does not call `resample`).


  Calculate the power for accepting H0 and estimate the needed sample size.
  Function `power_analysis` in `phdu.stats.bootstrap` follows Efron-Tshibirani: An introduction to the bootstrap,  p. 381-384.


  Module `phdu.stats.tests.permutation`.
  - Permutation tests for any statistic.
  - Includes paired and block cases.


  Please check the [example notebook](https://github.com/medinajorge/PhD-utils/blob/master/tests/Example.ipynb).


  [Github pages](https://medinajorge.github.io/PhD-utils/phdu.html)


  - For the R compatible installation first install R:

    ```conda install -c conda-forge r r-essentials r-base```

  - Install with dependencies:

    ```pip install phdu[dependencies]```

    Where `dependencies` can be `base` (recommended), `all`, `r` (needed for `resample` to work), `statsmodels`, `matplotlib` or `plotly`.


pkgId: 363f15c225ba1009f34524fc238acbd837294a294698c2abba2bb2485ae529da
name: python-phenotype2phenopacket-help
arch: noarch
version: 0.6.8
epoch: 0
release: 1
summary: Development documents and examples for phenotype2phenopacket
url: https://pypi.org/project/phenotype2phenopacket/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phenotype2phenopacket-0.6.8-1.src.rpm
location_href: Packages/python-phenotype2phenopacket-help-0.6.8-1.noarch.rpm
checksum_type: sha256
description:
  _Phenotype2Phenopacket_ is a command-line interface (CLI) application for the construction of phenopackets
  from a phenotype annotation file.



  Phenotype2Phenopacket can be installed from PyPi.

  ```shell
  pip install phenotype2phenopacket
  ```



  To convert all OMIM diseases in a phenotype annotation file to disease phenopackets, where all phenotypes are retained:

  ```shell
  p2p convert --phenotype-annotation /path/to/phenotype.hpoa --output-dir /path/to/output-dir
  ```

  To create synthetic patient disease phenopackets, where the dataset is more variable and frequencies are taken
  into account and constrained noise is applied :

  ```shell
  p2p create --phenotype-annotation /path/to/phenotype.hpoa --output-dir /path/to/output-dir
  ```

  You can also limit the number of disease phenopackets converted/created:

  ```shell
  p2p convert --phenotype-annotation /path/to/phenotype.hpoa --output-dir /path/to/output-dir --num-diseases 100
  ```

  Or limit for a specific OMIM disease:

  ```shell
  p2p create --phenotype-annotation /path/to/phenotype.hpoa --output-dir /path/to/output-dir --omim-id OMIM:619340
  ```

  Or limit for a list of OMIM IDs specified in a text file, with each ID separated by a new line:

  ```shell
  p2p create --phenotype-annotation /path/to/phenotype.hpoa --output-dir /path/to/output-dir --omim-id-list /path/to/list.txt
  ```

  To add known gene-to-phenotype relationships to phenopackets:

  ```shell
  p2p add-genes --phenopacket-dir /path/to/synthetic-phenopackets --genes-to-disease /path/to/genes_to_disease.txt --hgnc-data /path/to/hgnc_complete_set.txt --output-dir /path/to/output-dir
  ```

  > **_NOTE:_** To add known gene-to-phenotype the genes_to_disease.txt is expected. It can be downloaded [here](https://hpo.jax.org/data/annotations).


pkgId: fa291cc156bb8bf3e66607186554711c206571098ccf33694da02c460a4e02d6
name: python-phidata-help
arch: noarch
version: 2.7.3
epoch: 0
release: 1
summary: Development documents and examples for phidata
url: https://pypi.org/project/phidata/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phidata-2.7.3-1.src.rpm
location_href: Packages/python-phidata-help-2.7.3-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center" id="top">
    phidata
  </h1>

  <p align="center">
    <a href="https://docs.phidata.com">
      <img src="https://img.shields.io/badge/Read%20the%20Documentation-Click%20Here-green?style=for-the-badge&logo=read-the-docs" alt="Read the Docs">
    </a>
  </p>

  <h3 align="center">
  Build multi-modal Agents with memory, knowledge, tools and reasoning.
  </h3>

  <img
    src="https://github.com/user-attachments/assets/44739d09-2ec4-49b7-bea1-b275afccc592"
    style="border-radius: 8px;"
  />



  **Phidata is a framework for building multi-modal agents**, use phidata to:

  - **Build multi-modal agents with memory, knowledge, tools and reasoning.**
  - **Build teams of agents that can work together to solve problems.**
  - **Chat with your agents using a beautiful Agent UI.**



  ```shell
  pip install -U phidata
  ```



  - [Simple & Elegant](#simple--elegant)
  - [Powerful & Flexible](#powerful--flexible)
  - [Multi-Modal by default](#multi-modal-by-default)
  - [Multi-Agent orchestration](#multi-agent-orchestration)
  - [A beautiful Agent UI to chat with your agents](#a-beautiful-agent-ui-to-chat-with-your-agents)
  - [Agentic RAG built-in](#agentic-rag)
  - [Structured Outputs](#structured-outputs)
  - [Reasoning Agents](#reasoning-agents-experimental)
  - [Monitoring & Debugging built-in](#monitoring--debugging)
  - [Demo Agents](#demo-agents)



  Phidata Agents are simple and elegant, resulting in minimal, beautiful code.

  For example, you can create a web search agent in 10 lines of code, create a file `web_search.py`

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat
  from phi.tools.duckduckgo import DuckDuckGo

  web_agent = Agent(
      model=OpenAIChat(id="gpt-4o"),
      tools=[DuckDuckGo()],
      instructions=["Always include sources"],
      show_tool_calls=True,
      markdown=True,
  )
  web_agent.print_response("Tell me about OpenAI Sora?", stream=True)
  ```

  Install libraries, export your `OPENAI_API_KEY` and run the Agent:

  ```shell
  pip install phidata openai duckduckgo-search

  export OPENAI_API_KEY=sk-xxxx

  python web_search.py
  ```



  Phidata agents can use multiple tools and follow instructions to achieve complex tasks.

  For example, you can create a finance agent with tools to query financial data, create a file `finance_agent.py`

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat
  from phi.tools.yfinance import YFinanceTools

  finance_agent = Agent(
      name="Finance Agent",
      model=OpenAIChat(id="gpt-4o"),
      tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
      instructions=["Use tables to display data"],
      show_tool_calls=True,
      markdown=True,
  )
  finance_agent.print_response("Summarize analyst recommendations for NVDA", stream=True)
  ```

  Install libraries and run the Agent:

  ```shell
  pip install yfinance

  python finance_agent.py
  ```



  Phidata agents support text, images, audio and video.

  For example, you can create an image agent that can understand images and make tool calls as needed, create a file `image_agent.py`

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat
  from phi.tools.duckduckgo import DuckDuckGo

  agent = Agent(
      model=OpenAIChat(id="gpt-4o"),
      tools=[DuckDuckGo()],
      markdown=True,
  )

  agent.print_response(
      "Tell me about this image and give me the latest news about it.",
      images=["https://upload.wikimedia.org/wikipedia/commons/b/bf/Krakow_-_Kosciol_Mariacki.jpg"],
      stream=True,
  )
  ```

  Run the Agent:

  ```shell
  python image_agent.py
  ```



  Phidata agents can work together as a team to achieve complex tasks, create a file `agent_team.py`

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat
  from phi.tools.duckduckgo import DuckDuckGo
  from phi.tools.yfinance import YFinanceTools

  web_agent = Agent(
      name="Web Agent",
      role="Search the web for information",
      model=OpenAIChat(id="gpt-4o"),
      tools=[DuckDuckGo()],
      instructions=["Always include sources"],
      show_tool_calls=True,
      markdown=True,
  )

  finance_agent = Agent(
      name="Finance Agent",
      role="Get financial data",
      model=OpenAIChat(id="gpt-4o"),
      tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True)],
      instructions=["Use tables to display data"],
      show_tool_calls=True,
      markdown=True,
  )

  agent_team = Agent(
      team=[web_agent, finance_agent],
      model=OpenAIChat(id="gpt-4o"),
      instructions=["Always include sources", "Use tables to display data"],
      show_tool_calls=True,
      markdown=True,
  )

  agent_team.print_response("Summarize analyst recommendations and share the latest news for NVDA", stream=True)
  ```

  Run the Agent team:

  ```shell
  python agent_team.py
  ```



  Phidata provides a beautiful UI for interacting with your agents. Let's take it for a spin, create a file `playground.py`

  ![agent_playground](https://github.com/user-attachments/assets/546ce6f5-47f0-4c0c-8f06-01d560befdbc)

  > [!NOTE]
  > Phidata does not store any data, all agent data is stored locally in a sqlite database.

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat
  from phi.storage.agent.sqlite import SqlAgentStorage
  from phi.tools.duckduckgo import DuckDuckGo
  from phi.tools.yfinance import YFinanceTools
  from phi.playground import Playground, serve_playground_app

  web_agent = Agent(
      name="Web Agent",
      model=OpenAIChat(id="gpt-4o"),
      tools=[DuckDuckGo()],
      instructions=["Always include sources"],
      storage=SqlAgentStorage(table_name="web_agent", db_file="agents.db"),
      add_history_to_messages=True,
      markdown=True,
  )

  finance_agent = Agent(
      name="Finance Agent",
      model=OpenAIChat(id="gpt-4o"),
      tools=[YFinanceTools(stock_price=True, analyst_recommendations=True, company_info=True, company_news=True)],
      instructions=["Use tables to display data"],
      storage=SqlAgentStorage(table_name="finance_agent", db_file="agents.db"),
      add_history_to_messages=True,
      markdown=True,
  )

  app = Playground(agents=[finance_agent, web_agent]).get_app()

  if __name__ == "__main__":
      serve_playground_app("playground:app", reload=True)
  ```


  Authenticate with phidata by running the following command:

  ```shell
  phi auth
  ```

  or by exporting the `PHI_API_KEY` for your workspace from [phidata.app](https://www.phidata.app)

  ```bash
  export PHI_API_KEY=phi-***
  ```

  Install dependencies and run the Agent Playground:

  ```
  pip install 'fastapi[standard]' sqlalchemy

  python playground.py
  ```

  - Open the link provided or navigate to `http://phidata.app/playground`
  - Select the `localhost:7777` endpoint and start chatting with your agents!

  <video
    src="https://github.com/user-attachments/assets/3a2ff93c-3d2d-4f1a-9573-eee25542e5c4"
    style="border-radius: 8px;"
  />



  We were the first to pioneer Agentic RAG using our Auto-RAG paradigm. With Agentic RAG (or auto-rag), the Agent can search its knowledge base (vector db) for the specific information it needs to achieve its task, instead of always inserting the "context" into the prompt.

  This saves tokens and improves response quality. Create a file `rag_agent.py`

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat
  from phi.embedder.openai import OpenAIEmbedder
  from phi.knowledge.pdf import PDFUrlKnowledgeBase
  from phi.vectordb.lancedb import LanceDb, SearchType


  knowledge_base = PDFUrlKnowledgeBase(
      urls=["https://phi-public.s3.amazonaws.com/recipes/ThaiRecipes.pdf"],
      
      vector_db=LanceDb(
          table_name="recipes",
          uri="tmp/lancedb",
          search_type=SearchType.vector,
          embedder=OpenAIEmbedder(model="text-embedding-3-small"),
      ),
  )

  knowledge_base.load()

  agent = Agent(
      model=OpenAIChat(id="gpt-4o"),
      
      knowledge=knowledge_base,
      show_tool_calls=True,
      markdown=True,
  )
  agent.print_response("How do I make chicken and galangal in coconut milk soup", stream=True)
  ```

  Install libraries and run the Agent:

  ```shell
  pip install lancedb tantivy pypdf sqlalchemy

  python rag_agent.py
  ```



  Agents can return their output in a structured format as a Pydantic model.

  Create a file `structured_output.py`

  ```python
  from typing import List
  from pydantic import BaseModel, Field
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat


  class MovieScript(BaseModel):
      setting: str = Field(..., description="Provide a nice setting for a blockbuster movie.")
      ending: str = Field(..., description="Ending of the movie. If not available, provide a happy ending.")
      genre: str = Field(..., description="Genre of the movie. If not available, select action, thriller or romantic comedy.")
      name: str = Field(..., description="Give a name to this movie")
      characters: List[str] = Field(..., description="Name of characters for this movie.")
      storyline: str = Field(..., description="3 sentence storyline for the movie. Make it exciting!")


  json_mode_agent = Agent(
      model=OpenAIChat(id="gpt-4o"),
      description="You write movie scripts.",
      response_model=MovieScript,
  )

  structured_output_agent = Agent(
      model=OpenAIChat(id="gpt-4o"),
      description="You write movie scripts.",
      response_model=MovieScript,
      structured_outputs=True,
  )

  json_mode_agent.print_response("New York")
  structured_output_agent.print_response("New York")
  ```

  - Run the `structured_output.py` file

  ```shell
  python structured_output.py
  ```

  - The output is an object of the `MovieScript` class, here's how it looks:

  ```shell
  MovieScript(
  │   setting='A bustling and vibrant New York City',
  │   ending='The protagonist saves the city and reconciles with their estranged family.',
  │   genre='action',
  │   name='City Pulse',
  │   characters=['Alex Mercer', 'Nina Castillo', 'Detective Mike Johnson'],
  │   storyline='In the heart of New York City, a former cop turned vigilante, Alex Mercer, teams up with a street-smart activist, Nina Castillo, to take down a corrupt political figure who threatens to destroy the city. As they navigate through the intricate web of power and deception, they uncover shocking truths that push them to the brink of their abilities. With time running out, they must race against the clock to save New York and confront their own demons.'
  )
  ```



  Reasoning helps agents work through a problem step-by-step, backtracking and correcting as needed. Create a file `reasoning_agent.py`.

  ```python
  from phi.agent import Agent
  from phi.model.openai import OpenAIChat

  task = (
      "Three missionaries and three cannibals need to cross a river. "
      "They have a boat that can carry up to two people at a time. "
      "If, at any time, the cannibals outnumber the missionaries on either side of the river, the cannibals will eat the missionaries. "
      "How can all six people get across the river safely? Provide a step-by-step solution and show the solutions as an ascii diagram"
  )

  reasoning_agent = Agent(model=OpenAIChat(id="gpt-4o"), reasoning=True, markdown=True, structured_outputs=True)
  reasoning_agent.print_response(task, stream=True, show_full_reasoning=True)
  ```

  Run the Reasoning Agent:

  ```shell
  python reasoning_agent.py
  ```

  > [!WARNING]
  > Reasoning is an experimental feature and will break ~20% of the time. **It is not a replacement for o1.**
  >
  > It is an experiment fueled by curiosity, combining COT and tool use. Set your expectations very low for this initial release. For example: It will not be able to count ‘r’s in ‘strawberry’.



  The Agent Playground includes a few demo agents that you can test with. If you have recommendations for other demo agents, please let us know in our [community forum](https://community.phidata.com/).

  ![demo_agents](https://github.com/user-attachments/assets/329aa15d-83aa-4c6c-88f0-2b0eda257198)





  Phidata comes with built-in monitoring. You can set `monitoring=True` on any agent to track sessions or set `PHI_MONITORING=true` in your environment.

  > [!NOTE]
  > Run `phi auth` to authenticate your local account or export the `PHI_API_KEY`

  ```python
  from phi.agent import Agent

  agent = Agent(markdown=True, monitoring=True)
  agent.print_response("Share a 2 sentence horror story")
  ```

  Run the agent and monitor the results on [phidata.app/sessions](https://www.phidata.app/sessions)

  ```shell



  python monitoring.py
  ```

  View the agent session on [phidata.app/sessions](https://www.phidata.app/sessions)

  ![Agent Session](https://github.com/user-attachments/assets/45f3e460-9538-4b1f-96ba-bd46af3c89a8)



  Phidata also includes a built-in debugger that will show debug logs in the terminal. You can set `debug_mode=True` on any agent to track sessions or set `PHI_DEBUG=true` in your environment.

  ```python
  from phi.agent import Agent

  agent = Agent(markdown=True, debug_mode=True)
  agent.print_response("Share a 2 sentence horror story")
  ```

  ![debugging](https://github.com/user-attachments/assets/c933c787-4a28-4bff-a664-93b29360d9ea)



  - Read the docs at <a href="https://docs.phidata.com" target="_blank" rel="noopener noreferrer">docs.phidata.com</a>
  - Post your questions on the [community forum](https://community.phidata.com/)
  - Chat with us on <a href="https://discord.gg/4MtYHHrgA8" target="_blank" rel="noopener noreferrer">discord</a>





  <details>

  <summary>Show code</summary>

  The `PythonAgent` can achieve tasks by writing and running python code.

  - Create a file `python_agent.py`

  ```python
  from phi.agent.python import PythonAgent
  from phi.model.openai import OpenAIChat
  from phi.file.local.csv import CsvFile

  python_agent = PythonAgent(
      model=OpenAIChat(id="gpt-4o"),
      files=[
          CsvFile(
              path="https://phidata-public.s3.amazonaws.com/demo_data/IMDB-Movie-Data.csv",
              description="Contains information about movies from IMDB.",
          )
      ],
      markdown=True,
      pip_install=True,
      show_tool_calls=True,
  )

  python_agent.print_response("What is the average rating of movies?")
  ```

  - Run the `python_agent.py`

  ```shell
  python python_agent.py
  ```

  </details>



  <details>

  <summary>Show code</summary>

  The `DuckDbAgent` can perform data analysis using SQL.

  - Create a file `data_analyst.py`

  ```python
  import json
  from phi.model.openai import OpenAIChat
  from phi.agent.duckdb import DuckDbAgent

  data_analyst = DuckDbAgent(
      model=OpenAIChat(model="gpt-4o"),
      markdown=True,
      semantic_model=json.dumps(
          {
              "tables": [
                  {
                      "name": "movies",
                      "description": "Contains information about movies from IMDB.",
                      "path": "https://phidata-public.s3.amazonaws.com/demo_data/IMDB-Movie-Data.csv",
                  }
              ]
          },
          indent=2,
      ),
  )

  data_analyst.print_response(
      "Show me a histogram of ratings. "
      "Choose an appropriate bucket size but share how you chose it. "
      "Show me the result as a pretty ascii diagram",
      stream=True,
  )
  ```

  - Install duckdb and run the `data_analyst.py` file

  ```shell
  pip install duckdb

  python data_analyst.py
  ```

  </details>





  We're an open-source project and welcome contributions, please read the [contributing guide](https://github.com/phidatahq/phidata/blob/main/CONTRIBUTING.md) for more information.



  - If you have a feature request, please open an issue or make a pull request.
  - If you have ideas on how we can improve, please create a discussion.



  Phidata logs which model an agent used so we can prioritize features for the most popular models.

  You can disable this by setting `PHI_TELEMETRY=false` in your environment.

  <p align="left">
    <a href="#top">⬆️ Back to Top</a>
  </p>


pkgId: 7dc3df698c75c80dda997d99a02b6f047992e5bb57b3f398cf6f1c9a8d3d7256
name: python-phiml-help
arch: noarch
version: 1.11.0
epoch: 0
release: 1
summary: Development documents and examples for phiml
url: https://github.com/tum-pbs/PhiML
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phiml-1.11.0-1.src.rpm
location_href: Packages/python-phiml-help-1.11.0-1.noarch.rpm
checksum_type: sha256
description:
  Due to a PyPI issue, the description cannot be displayed. Please visit the homepage at https://github.com/tum-pbs/PhiML


pkgId: 8eee4b7208a9558a38157fc7f3cc448cf0f14f757f150462a053b7e150be5375
name: python-photos-where-help
arch: noarch
version: 2.2
epoch: 0
release: 1
summary: Development documents and examples for photos-where
url: https://github.com/visgean/where
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-photos-where-2.2-1.src.rpm
location_href: Packages/python-photos-where-help-2.2-1.noarch.rpm
checksum_type: sha256
description:
  This scripts reads EXIF data from your photos and generates CSV file or Pandas dataframe with day by day location in terms of country.

  It relies on my package [exif2pandas](https://github.com/Visgean/exif2pandas/). It uses [reverse-geocoder](https://github.com/thampiman/reverse-geocoder) to convert GPS data to country codes. That module uses a csv file with 150k cities and then uses nearest neighbour algorithm to find the position of each gps data point. This sometimes does not work in border regions so if you are seeing bad data the easiest fix is to copy [cities.csv](https://github.com/Visgean/where/blob/main/src/cities.csv) and add your village etc.

  In case some of your photos contain bad gps data that show that you have been to countries where you have never been you can use ``ignore_countries`` argument.



  ![image-20230727131720726](assets/image-20230727131720726.png)

  Generated world map with colored regions according to how many days you have spent in the country.



  ![image-20230727131816623](assets/image-20230727131816623.png)



  ```
  id,from,to,days,country,country_code
  4,2015-11-07,2015-11-09,1,Scotland,GB
  5,2015-11-09,2015-12-12,32,Praha,CZ
  6,2015-12-12,2015-12-12,0,Budapest,HU
  7,2015-12-12,2015-12-12,0,Praha,CZ
  8,2015-12-12,2015-12-15,2,Budapest,HU

  ```

  note that the country column is usually wrong - this is because the cities.csv is not consisent with administrative boundaries beyond country_code.



  ![image-20230727132504796](assets/image-20230727132504796.png)



  Finally there is a raw dataframe with exif data per image file:

  ![image-20230727132834377](assets/image-20230727132834377.png)





  See ``example.ipynb`` for example graphs and data frames exported.



  See PYPI [Python package](https://pypi.org/project/photos-where/).

  ```
  $ pip install photos-where
  ```



  ```
  $ photos_where Dropbox/Photos/2020/
  $ ls where
  cities-pie.jpg
  countries-pie.jpg
  intervals.csv
  location-by-day.csv
  photos.feather
  years.jpg
  ```


pkgId: f1d4b6271b82d0bc5b048404a5439479b9dc8c71b637f916998526f94d4e23bb
name: python-phrase-api-help
arch: noarch
version: 3.0.0
epoch: 0
release: 1
summary: Development documents and examples for phrase-api
url: https://github.com/phrase/phrase-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phrase-api-3.0.0-1.src.rpm
location_href: Packages/python-phrase-api-help-3.0.0-1.noarch.rpm
checksum_type: sha256
description:
      Phrase Strings is a translation management platform for software projects. You can collaborate on language file translation with your team or order translations through our platform. The API allows you to import locale files, download locale files, tag keys or interact in other ways with the localization data stored in Phrase Strings for your account.


pkgId: 6acde87d52cb5854343be1903acc601fd47ac884a75d9ddd81553105d04cda47
name: python-phub-help
arch: noarch
version: 4.7.3
epoch: 0
release: 1
summary: Development documents and examples for phub
url: https://pypi.org/project/phub/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phub-4.7.3-1.src.rpm
location_href: Packages/python-phub-help-4.7.3-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img width="200" src="https://raw.githubusercontent.com/Egsagon/PHUB/master/assets/logo.svg">
  </p>



  PHUB is an easy-to-use API wrapper for Pornhub. It can access most used or useful
  PH features, such as video searching, account features, video downloading, and more.

  - Project documentation: [phub.readthedocs.io](https://phub.readthedocs.io)
  - Project repository: [EchterAlsFake/PHUB](https://github.com/EchterAlsFake/PHUB)

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


pkgId: 8dfc928b3397a56d80adcee4da61287f50ac783fdafc31a84c2d37c381fb809d
name: python-phylum-help
arch: noarch
version: 0.56.0
epoch: 0
release: 1
summary: Development documents and examples for phylum
url: https://phylum.io/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-phylum-0.56.0-1.src.rpm
location_href: Packages/python-phylum-help-0.56.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/phylum)](https://pypi.org/project/phylum/)
  ![PyPI - Status](https://img.shields.io/pypi/status/phylum)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/phylum)](https://pypi.org/project/phylum/)
  [![GitHub](https://img.shields.io/github/license/phylum-dev/phylum-ci)][license]
  [![GitHub issues](https://img.shields.io/github/issues/phylum-dev/phylum-ci)][issues]
  ![GitHub last commit](https://img.shields.io/github/last-commit/phylum-dev/phylum-ci)
  [![GitHub Workflow Status (branch)][workflow_shield]][workflow_test]
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)][CoC]
  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit)][pre-commit]
  [![Poetry](https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json)][poetry]
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)][black]
  [![Downloads](https://static.pepy.tech/badge/phylum/month)][downloads]
  [![Discord](https://img.shields.io/discord/1070071012353376387?logo=discord)][discord_invite]

  Utilities for integrating Phylum into CI pipelines

  [license]: https://github.com/phylum-dev/phylum-ci/blob/main/LICENSE
  [issues]: https://github.com/phylum-dev/phylum-ci/issues
  [workflow_shield]: https://img.shields.io/github/actions/workflow/status/phylum-dev/phylum-ci/test.yml?branch=main&label=tests&logo=GitHub
  [workflow_test]: https://github.com/phylum-dev/phylum-ci/actions/workflows/test.yml
  [CoC]: https://github.com/phylum-dev/phylum-ci/blob/main/CODE_OF_CONDUCT.md
  [pre-commit]: https://github.com/pre-commit/pre-commit
  [poetry]: https://python-poetry.org/
  [black]: https://github.com/psf/black
  [downloads]: https://pepy.tech/project/phylum
  [discord_invite]: https://discord.gg/Fe6pr5eW6p





  The `phylum` Python package is pip installable for the environment of your choice:

  ```sh
  pip install phylum
  ```

  It can also be installed in an isolated environment with the excellent [`pipx` tool][pipx]:

  ```sh

  pipx install phylum


  pipx run --spec phylum phylum-init <options>
  pipx run --spec phylum phylum-ci <options>
  ```

  These installation methods require Python 3.9+ to run.
  For a self contained environment, consider using the Docker image as described below.

  Windows binaries are offered as [release artifacts][latest_rels] for a "standalone" solution that does not require
  Python or Docker to run. There are two options for this installation method:

  * `phylum-ci.zip`
    * [Download the latest archive version][latest_zip] and extract it
    * Add the extracted directory to `PATH` or reference the contained `phylum-ci.exe` binary directly
  * `phylum-ci.exe`
    * [Download the latest executable version][latest_exe] and place this binary on `PATH` or reference it directly
    * This is a self-extracting executable that adds a version-specific directory in the local user cache

  An advantage to the self-extracting archive is that it is a single file.
  A disadvantage is that the file may trigger AV since it uses a packer and is not digitally signed.

  Either Windows "installation" method allows access to the same [`phylum-ci` script entry point features][anchor_script].

  [pipx]: https://pypa.github.io/pipx/
  [latest_rels]: https://github.com/phylum-dev/phylum-ci/releases/latest
  [latest_zip]: https://github.com/phylum-dev/phylum-ci/releases/latest/download/phylum-ci.zip
  [latest_exe]: https://github.com/phylum-dev/phylum-ci/releases/latest/download/phylum-ci.exe
  [anchor_script]: #phylum-ci-script-entry-point



  The `phylum` Python package exposes its functionality with a command line interface (CLI).
  To view the options available from the CLI, print the help message from one of the scripts provided as entry points:

  ```sh
  phylum-init -h
  phylum-ci -h
  ```

  The functionality can also be accessed by calling the module:

  ```sh
  python -m phylum.init -h
  python -m phylum.ci -h
  ```

  The functionality is also exposed in the form of a Docker image:

  ```sh

  docker pull phylumio/phylum-ci


  docker run --rm phylumio/phylum-ci phylum-ci --help


  export PHYLUM_API_KEY=$(phylum auth token)


  docker run -it --rm -e PHYLUM_API_KEY --mount type=bind,src=$(pwd),dst=/phylum -w /phylum phylumio/phylum-ci
  ```

  The default Docker image contains `git` and the installed `phylum` Python package.
  It also contains an installed version of the Phylum CLI and all required tools needed for [lockfile generation].
  An advantage of using the default Docker image is that the complete environment is packaged and made available with
  components that are known to work together.

  One disadvantage to the default image is it's size. It can take a while to download and may provide more tools than
  required for your specific use case. Special `slim` tags of the `phylum-ci` image are provided as an alternative.
  These tags differ from the default image in that they do not contain the required tools needed for [lockfile generation]
  (with the exception of the `pip` tool). The `slim` tags are significantly smaller and will allow integrations relying
  on them to complete faster. They are useful for those instances where *no* manifest files are present and/or *only*
  lockfiles are used.

  ```sh

  docker pull phylumio/phylum-ci:slim
  ```

  When using the `latest` tagged image, the version of the Phylum CLI is the `latest` available.
  There are additional image tag options available to specify a specific release of the `phylum-ci` project and a specific
  version of the Phylum CLI, in the form of `<phylum-ci version>-CLIv<Phylum CLI version>`.
  Each of these also has a `-slim` variant that does not support [lockfile generation]. Here are image tag examples:

  ```sh

  docker pull phylumio/phylum-ci:latest


  docker pull phylumio/phylum-ci:0.44.1-CLIv6.6.0


  docker pull phylumio/phylum-ci:0.47.0-CLIv6.6.4-slim
  ```

  [lockfile generation]: https://docs.phylum.io/cli/lockfile_generation



  The `phylum-init` script can be used to fetch and install the Phylum CLI.
  It will attempt to install the latest released version of the CLI but can be specified to fetch a specific version.
  It will attempt to automatically determine the correct CLI release, based on the platform where the script is run, but
  a specific release target can be specified.
  It will accept a Phylum token from an environment variable or specified as an option, but will also function in the case
  that no token is provided. This can be because there is already a token set that should continue to be used or because
  no token exists and one will need to be manually created or set, after the CLI is installed.

  The options for `phylum-init`, automatically updated to be current for the latest release:

  > **HINT:** Click on the image to bring up the SVG file, which should allow for search and copy/paste functionality.

  ![phylum-init options](https://raw.githubusercontent.com/phylum-dev/phylum-ci/main/docs/img/phylum-init_options.svg)



  The `phylum-ci` script is for analyzing dependency file (lockfiles and manifests) changes.
  The script can be used locally or from within a Continuous Integration (CI) environment.
  It will attempt to detect the CI platform based on the environment from which it is run and act accordingly.
  The current CI platforms/environments supported are:

  |Platform/Environment|Information Link|
  |--------------------|---------------------|
  |GitHub Actions|[Documentation][github_docs]|
  |GitLab CI|[Documentation][gitlab_docs]|
  |Azure Pipelines|[Documentation][azure_docs]|
  |Bitbucket Pipelines|[Documentation][bb_pipelines_docs]|
  |Jenkins Pipelines|[Documentation][jenkins_docs]|
  |Git `pre-commit` Hooks|[Documentation][precommit_docs]|

  There is also support for local use. This is the "fall-through" case used when no other environment is detected.
  This can be useful to analyze dependency files locally, prior to or after submitting a pull/merge request (PR/MR) to a
  CI system. It can also help in establishing a successful submission prior to submitting a PR/MR to a CI system.
  Additionally, local use can aid troubleshooting after submitting a PR/MR to a CI system and getting unexpected results.

  The options for `phylum-ci`, automatically updated to be current for the latest release:

  > **HINT:** Click on the image to bring up the SVG file, which should allow for search and copy/paste functionality.

  ![phylum-ci options](https://raw.githubusercontent.com/phylum-dev/phylum-ci/main/docs/img/phylum-ci_options.svg)

  [github_docs]: https://docs.phylum.io/phylum-ci/github_actions
  [gitlab_docs]: https://docs.phylum.io/phylum-ci/gitlab_ci
  [azure_docs]: https://docs.phylum.io/phylum-ci/azure_pipelines
  [bb_pipelines_docs]: https://docs.phylum.io/phylum-ci/bitbucket_pipelines
  [jenkins_docs]: https://docs.phylum.io/phylum-ci/jenkins
  [precommit_docs]: https://docs.phylum.io/phylum-ci/git_precommit



  The `phylum-init` script entry point will return a zero (0) exit code when it completes successfully and a one (1)
  otherwise.

  The `phylum-ci` script entry point will return a zero (0) exit code when it completes successfully or one of the
  following non-zero codes otherwise:

  |Exit Code|Meaning|
  |---------|-------|
  |1|Default failure code. An unrecoverable error was encountered.|
  |2|Phylum analysis is complete and contains a policy violation.|
  |5|Phylum analysis is incomplete. Only used when enabled [by option][script_options].|
  |6|Phylum analysis is incomplete and contains a policy violation.|
  |10|Dependency file(s) failed filtering and excluded from analysis. See [this FAQ][FAQ] for more.|
  |11|No dependency files were provided or detected.|
  |12|No dependencies found in any current dependency file.|
  |20|A manifest is attempted to be parsed but lockfile generation has been disabled.|

  Exit codes of 10 or higher represent situations not directly linked to Phylum analysis. These errors are important
  because they indicate a complete Phylum analysis was not possible, which necessitates further investigation. An
  [option is available][script_options] to explicitly prevent these errors from setting an exit code.

  [script_options]: #phylum-ci-script-entry-point
  [FAQ]: https://github.com/marketplace/actions/phylum-analyze-pr#why-does-phylum-report-a-failing-status-check-if-it-shows-a-successful-analysis-comment



  Copyright (C) 2022  Phylum, Inc.

  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 any later version.

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

  You should have received a copy of the GNU General Public License along with this program.
  If not, see <https://www.gnu.org/licenses/gpl.html> or write to `phylum@phylum.io` or `engineering@phylum.io`



  Suggestions and help are welcome. Feel free to open an issue or otherwise contribute.
  More information is available on the [contributing documentation][contributing] page.

  [contributing]: https://github.com/phylum-dev/phylum-ci/blob/main/CONTRIBUTING.md



  Everyone participating in the `phylum-ci` project, and in particular in the issue tracker and pull requests, is
  expected to treat other people with respect and more generally to follow the guidelines articulated in the
  [Code of Conduct][CoC].



  Found a security issue in this repository? See the [security policy][security]
  for details on coordinated disclosure.

  [security]: https://github.com/phylum-dev/phylum-ci/blob/main/docs/security.md



  All notable changes to this project are documented in the [CHANGELOG][changelog].

  The format of the change log is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
  The entries in the changelog are primarily automatically generated through the use of
  [conventional commits](https://www.conventionalcommits.org) and the
  [Python Semantic Release](https://python-semantic-release.readthedocs.io/en/latest/index.html) tool.
  However, some entries may be manually edited, where it helps for clarity and understanding.

  [changelog]: https://github.com/phylum-dev/phylum-ci/blob/main/CHANGELOG.md


pkgId: facfee5d7fee69325cec3948b1662cec856893e752929c8155dc5e18ae62acb8
name: python-physiocurve-help
arch: noarch
version: 2024.12.16
epoch: 0
release: 1
summary: Development documents and examples for physiocurve
url: https://framagit.org/jaj/physiocurve
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-physiocurve-2024.12.16-1.src.rpm
location_href: Packages/python-physiocurve-help-2024.12.16-1.noarch.rpm
checksum_type: sha256
description:
  physiocurve is a library to analyze biometric time series such as ECG and pulse waves, often obtained from patient monitors.


pkgId: f60814607f2e64ad3610ecb6f8457b7c11a5aed98618654d425b69e078f9c896
name: python-physmet-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for physmet
url: https://pypi.org/project/physmet/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-physmet-0.1.3-1.src.rpm
location_href: Packages/python-physmet-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  This package provides support for defining and working with objects that
  comprise numeric data and an associated metric unit.

  ```python
  import physmet
  x = physmet.axis.coordinates([3, 6, 9], 'm')
  y = physmet.axis.coordinates([4, 8], 'J')
  a = physmet.array([[1.5, 2.0], [-3.0, 10.0], [-1.5, -10.0]], 'cm / s', axes={'x': x, 'y': y})
  a
  s = physmet.scalar(8.0, unit='s')
  s
  a * s
  z = physmet.axis.coordinates([0, 2, 4, 6], 'mK')
  z.unit
  z.unit.quantity
  b = physmet.array([[1.5, 2.0, -1.0, -1.0], [-3.0, 10.0, 1.0, 1.0]], 'au^2', axes={'y': y, 'z': z})
  a
  b
  a / b
  ```


pkgId: 5c603fecff281f9522d60d50835691e09f1483e5513d4a7ced43a557eb322ec7
name: python-pi-zero-pytorch-help
arch: noarch
version: 0.0.47
epoch: 0
release: 1
summary: Development documents and examples for pi-zero-pytorch
url: https://pypi.org/project/pi-zero-pytorch/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-pi-zero-pytorch-0.0.47-1.src.rpm
location_href: Packages/python-pi-zero-pytorch-help-0.0.47-1.noarch.rpm
checksum_type: sha256
description:
  <img src="./fig3.png" width="400px"></img>



  Implementation of <a href="https://www.physicalintelligence.company/blog/pi0">π₀</a> the robotic foundation model architecture proposed by Physical Intelligence

  Summary of this work would be that it is a simplified <a href="https://github.com/lucidrains/transfusion-pytorch">Transfusion</a> (Zhou et al.) with influence from <a href="https://arxiv.org/abs/2403.03206">Stable Diffusion 3</a> (Esser et al.), mainly the adoption of flow matching instead of diffusion for policy generation, as well as the separation of parameters (<a href="https://github.com/lucidrains/mmdit/blob/main/mmdit/mmdit_pytorch.py#L43">Joint Attention</a> from mmDIT). They build on top of a pretrained vision language model, PaliGemma 2B.



  - [Einops](https://github.com/arogozhnikov/einops) for the amazing [pack and unpack](https://einops.rocks/4-pack-and-unpack/), used extensively here for managing various token sets

  - [Flex Attention](https://pytorch.org/blog/flexattention/) for allowing for easy mixture of autoregressive and bidirectional attention

  - [@Wonder1905](https://github.com/Wonder1905) for the code review and identifying issues

  - You? maybe a phd student who wants to contribute to the latest SOTA architecture for behavioral cloning?



  ```bash
  $ pip install pi-zero-pytorch
  ```



  ```python
  import torch
  from pi_zero_pytorch import π0

  model = π0(
      dim = 512,
      dim_action_input = 6,
      dim_joint_state = 12,
      num_tokens = 20_000
  )

  vision = torch.randn(1, 1024, 512)
  commands = torch.randint(0, 20_000, (1, 1024))
  joint_state = torch.randn(1, 12)
  actions = torch.randn(1, 32, 6)

  loss, _ = model(vision, commands, joint_state, actions)
  loss.backward()



  sampled_actions = model(vision, commands, joint_state, trajectory_length = 32) # (1, 32, 6)
  ```



  At the project root, run

  ```bash
  $ pip install '.[test]' # or `uv pip install '.[test]'`
  ```

  Then add your tests to `tests/test_pi_zero.py` and run

  ```bash
  $ pytest tests/
  ```

  That's it



  ```bibtex
  @misc{Black2024,
      author  = {Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, Szymon Jakubczak, Tim Jones, Liyiming Ke, Sergey Levine, Adrian Li-Bell, Mohith Mothukuri, Suraj Nair, Karl Pertsch, Lucy Xiaoyang Shi, James Tanner, Quan Vuong, Anna Walling, Haohuan Wang, Ury Zhilinsky},
      url     = {https://www.physicalintelligence.company/download/pi0.pdf}
  }
  ```

  ```bibtex
  @inproceedings{Zhou2024ValueRL,
      title   = {Value Residual Learning For Alleviating Attention Concentration In Transformers},
      author  = {Zhanchao Zhou and Tianyi Wu and Zhiyun Jiang and Zhenzhong Lan},
      year    = {2024},
      url     = {https://api.semanticscholar.org/CorpusID:273532030}
  }
  ```

  ```bibtex
  @inproceedings{Darcet2023VisionTN,
      title   = {Vision Transformers Need Registers},
      author  = {Timoth'ee Darcet and Maxime Oquab and Julien Mairal and Piotr Bojanowski},
      year    = {2023},
      url     = {https://api.semanticscholar.org/CorpusID:263134283}
  }
  ```

  ```bibtex
  @article{Li2024ImmiscibleDA,
      title   = {Immiscible Diffusion: Accelerating Diffusion Training with Noise Assignment},
      author  = {Yiheng Li and Heyang Jiang and Akio Kodaira and Masayoshi Tomizuka and Kurt Keutzer and Chenfeng Xu},
      journal = {ArXiv},
      year    = {2024},
      volume  = {abs/2406.12303},
      url     = {https://api.semanticscholar.org/CorpusID:270562607}
  }
  ```

  ```bibtex
  @inproceedings{Sadat2024EliminatingOA,
      title   = {Eliminating Oversaturation and Artifacts of High Guidance Scales in Diffusion Models},
      author  = {Seyedmorteza Sadat and Otmar Hilliges and Romann M. Weber},
      year    = {2024},
      url     = {https://api.semanticscholar.org/CorpusID:273098845}
  }
  ```

  ```bibtex
  @article{Bulatov2022RecurrentMT,
      title   = {Recurrent Memory Transformer},
      author  = {Aydar Bulatov and Yuri Kuratov and Mikhail S. Burtsev},
      journal = {ArXiv},
      year    = {2022},
      volume  = {abs/2207.06881},
      url     = {https://api.semanticscholar.org/CorpusID:250526424}
  }
  ```

  ```bibtex
  @inproceedings{Bessonov2023RecurrentAT,
      title   = {Recurrent Action Transformer with Memory},
      author  = {A. B. Bessonov and Alexey Staroverov and Huzhenyu Zhang and Alexey K. Kovalev and D. Yudin and Aleksandr I. Panov},
      year    = {2023},
      url     = {https://api.semanticscholar.org/CorpusID:259188030}
  }
  ```

  [*dear alice*](https://www.youtube.com/watch?v=z-Ng5ZvrDm4)

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


pkgId: e721ed2216497f1f1b4f94b0405473d6c219c7129ae800beff576047c9c7188d
name: python-picnic-bio-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for picnic-bio
url: https://picnic.cd-code.org/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-picnic-bio-1.0.0-1.src.rpm
location_href: Packages/python-picnic-bio-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">
  <img src="https://git.mpi-cbg.de/tothpetroczylab/picnic/-/raw/main/branding/logo/logo_picnic_v1.96113169.png" width="300">
  </h1><br>



  [![Build Status](https://git.mpi-cbg.de/tothpetroczylab/picnic/badges/main/pipeline.svg)](https://git.mpi-cbg.de/tothpetroczylab/picnic/-/pipelines)
  [![Coverage Status](https://git.mpi-cbg.de/tothpetroczylab/picnic/badges/main/coverage.svg)](https://git.mpi-cbg.de/tothpetroczylab/picnic/-/pipelines)
  [![PyPI Version](https://img.shields.io/pypi/v/picnic-bio.svg)](https://pypi.org/project/picnic-bio/#history)
  [![PyPI Downloads](https://img.shields.io/pypi/dm/picnic-bio.svg?label=PyPI%20downloads)](
  https://pypi.org/project/picnic-bio/#files)
  [![Nat Commun 15, 10668 (2024)](https://img.shields.io/badge/DOI-10.1038%2Fs41467_024_55089_x-blue)](
  https://doi.org/10.1038/s41467-024-55089-x)
  [![Python Versions](https://img.shields.io/pypi/pyversions/picnic-bio.svg)](https://pypi.org/project/picnic-bio/#description)
  [![License](https://img.shields.io/pypi/l/picnic-bio.svg)](https://git.mpi-cbg.de/tothpetroczylab/picnic/-/blob/main/LICENSE)

  PICNIC (Proteins Involved in CoNdensates In Cells) is a machine learning-based model that predicts proteins involved in biomolecular condensates. The first model (PICNIC) is based on sequence-based features and structure-based features derived from Alphafold2 models. Another model includes extended set of features based on Gene Ontology terms (PICNIC-GO). Although this model is biased by the already available annotations on proteins, it provides useful insights about specific protein properties that are enriched in proteins of biomolecular condensate. Overall, we recommend using PICNIC that is an unbiased predictor, and using PICNIC-GO for specific cases, for example for experimental hypothesis generation.

  - [External software](#external-software)
  - [Installation instructions](#installation-instructions)
    - [Requirements](#requirements)
    - [Install external requirements](#install-external-requirements)
    - [PICNIC is available on PyPI](#picnic-is-available-on-pypi)
    - [PICNIC is also installable from source](#picnic-is-also-installable-from-source)
    - [How to install PICNIC using Conda?](#how-to-install-picnic-using-conda)
  - [How to use?](#how-to-use)
    - [Usage - Using PICNIC from command line](#usage---using-picnic-from-command-line)
    - [Examples](#examples)
    - [How to run the provided Jupyter notebook?](#how-to-run-the-provided-jupyter-notebook)
  - [Publication](#publication)



  *IUPred2A*

  IUPred2A is a tool that predicts disordered protein regions. It is available for download via the link https://iupred2a.elte.hu/download_new
  The downloaded archive should be unpacked into the "src/files/" directory.

  *STRIDE*

  STRIDE is a software for protein secondary structure assignment
  Installation guide can be found here https://webclu.bio.wzw.tum.de/stride/



  A binary installer for the latest released version is available at the Python Package Index (PyPI).



  * Python versions >=3.9,<3.13
  * Download and unpack IUPred2A
    * Add IUPred2A to PYTHONPATH
  * Download and unpack STRIDE
    * Add STRIDE binary to your system PATH






  A complete installation guide can be found [here](https://webclu.bio.wzw.tum.de/stride/install.html) or simply
  run the following commands:

  ```shell
  $ mkdir stride
  $ cd stride
  $ curl -OL https://webclu.bio.wzw.tum.de/stride/stride.tar.gz
  $ tar -zxf stride.tar.gz
  $ make
  $ export PATH="$PATH:$PWD"
  ```



  IUPred2A software is available for free only for academic users and it cannot be used for commercial purpose.
  If you are an academic user, then you can download IUPred2A by filling out the following form [here](https://iupred2a.elte.hu/download_new).

  ```shell

  $ tar -zxf iupred2a.tar.gz
  $ cd iupred2a
  $ export PYTHONPATH="$PWD"
  ```



  PICNIC officially supports Python versions >=3.9,<3.13.

  ```shell
  $ python3 --version
  Python 3.11.5

  $ python3 -m venv picnic-env
  $ source picnic-env/bin/activate
  $ (picnic-env) % python -m pip install --upgrade pip
  $ (picnic-env) % python -m pip install picnic_bio
  ```



  ```shell
  $ git clone git@git.mpi-cbg.de:atplab/picnic.git
  ```

  Once you have a copy of the source, you can embed it in your own Python package, or install it into your site-packages easily

  ```shell
  $ cd picnic
  $ python3 -m venv picnic-env
  $ source picnic-env/bin/activate
  $ (picnic-env) % python -m pip install --upgrade pip
  $ (picnic-env) $ python -m pip install .
  ```



  There isn't any binary installer available on Conda yet. Though it is possible to install PICNIC within a virtual Conda environment.

  Please note that in a conda environment you have to pre-install catboost, before installing picnic-bio itself, otherwise the installation will fail when compiling the catboost package from source code. Also it is recommended to use and set up [conda-forge](https://conda-forge.org/docs/user/introduction.html) to fetch pre-compiled versions of catboost.

  We have documented how to get around the catboost installation issue.

  ```shell
  $ conda config --add channels conda-forge
  $ conda config --set channel_priority strict




  $ conda create -n myenv python=3.11 catboost
  $ conda activate myenv
  (myenv) $ python -m pip install picnic_bio
  ```





  ```
  $ picnic <is_automated> <path_af> <protein_id> <is_go> --path_fasta_file <file>

  usage: PICNIC [-h] [--path_fasta_file PATH_FASTA_FILE]
                is_automated path_af protein_id is_go

  PICNIC (Proteins Involved in CoNdensates In Cells) is a machine learning-based
  model that predicts proteins involved in biomolecular condensates.

  positional arguments:
    is_automated          True if automated pipeline (works for proteins with
                          length < 1400 aa, with precalculated Alphafold2 model,
                          deposited to UniprotKB), else manual pipeline
                          (protein_id, Alphafold2 model(s) and fasta file are
                          needed to be provided as input)
    path_af               directory with pdb files, created by Alphafold2 for
                          the protein in the format. For smaller proteins ( <
                          1400 aa length) AlphaFold2 provides one model, that
                          should be named: AF-protein_id-F1-v{j}.pdb, where j is
                          a version number. In case of large proteins Alphafold2
                          provides more than one file, and all of them should be
                          stored in one directory and named: 'AF-
                          protein_id-F{i}-v{j}.pdb', where i is a number of
                          model, j is a version number.
    protein_id            protein identifier in UniprotKB (should correspond to
                          the name 'protein_id' for Alphafold2 models, stored in
                          directory_af_models)
    is_go                 boolean flag; if 'True', picnic_go score (picnic
                          version with Gene Ontology features) will be
                          calculated, Gene Ontology terms are retrieved in this
                          case from UniprotKB by protein_id identifier;
                          otherwise default picnic score will be printed
                          (without Gene Ontology annotation)

  options:
    -h, --help            show this help message and exit
    --path_fasta_file PATH_FASTA_FILE
                          directory with sequence file in fasta format
  ```



  Run automated pipeline for a given UniProt Id:
  ```shell
  $ picnic True notebooks/test_files/Q99720/ Q99720 True
  ```
  Run manual pipeline for a given UniProt Id:
  ```shell
  $ picnic False 'notebooks/test_files/O95613/' 'O95613' False --path_fasta_file 'notebooks/test_files/O95613/O95613.fasta.txt'
  ```
  Run manual pipeline for your own protein sequence called MY_PROTEIN, which has no reference to UniProt:
  ```shell
  $ picnic False 'notebooks/test_files/MY_PROTEIN/' 'MY_PROTEIN' False --path_fasta_file 'notebooks/test_files/MY_PROTEIN/my_protein.fasta'
  ```
  Examples of using PICNIC are shown in a jupyter-notebook in notebooks folder.



  Examples of how to use and run PICNIC are shown in a provided Jupyter notebook. The notebook can be found under the
  **notebooks** folder.



  Please read documentation [here](https://saturncloud.io/blog/how-to-launch-jupyter-notebook-from-your-terminal/#what-is-jupyter-notebook).




  Create a virtual environment by executing the command venv:
  ```shell
  $ python -m venv /path/to/new/virtual/environment

  $ python -m venv my_jupyter_env
  ```

  Then install the classic Jupyter Notebook with:
  ```shell
  $ source my_jupyter_env/bin/activate

  $ pip install notebook
  ```
  Also install picnic-bio from source in the same virtual environment...
  ```shell
  $ pip install .
  ```



  In your terminal source the previously created virtual environment...
  ```shell
  $ source my_jupyter_env/bin/activate
  ```
  Launch Jupyter Notebook...
  ```shell
  $ jupyter notebook
  ```
  Open the example notebook called 'picnic_examples.ipynb' under the notebooks folder.


  ***PICNIC accurately predicts condensate-forming proteins regardless of their structural disorder across organisms.***
  Anna Hadarovich, Hari Raj Singh, Soumyadeep Ghosh, Maxim Scheremetjew, Nadia Rostam, Anthony A. Hyman & Agnes Toth-Petroczy.
  Nature Communications volume 15, Article number: 10668 (2024). doi: [10.1038/s41467-024-55089-x](https://doi.org/10.1038/s41467-024-55089-x). PMID: [39663388](https://pubmed.ncbi.nlm.nih.gov/39663388/).

  <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Creative Commons Attribution-ShareAlike 4.0 International License</a>.







  Before you start make sure you have a [SSH key generated](https://git.mpi-cbg.de/help/ssh/index#generate-an-ssh-key-pair) and the [public SSH Key added to your GitLab account](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account).
  You only have to do this once!

  Every time you open a new console/terminal make sure your ssh-agent is running and all SSH keys are added.

  ```shell
  $ eval `ssh-agent -s` && ssh-add
  ```



  Fill out and submit the IUPred2A web form [here](https://iupred2a.elte.hu/download_new) to request the iupred2a.tar.gz archive.
  Once you received the archive please unpack the TAR ball under the following project sub folder src/files/:

  ```shell
  $ cd picnic/bin
  $ cp blah/iupred2a.tar.gz .
  $ tar -xvf iupred2a.tar.gz
  $ cd iupred2a
  $ export PYTHONPATH="$PWD"
  ```



  This could be achieved in different ways. Follow documentation [here](https://brianchristner.io/what-is-docker-buildkit/).

  There are 2 main options:

  * Enable the BuildKit in your local Docker Desktop
  * Enable the BuildKit in a fresh terminal



  ```
  export DOCKER_BUILDKIT=1
  ```


  ```
  export COMPOSE_DOCKER_CLI_BUILD=1
  ```



  ```shell
  $ docker build --build-arg="PYTHON_VERSION=3.10.13" . -f Dockerfile -t atplab/picnic-service
  ```



  ```shell
  $ docker run atplab/picnic-service

  e.g.
  $ docker run atplab/picnic-service True 'notebooks/test_files/Q99720/' 'Q99720' True
  ```



  ```shell
  $ docker run -it --entrypoint sh atplab/picnic-service
  ```







  ```shell
  // Create a new env - one off task
  $ python3 -m venv packaging

  $ source packaging/bin/activate

  (packaging) $ pip install -r requirements-packaging.txt
  ```



  ```shell
  (venv) % cd /<path-to-project-root-folder>/picnic

  (venv) % pip install .


  (venv) % picnic
  usage: PICNIC [-h] [--path_fasta_file PATH_FASTA_FILE] is_automated path_af protein_id is_go
  PICNIC: error: the following arguments are required: is_automated, path_af, protein_id, is_go
  ```



  Run the following command from the root directory to build the package. This will create a dist
  folder where the wheel distribution is built along with a zip file.
  ```shell
  (packaging) $ cd /<path-to-project-root-folder>/picnic

  (packaging) $ python -m build

  (packaging) $ ls -l dist
  picnic-bio-1.0.0b1.tar.gz
  picnic_bio-1.0.0b1-py3-none-any.whl

  (packaging) $ twine check dist/*
  ```



  Finally, we need to upload these files to PyPi using Twine. Use the following command from the project root
  directory. Enter the PyPi credentials to complete uploading the package.

  ```shell

  (packaging) $ twine upload --repository testpypi dist/*


  (packaging) $ twine upload dist/*
  ```




  ```shell
  (packaging) $ deactivate
  ```


pkgId: 4ab602e2468d1a8038b9fa5bfdb78a3f8ced2214aed9f6909c610575e507f2e5
name: python-picows-debuginfo
arch: aarch64
version: 1.7.2
epoch: 0
release: 1
summary: Debug information for package python-picows
url: https://github.com/tarasko/picows
rpm_license: MIT License
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-picows-1.7.2-1.src.rpm
location_href: Packages/python-picows-debuginfo-1.7.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug information for package python-picows.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: cb2f7a763458d0e87bbd61040605ce79b3947ad1342f6876d30d78edd2a6c9b4
name: python-picows-debugsource
arch: aarch64
version: 1.7.2
epoch: 0
release: 1
summary: Debug sources for package python-picows
url: https://github.com/tarasko/picows
rpm_license: MIT License
rpm_group: Development/Debug
rpm_buildhost: localhost
rpm_sourcerpm: python-picows-1.7.2-1.src.rpm
location_href: Packages/python-picows-debugsource-1.7.2-1.aarch64.rpm
checksum_type: sha256
description:
  This package provides debug sources for package python-picows.
  Debug sources are useful when developing applications that use this
  package or when debugging this package.


pkgId: 483c4471ed3c1890c55393e17390adbd93b263c7ebf8474e2f9126971badd3d6
name: python-picows-help
arch: aarch64
version: 1.7.2
epoch: 0
release: 1
summary: Development documents and examples for picows
url: https://github.com/tarasko/picows
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-picows-1.7.2-1.src.rpm
location_href: Packages/python-picows-help-1.7.2-1.aarch64.rpm
checksum_type: sha256
description:
  **picows** is a high-performance python library designed for building asyncio WebSocket clients and servers.
  Implemented in Cython, it offers exceptional speed and efficiency, surpassing other popular WebSocket python libraries.
  The above chart shows the performance of echo clients communicating with a server through a loopback interface using popular Python libraries.
  `boost.beast client <https://www.boost.org/doc/libs/1_85_0/libs/beast/example/websocket/client/sync/websocket_client_sync.cpp>`_
  is also included for reference. Typically, picows is ~1.5-2 times faster than aiohttp. All Python clients use uvloop. Please find the benchmark sources
  `here <https://github.com/tarasko/picows/blob/master/examples/echo_client_benchmark.py>`_.


