# packages

pkgId: 53232f9d488a6dad28cb3084ddc8d56e13f224c4d196e18534b729e89b47d17c
name: python-v-installer-help
arch: noarch
version: 0.0.11
epoch: 0
release: 1
summary: Development documents and examples for v-installer
url: http://gitea:8000/datlt4/fortifai_monitoring
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-v-installer-0.0.11-1.src.rpm
location_href: Packages/python-v-installer-help-0.0.11-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
  python3 setup.py sdist bdist_wheel
  ```



  ```bash
  twine upload dist/*
  ```



  ```bash
  docker run -it --rm -v $(pwd):/workspace/v-installer python:3.12.7-alpine /bin/sh

  apk update
  cd /workspace/v-installer
  python3 -m pip install setuptools
  python3 setup.py sdist bdist_wheel
  apk add twine
  apk add gcc python3-dev musl-dev linux-headers
  TWINE_USERNAME="__token__" TWINE_PASSWORD="pypi-....................................................." twine upload --non-interactive dist/*
  ```


pkgId: 9ce10bb5f9add31cf434e9dad7cf899f88767df2569631a68e82a7fc005be802
name: python-v2dl-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for v2dl
url: https://pypi.org/project/v2dl/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-v2dl-0.2.6-1.src.rpm
location_href: Packages/python-v2dl-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  ![Python >= 3.10](https://img.shields.io/badge/python->=3.10-red.svg?style=for-the-badge)
  [![PyPI - Version](https://img.shields.io/pypi/v/v2dl?style=for-the-badge)](https://pypi.org/project/v2dl/)
  ![Pepy Total Downloads](https://img.shields.io/pepy/dt/v2dl?style=for-the-badge&color=027ec7)
  ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ZhenShuo2021/V2PH-Downloader?style=for-the-badge)
  [![Test Status](https://img.shields.io/github/actions/workflow/status/ZhenShuo2021/V2PH-Downloader/python-publish.yml?label=Tests&style=for-the-badge)](https://github.com/ZhenShuo2021/V2PH-Downloader/actions)
  [![Build Status](https://img.shields.io/github/actions/workflow/status/ZhenShuo2021/V2PH-Downloader/tests.yml?label=Build&style=for-the-badge)](https://github.com/ZhenShuo2021/V2PH-Downloader/actions)
  [![GitHub last commit](https://img.shields.io/github/last-commit/ZhenShuo2021/V2PH-Downloader?labelColor=555555&style=for-the-badge&color=027ec7)](https://github.com/ZhenShuo2021/V2PH-Downloader/commits/main/)

  </div>

  [English](https://github.com/ZhenShuo2021/V2PH-Downloader/blob/main/README.en.md)



  微圖坊下載器



  📦 開箱即用：不用下載額外依賴
  🌐 跨平台：全平台支援
  🔄 雙引擎：支援 DrissionPage 和 Selenium 兩種自動化選項
  🛠️ 方便：支援多帳號自動登入自動切換，支援 cookies/帳號密碼登入兩種方式
  ⚡️ 快速：採用非同步事件迴圈的高效下載
  🧩 自訂：提供多種自定義參數選項
  🔑 安全：使用 PyNaCL 作為加密後端



  基本需求為

  1. 電腦已安裝 Chrome 瀏覽器
  2. Python 版本 > 3.10
  3. 使用指令安裝套件

  ```sh
  pip install v2dl
  ```



  首次執行時需要登入 V2PH 的帳號，有兩種方式

  1. 帳號管理介面
  使用 `v2dl -a` 進入帳號管理介面。

  ```sh
  v2dl -a
  ```

  2. 手動登入
  帳號登入頁面的機器人偵測比較嚴格，可以隨機下載一個相簿啟動程式，遇到登入頁面程式報錯後手動登入。



  v2dl 支援多種下載方式，可以下載單一相簿，也可以下載相簿列表，也支援從相簿中間開始下載，以及讀取文字文件中的所有頁面。

  ```sh

  v2dl "https://www.v2ph.com/album/Weekly-Young-Jump-2015-No15"


  v2dl "https://www.v2ph.com/category/nogizaka46"


  v2dl -i "/path/to/urls.txt"
  ```



  會尋找系統設定目錄中是否存在 `config.yaml`，格式請參照根目錄的範例。

  裡面可以修改捲動長度、捲動步長與速率限制等設定：

  - download_dir: 設定下載位置，預設系統下載資料夾。
  - download_log: 紀錄已下載的 album 頁面網址，重複的會跳過，該文件預設位於系統設定目錄。
  - system_log: 設定程式執行日誌的位置，該文件預設位於系統設定目錄。
  - rate_limit: 下載速度限制，預設 400 夠用也不會被封鎖。
  - chrome/exec_path: 系統的 Chrome 程式位置。

  系統設定目錄位置：

  - Windows: `C:\Users\xxx\AppData\v2dl`
  - Linux, macOS: `/Users/xxx/.config/v2dl`



  Cookies 登入比帳號密碼更容易成功。

  使用方式是用擴充套件（如 [Cookie-Editor](https://chromewebstore.google.com/detail/cookie-editor/hlkenndednhfkekhgcdicdfddnkalmdm)）導出 cookies，建議選擇 Netscape 格式，並且在帳號管理工具中輸入導出的 cookie 文件位置。

  > [!NOTE]
  > 導出的 Cookies 必須包含 frontend-rmt/frontend-rmu 項目。

  > [!NOTE]
  > Cookies 為機密資訊，請選擇選擇[下載數量高](https://news.cnyes.com/news/id/5584471)的擴充功能套件，並且導出完成後建議將套件移除或限制存取。



  - url: 下載目標的網址。
  - -i: 下載目標的 URL 列表文字文件，每行一個 URL。
  - -a: 進入帳號管理工具。
  - -d: 設定下載根目錄，在分類檔案時特別有用。
  - -D: 設定檔案實際下載位置。
  - --no-skip: 強制下載不跳過。
  - --bot: 選擇自動化工具，drission 比較不會被機器人檢測封鎖。
  - --dry-run: 僅進行模擬下載，不會實際下載檔案。
  - --chrome-args: 複寫啟動 Chrome 的參數，用於被機器人偵測封鎖時。
  - --user-agent: 複寫 user-agent，用於被機器人偵測封鎖時。
  - --terminate: 程式結束後是否關閉 Chrome 視窗。
  - -q: 安靜模式。
  - -v: 偵錯模式。



  > 作為好玩的套件，所以會放一些看起來沒用的功能，例如這個安全架構。其實我也只是把文檔看過一遍就拿來用，這個段落都是邊寫邊查（不過有特別選輕量套件，這個才 4MB，常見的 cryptography 25MB）。

  密碼儲存使用基於現代密碼學 Networking and Cryptography (NaCl) 的加密套件 PyNaCL，系統採用三層金鑰架構完成縱深防禦：

  - 第一層使用作業系統的安全亂數源 os.urandom 生成 32 位元的 encryption_key 和 salt 用以衍生金鑰，衍生金鑰函式 (KDF) 採用最先進的 argon2id 演算法，此演算法結合最先進的 Argon2i 和 Argon2d，能有效防禦 side-channel resistant 和對抗 GPU 暴力破解。

  - 中間層使用主金鑰保護非對稱金鑰對，使用 XSalsa20-Poly1305 演算法加上 24-byte nonce 防禦密碼碰撞，XSalsa20 [擴展](https://meebox.io/docs/guide/encryption.html)了 Salsa20，在原本高效、不需要硬體加速的優勢上更進一步強化安全性。Poly1305 確保密碼完整性，防止傳輸過程中被篡改的問題。

  - 最外層以 SealBox 實現加密，採用業界標準 Curve25519 演算法提供完美前向保密，Curve25519 只需更短的金鑰就可達到和 RSA 同等的安全強度。

  最後將金鑰儲存在設有安全權限管理的資料夾，並將加密材料分開儲存於獨立的 .env 檔案中。



  你可以擴展 V2DL，以下是一個使用自訂預設值，並且替換網頁自動化套件的範例

  ```py
  from v2dl import V2DLApp

  custom_defaults = {
      "static_config": {
          "min_scroll_length": 1000,
          "max_scroll_length": 2000,
          
      }
  }


  class CustomBot:
      def __init__(self, config_instance):
          self.config = config_instance

      def auto_page_scroll(self, full_url, page_sleep=0) -> str:
          
          print("Custom bot in action!")
          return """
  <!doctype html>
  <html>
  <head>
      <title>Example Domain</title>

      <meta charset="utf-8" />
      <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1" />
  </head>

  <body>
  <div>
      <h1>Example Domain</h1>
      <p>This domain is for use in illustrative examples in documents. You may use this
      domain in literature without prior coordination or asking for permission.</p>
      <p><a href="https://www.iana.org/domains/example">More information...</a></p>
  </div>
  </body>
  </html>
  """

  class ExtendedV2DL(V2DLApp):
      def _setup_runtime_config(self, config_manager, args):
          super()._setup_runtime_config(config_manager, args)
          config_manager.set("runtime_config", "user_agent", "my_custom_ua")
          print("Custom config in action!")


  bot_name = "my awesome bot"
  command_line_args = {"url": "https://www.v2ph.com/album/foo", "force_download": True}

  app = ExtendedV2DL()
  app.register_bot(bot_name, CustomBot)
  app.set_bot(bot_name)
  app.run(command_line_args)
  ```



  1. 換頁或者下載速度太快都可能觸發封鎖，目前的設定已經均衡下載速度和避免封鎖了。
  2. 會不會被封鎖也有一部分取決於網路環境，不要開 VPN 下載比較安全。
  3. 謹慎使用，不要又把網站搞到關掉了，難得有資源收錄完整的。

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


pkgId: 177fd9003d78cb5ed19752224fbf0c9b642cbb2b426bbe675357429b06fa972b
name: python-vald-client-python-help
arch: noarch
version: 1.7.15
epoch: 0
release: 1
summary: Development documents and examples for vald-client-python
url: https://github.com/vdaas/vald-client-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vald-client-python-1.7.15-1.src.rpm
location_href: Packages/python-vald-client-python-help-1.7.15-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://badge.fury.io/py/vald-client-python.svg)](https://badge.fury.io/py/vald-client-python)
  [![Vald version](https://img.shields.io/github/release/vdaas/vald.svg?style=flat-square)](https://github.com/vdaas/vald/releases/latest)
  ![Build version](https://img.shields.io/badge/python-3.10-green)

  A Python gRPC client library for [Vald](https://github.com/vdaas/vald).



  Using pip,

  ```sh
  pip install vald-client-python
  ```



  To use v1 APIs,

  ```python
  import grpc
  from vald.v1.vald import insert_pb2_grpc
  from vald.v1.vald import search_pb2_grpc
  from vald.v1.vald import update_pb2_grpc
  from vald.v1.vald import remove_pb2_grpc
  from vald.v1.payload import payload_pb2


  channel = grpc.insecure_channel("gateway.vald.vdaas.org:80")


  istub = insert_pb2_grpc.InsertStub(channel)
  sstub = search_pb2_grpc.SearchStub(channel)
  ustub = update_pb2_grpc.UpdateStub(channel)
  rstub = remove_pb2_grpc.RemoveStub(channel)


  vec = payload_pb2.Object.Vector(id='vector_id_1', vector=[0.1, 0.2, 0.3])
  icfg = payload_pb2.Insert.Config(skip_strict_exist_check=True)
  istub.Insert(payload_pb2.Insert.Request(vector=vec, config=icfg))





  scfg = payload_pb2.Search.Config(num=10, radius=-1.0, epsilon=0.01, timeout=3000000000)
  res = sstub.Search(payload_pb2.Search.Request(vector=[0.1, 0.2, 0.3], config=scfg))



  uvec = payload_pb2.Object.Vector(id='vector_id_1', vector=[0.1, 0.2, 0.3])
  ucfg = payload_pb2.Update.Config(skip_strict_exist_check=True)
  ustub.Update(payload_pb2.Update.Request(vector=uvec, config=ucfg))



  rcfg = payload_pb2.Remove.Config(skip_strict_exist_check=True)
  rid = payload_pb2.Object.ID(id='vector_id_1')
  rstub.Remove(payload_pb2.Remove.Request(id=rid, config=rcfg))


  channel.close()
  ```


pkgId: 95dff5bc280cd3ff7269bd796b43f5a8467f05caa95ccd422f8dea117c1b71b1
name: python-validata-table-help
arch: noarch
version: 0.12.1
epoch: 0
release: 1
summary: Development documents and examples for validata-table
url: https://gitlab.com/validata-table/validata-table
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-validata-table-0.12.1-1.src.rpm
location_href: Packages/python-validata-table-help-0.12.1-1.noarch.rpm
checksum_type: sha256
description:
  [Validata Table](https://gitlab.com/validata-table/validata-table)  is python package used as a tabular data validation service.

  It includes four subpackages, where you can find their respective documentations :
  - [`validata_core`](src/validata_core/README.md)
  - [`validata_ui`](src/validata_ui/README.md)
  - [`validata_api`](src/validata_api/README.md)
  - `tests` used for testing the project (in development environment or in continuous integration)

  It offers also a command line tool `validata` used to validate tabular data.
  See [validata_core/README.md](src/validata_core/README.md) for more details.



  You can use locally this package `validata-table`, doing:

  ```commandline
  pip install validata-table
  ```

  This allows you to use `validata` command line tool to validate tabular data:

  ```commandline
  validata --help
  ```



  This project is based on [Docker](https://docs.docker.com/get-started/overview/) to use a local developement environement.

  This project includes a Makefile, which allows you to run predefined actions
  by running specific commands.

  Dependency management tool used : [Poetry version 1.6.1](https://python-poetry.org/docs/)



  First install [Docker Engine](https://docs.docker.com/engine/install/) and [docker-compose >= version 2](https://docs.docker.com/compose/install/)
  on your machine if not already done.

  Then you may clone source code in your development directory:

  ```commandline
  git clone https://gitlab.com/validata-table/validata-table.git
  cd validata-table
  ```



  Configuration is done by editing environment variables in `.env`,
  (see `.env.example` file to set `.env` file)

  Warning: Docker env files do not support using quotes around variable values!

  Launch the local development environment, thanks to the makefile command:

  ```bash

  make serve_dev
  ```

  This launches two docker containers:

  - validata-api-dev
  - validata-ui-dev



  To access to the API of Validata Table click on http://localhost:5000/

  [Try Validata Table API](src/validata_api/README.md)



  To access to the API of Validata Table click on http://localhost:5001/



  To use validata command line tool in the docker development environment, run:

  ```
  docker exec -it validata-api-dev bash
  validata --help
  ```



  To launch tests in the development environment, run:

  ```
  make test
  ```



  Some code linting tools are configured for this project:

  - [black](https://black.readthedocs.io/en/stable/): to format code, run `make black`
  - [isort](https://pycqa.github.io/isort/): to format import, run `make isort`
  - [flake8](https://flake8.pycqa.org/en/latest/): to enforce style coding, run `make flake8`
  - [pyright](https://microsoft.github.io/pyright/#/): to check static types.
    `pyright` will be executed in local virtual environment with `poetry`:

    First you need to create a virtual environment .venv at the root of the project
  and configure it:

  ```commandline

  python3.9 -m venv .venv  # install virtual environement locally
  poetry config virtualenvs.in-project true
  poetry config --list # Check if correctly configured
  >>>
  ...
  virtualenvs.in-project = true
  ...

  poetry install  # install project dependencies
  ```

  Then execute locally `pyright` with `poetry`:

  ```commandline
  poetry run pyright .
  ```




  The continuous integration is configured in `.gitlab-ci.yml` file



  On master branch :

  - Update version in [pyproject.toml](pyproject.toml) and [CHANGELOG.md](CHANGELOG.md) files
  - Update version Docker images used in [docker-compose.yml](docker-compose.yml) file:
    - registry.gitlab.com/validata-table/validata-table/validata-table-api:vX.X.X
    - registry.gitlab.com/validata-table/validata-table/validata-table-ui:vX.X.X
  - Update CHANGELOG.md
  - Commit changes using `Release` as commit message
  - Create git tag (starting with "v" for the release) `git tag -a`
  - Git push: `git push && git push --tags`
  - Check that pypi package is created and container images for validata_ui and validata_api are well-built
  ([validata-table pipelines](https://gitlab.com/validata-table/validata-table/-/pipelines))

  Creating and pushing a new release will trigger the pipeline in order to automatically:

  - publish a new version of `validata-table` package on [PyPI](https://pypi.org/)
  - build a new tag of the Docker image `validata-table-ui`, based on the new version just created of the package `validata-table`, and publish it on the gitlab container
  registry [validata-table-ui](https://gitlab.com/validata-table/validata-table/container_registry/5871420),
  used to run user interface Validata
  - build a new tag of the Docker image `validata-table-api`, based on the new version just created of the package `validata-table` and publish it on the gitlab container
  registry [validata-table-api](https://gitlab.com/validata-table/validata-table/container_registry/5871449),
  used to run the API of Validata

  This pipeline runs when a new tag under the format 'vX.X.X' is pushed.



  You can deploy this project on your own production server by using Docker.

  Production environment is based on Docker images `validata-table-ui`and `validata-table-api`
  hosted on gitlab container registries [validata-table-ui](https://gitlab.com/validata-table/validata-table/container_registry/5871420)
  and [validata-table-api](https://gitlab.com/validata-table/validata-table/container_registry/5871449)

  To deploy in production, you can follow these steps described below.

  First you may clone source code in your deployment directory:

  ```commandline
  git clone https://gitlab.com/validata-table/validata-table.git
  cd validata-table
  ```

  Configuration is done by editing environment variables in `.env`,
  (see `.env.example` file to set `.env` file).

  Warning: Docker env files do not support using quotes around variable values !

  Launch the docker production environment with makefile:

  ```commandline
  make serve_prod
  ```

  OR launch the docker production environment with `docker compose` command:

  ```commandline
  docker compose -f docker-compose.yml up --build -d
  ```

  Then:

  - To access to the API of Validata Table click on http://localhost:<PORT_NUMBER_API>/
    (replacing PORT_NUMBER_API with the value you choose)
  - To access to the UI of Validata Table click on http://localhost:<PORT_NUMBER_UI>/
    (replacing PORT_NUMBER_UI with the value you choose)
  - To access to the `validata` command lines tool:

  ```
  docker exec -it validata-table-api bash
  validata --help
  ```



  To keep track of the project's history, [Validata Table](https://gitlab.com/validata-table/validata-table)
  comes from the merge of four gitlab repositories :
  - [Validata core](https://gitlab.com/validata-table/validata-core)
  - [Validata UI](https://gitlab.com/validata-table/validata-ui)
  - [Validata API](https://gitlab.com/validata-table/validata-api)
  - [Validata Docker](https://gitlab.com/validata-table/validata-docker)


pkgId: 6f86635e567e89370a24412651077571cfe563e1841b36eab1b3f8544fd21500
name: python-validio-cli-help
arch: noarch
version: 0.25.2
epoch: 0
release: 1
summary: Development documents and examples for validio-cli
url: https://validio.io/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-validio-cli-0.25.2-1.src.rpm
location_href: Packages/python-validio-cli-help-0.25.2-1.noarch.rpm
checksum_type: sha256
description:
  This CLI is maintained by [Validio] to enable users to interact with the Validio platform.



  ```sh
  pip install validio-cli
  ```



  ```sh
  validio --help
  ```

    [Validio]: https://validio.io


pkgId: a729d1170a8466690b341e4f626bd8420fdfe2189b95eb95cf03cb81f8447486
name: python-validio-sdk-help
arch: noarch
version: 0.25.2
epoch: 0
release: 1
summary: Development documents and examples for validio-sdk
url: https://validio.io/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-validio-sdk-0.25.2-1.src.rpm
location_href: Packages/python-validio-sdk-help-0.25.2-1.noarch.rpm
checksum_type: sha256
description:
  This SDK is maintained by [Validio] to enable users to integrate with the Validio platform in a programmatic way.

  For more information, refer to the [SDK docs].



  ```sh
  pip install validio-sdk
  ```

    [Validio]: https://validio.io
    [SDK docs]: https://dev.validio.io/sdk-docs


pkgId: f76d07394595eaa7408ca72f82f3e21a3599513ec87573ab6ef10cc11af50e46
name: python-validmind-help
arch: noarch
version: 2.7.2
epoch: 0
release: 1
summary: Development documents and examples for validmind
url: https://pypi.org/project/validmind/
rpm_license: Commercial License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-validmind-2.7.2-1.src.rpm
location_href: Packages/python-validmind-help-2.7.2-1.noarch.rpm
checksum_type: sha256
description:
  The ValidMind Library is a suite of developer tools and methods designed to automate the documentation and validation of your models.

  Designed to be model agnostic, the ValidMind Library provides all the standard functionality without requiring you to rewrite any functions as long as your model is built in Python.

  With a rich array of documentation tools and test suites, from documenting descriptions of your datasets to testing your models for weak spots and overfit areas, the ValidMind Library helps you automate model documentation by feeding the ValidMind Platform with documentation artifacts and test results.



  ValidMind helps developers, data scientists and risk and compliance stakeholders identify potential risks in their AI and large language models, and generate robust, high-quality model documentation that meets regulatory requirements.

  [The ValidMind AI risk platform](https://docs.validmind.ai/about/overview.html) consists of two intertwined product offerings:

  - **The ValidMind Library** — Designed to be incorporated into your existing model development environment, you use the ValidMind Library to run tests and log documentation to the ValidMind Platform. Driven by the power of open-source, the ValidMind Library welcomes contributions to our code and developer samples: [`validmind-library` @ GitHub](https://github.com/validmind/validmind-library)
  - **The ValidMind Platform** — A cloud-hosted user interface allowing you to comprehensively track your model inventory throughout the entire model lifecycle according to the unique requirements of your organization. You use the ValidMind Platform to oversee your model risk management process via the customizable model inventory.



  > **All you need to get started with ValidMind is an account with us.**
  >
  > Signing up is FREE — **[Register with ValidMind](https://docs.validmind.ai/guide/configuration/register-with-validmind.html)**

  That's right — you can run tests and log documentation even if you don't have a model available, so go ahead and [**Get started with the ValidMind Library**](https://docs.validmind.ai/developer/get-started-validmind-library.html)!



  **[Explore our code samples!](https://docs.validmind.ai/developer/samples-jupyter-notebooks.html)**

  Our selection of Jupyter Notebooks showcase the capabilities and features of the ValidMind Library, while also providing you with useful examples that you can build on and adapt for your own use cases.



  To install the ValidMind Library and all optional dependencies, run:

  ```bash
  pip install validmind[all]
  ```

  To install the ValidMind Library without optional dependencies (core functionality only), run:

  ```bash
  pip install validmind
  ```



  The ValidMind Library has optional dependencies that can be installed separately to support additional model types and tests.

  - **LLM Support**: To be able to run tests for Large Language Models (LLMs), install the `llm` extra:

      ```bash
      pip install validmind[llm]
      ```

  - **PyTorch Models**: To use pytorch models with the ValidMind Library, install the `torch` extra:

      ```bash
      pip install validmind[torch]
      ```

  - **Hugging Face Transformers**: To use Hugging Face Transformers models with the ValidMind Library, install the `transformers` extra:

      ```bash
      pip install validmind[transformers]
      ```

  - **R Models**: To use R models with the ValidMind Library, install the `r` extra:

      ```bash
      pip install validmind[r-support]
      ```


pkgId: fc313c4fb941cfd97a1af67cf1ad24468307f0d3f9941a66fd5bf4ea02fcb9df
name: python-valor-lite-help
arch: noarch
version: 0.34.0
epoch: 0
release: 1
summary: Development documents and examples for valor-lite
url: https://pypi.org/project/valor-lite/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-valor-lite-0.34.0-1.src.rpm
location_href: Packages/python-valor-lite-help-0.34.0-1.noarch.rpm
checksum_type: sha256
description:
  valor-lite is a lightweight, numpy-based library designed for fast and seamless evaluation of machine learning models. It is optimized for environments where quick, responsive evaluations are essential, whether as part of a larger service or embedded within user-facing tools.

  valor-lite is maintained by Striveworks, a cutting-edge MLOps company based in Austin, Texas. If you'd like to learn more or have questions, we invite you to connect with us on [Slack](https://striveworks-public.slack.com/join/shared_invite/zt-1a0jx768y-2J1fffN~b4fXYM8GecvOhA#/shared-invite/email) or explore our [GitHub repository](https://github.com/striveworks/valor).

  For additional details, be sure to check out our user [documentation](https://striveworks.github.io/valor/). We're excited to support you in making the most of Valor!





  ```python
  from valor_lite.classification import DataLoader, Classification, MetricType

  classifications = [
      Classification(
          uid="uid0",
          groundtruth="dog",
          predictions=["dog", "cat", "bird"],
          scores=[0.75, 0.2, 0.05],
      ),
      Classification(
          uid="uid1",
          groundtruth="cat",
          predictions=["dog", "cat", "bird"],
          scores=[0.41, 0.39, 0.1],
      ),
  ]

  loader = DataLoader()
  loader.add_data(classifications)
  evaluator = loader.finalize()

  metrics = evaluator.evaluate()

  assert metrics[MetricType.Precision][0].to_dict() == {
      'type': 'Precision',
      'value': [0.5],
      'parameters': {
          'score_thresholds': [0.0],
          'hardmax': True,
          'label': 'dog'
      }
  }
  ```



  ```python
  from valor_lite.object_detection import DataLoader, Detection, BoundingBox, MetricType

  detections = [
      Detection(
          uid="uid0",
          groundtruths=[
              BoundingBox(
                  xmin=0, xmax=10,
                  ymin=0, ymax=10,
                  labels=["dog"]
              ),
              BoundingBox(
                  xmin=20, xmax=30,
                  ymin=20, ymax=30,
                  labels=["cat"]
              ),
          ],
          predictions=[
              BoundingBox(
                  xmin=1, xmax=11,
                  ymin=1, ymax=11,
                  labels=["dog", "cat", "bird"],
                  scores=[0.85, 0.1, 0.05]
              ),
              BoundingBox(
                  xmin=21, xmax=31,
                  ymin=21, ymax=31,
                  labels=["dog", "cat", "bird"],
                  scores=[0.34, 0.33, 0.33]
              ),
          ],
      ),
  ]

  loader = DataLoader()
  loader.add_bounding_boxes(detections)
  evaluator = loader.finalize()

  metrics = evaluator.evaluate()

  assert metrics[MetricType.Precision][0].to_dict() == {
      'type': 'Precision',
      'value': 0.5,
      'parameters': {
          'iou_threshold': 0.5,
          'score_threshold': 0.5,
          'label': 'dog'
      }
  }
  ```



  ```python
  import numpy as np
  from valor_lite.semantic_segmentation import DataLoader, Segmentation, Bitmask, MetricType

  segmentations = [
      Segmentation(
          uid="uid0",
          groundtruths=[
              Bitmask(
                  mask=np.random.randint(2, size=(10,10), dtype=np.bool_),
                  label="sky",
              ),
              Bitmask(
                  mask=np.random.randint(2, size=(10,10), dtype=np.bool_),
                  label="ground",
              )
          ],
          predictions=[
              Bitmask(
                  mask=np.random.randint(2, size=(10,10), dtype=np.bool_),
                  label="sky",
              ),
              Bitmask(
                  mask=np.random.randint(2, size=(10,10), dtype=np.bool_),
                  label="ground",
              )
          ]
      ),
  ]

  loader = DataLoader()
  loader.add_data(segmentations)
  evaluator = loader.finalize()

  print(metrics[MetricType.Precision][0])
  ```


pkgId: 0e235a75c73dfd6f18bfedd656e36a2c3df2c7878ef7321058b5af9e4a51f314
name: python-valsai-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for valsai
url: https://pypi.org/project/valsai/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-valsai-0.1.0-1.src.rpm
location_href: Packages/python-valsai-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ```
  pip install valsai
  ```



  This Python package contains two items - a CLI tool to use Vals from the command line, and an SDK to
  use Vals from Python code.

  All code is contained within `vals/`, separated by CLI and SDK. Note that many of the CLI functions
  are just thin wrappers around the SDK.



  We've provided a set of examples in `examples/`. They are organized as follows:

  - `suites/` - These are example JSON files, of the sort that you may use for `vals suite create <example.json>`.
  - `scripts/` - These are example Python scripts that leverage the sdk.



  Make an account at [https://platform.vals.ai](https://platform.vals.ai) and confirm your email.

  Then, go to [https://platform.vals.ai/auth](https://platform.vals/ai/auth) and create an API key.

  If you are using the command line, you should set the following:

  ```
  export VALS_API_KEY=<YOUR API KEY>
  ```

  If you're using the EU instance of vals, you should also set `export VALS_REGION=europe`. Include these in your .zshrc / .bashrc to make them permanent.

  See the documentation for passing in your API key directly via Python code for SDK usage.



  The CLI is run as follows:

  ```
  $ vals
  ```

  Use the `--help` flag at the top and subcommand level for guidance.

  Commands must be run from the pip environment the cli was installed in. Commands are split up into subcommand. Currently there are two subcommands:

  - `vals suite --help`: relating to creating / updating tests and suites
  - `vals run --help`: relating to creating and querying runs and run results.

  Full documentation of the CLI usage can be found in our documentation at [https://www.platform.vals.ai/docs/index.html#/cli](https://www.platform.vals.ai/docs/index.html#/cli)



  All of the functionality that is in the CLI can also be accessed via Python functions,
  as well as features only available in the SDK.

  See usage documentation in our docs: [https://www.platform.vals.ai/docs/index.html#/sdk](https://www.platform.vals.ai/docs/index.html#/sdk)





  Run the following command to install it locally. The -e flag is optional, but recommended, as it allows you to make changes to the code without reinstalling. The dev flag is required for dev-only depedencies.

  ```bash
  pip install -e ".[dev]"
  ```



  Add additional .graphql files to `vals/graphql`, then run the following command:

  ```
  ariadne-codegen --config codegen-config.toml
  ```

  NOTE: This will _overwrite_ anything in the `vals/graphql_client` directory.


pkgId: cb317b482011f63edeeff30115a8da4e92d19009547f7b250a2846b2d01de36f
name: python-vana-help
arch: noarch
version: 0.37.0
epoch: 0
release: 1
summary: Development documents and examples for vana
url: https://github.com/vana-com/vana-framework
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vana-0.37.0-1.src.rpm
location_href: Packages/python-vana-help-0.37.0-1.noarch.rpm
checksum_type: sha256
description:
  [Documentation](https://docs.vana.org/vana/quick-start-guide/satori-testnet) • [Discord](https://discord.gg/xx98TSE8) • [Network](https://satori.vanascan.io)
  </div>
  We believe in an open internet where users own their data and the AI models they contribute to.
  AI models should be created more like open source software: iteratively by a community. To make this possible, researchers need access to the world's best datasets that are held captive across walled gardens. Users can break down these walled gardens by exporting their own data.
  We are building towards a user-owned foundation model, trained by 100M users who contribute their data and compute.

  To get started with Vana, follow these steps:
  1. Clone the repository:
      ```shell
      git clone https://github.com/vana-com/vana-framework.git
      ```
  2. Install the required dependencies using poetry:
      ```shell
      poetry install
      ```
  3. Setup vanacli
      ```shell
      pip install vana
      ```

  Wallets are the core ownership and identity technology around which all functions on Vana are carried out.
  Vana wallets consists of a coldkey and hotkey where the coldkey may contain many hotkeys, while each hotkey can only belong to a single coldkey.
  Coldkeys store funds securely, and operate functions such as transfers and staking, while hotkeys are used for all online operations such as signing queries, running miners and validating.
  ```bash
  vanacli --help
  usage: vanacli <command> <command args> wallet [-h] {balance,create,new_hotkey,new_coldkey,regen_coldkey,regen_coldkeypub,regen_hotkey,update,history} ...
  positional arguments:
    {balance,create,new_hotkey,new_coldkey,regen_coldkey,regen_coldkeypub,regen_hotkey,update,history}
                          Commands for managing and viewing wallets.
      balance             Checks the balance of the wallet.
      create              Creates a new coldkey (for containing balance) under the specified path.
      new_hotkey          Creates a new hotkey (for running a miner) under the specified path.
      new_coldkey         Creates a new coldkey (for containing balance) under the specified path.
      regen_coldkey       Regenerates a coldkey from a passed value
      regen_coldkeypub    Regenerates a coldkeypub from the public part of the coldkey.
      regen_hotkey        Regenerates a hotkey from a passed mnemonic
      update              Updates the wallet security using NaCL instead of ansible vault.
      history             Fetch transfer history associated with the provided wallet
  options:
    -h, --help            show this help message and exit
  ```
  You should be able to view your keys by navigating to `~/.vana/wallets`
  ```bash
  $ tree ~/.vana/
      .vana/                  # Root directory.
          wallets/                # The folder containing all vana wallets.
              default/            # The name of your wallet, "default"
                  coldkey         # Your encrypted coldkey.
                  coldkeypub.txt  # Your coldkey public address
                  hotkeys/        # The folder containing all of your hotkeys.
                      default     # You unencrypted hotkey information.
  ```
  Your default wallet ```Wallet (default, default, ~/.vana/wallets/)``` is always used unless you specify otherwise.
  Be sure to store your mnemonics safely.
  If you lose your password to your wallet, or the access to the machine where the wallet is stored, you can always regenerate the coldkey using the mnemonic you saved from above.
  ```bash
  vanacli wallet regen_coldkey --mnemonic **** *** **** **** ***** **** *** **** **** **** ***** *****
  ```

  The command line interface (`vanacli`) is the primary command line tool for interacting with the Vana network.
  It can be used to deploy nodes, manage wallets, stake/unstake, nominate, transfer tokens, and more.

  To get the list of all the available commands and their descriptions, you can use:
  ```bash
  vanacli --help
  usage: vanacli <command> <command args>
  vana cli v0.0.1
  positional arguments:
    {root,r,roots,wallet,w,wallets,stake,st,stakes,su,info,i}
      root (r, roots)     Commands for managing and viewing the root network.
      wallet (w, wallets)
                          Commands for managing and viewing wallets.
      stake (st, stakes)  Commands for staking and removing stake from hotkey accounts.
      info (i)            Instructions for enabling autocompletion for the CLI.
  options:
    -h, --help            show this help message and exit
    --print-completion {bash,zsh,tcsh}
                           Print shell tab completion script
  ```

  The MIT License (MIT)
  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: 94b625cd2f91d8e9b90e29f395e558b38b7681bae2905af4fcfa176d22aee7d8
name: python-vantage-agent-help
arch: noarch
version: 2.5.17
epoch: 0
release: 1
summary: Development documents and examples for vantage-agent
url: https://pypi.org/project/vantage-agent/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vantage-agent-2.5.17-1.src.rpm
location_href: Packages/python-vantage-agent-help-2.5.17-1.noarch.rpm
checksum_type: sha256
description:
  To install the package from Pypi simply run `pip install vantage-agent`.



  1. Setup dependencies

      Dependencies and environment are managed in the project by [Poetry](https://python-poetry.org/). To initiate the development environment run:

      ```bash
      make install
      ```

  2. Setup `.env` parameters

      ```bash
      VANTAGE_AGENT_BASE_API_URL="<base-api-url>"
      VANTAGE_AGENT_OIDC_DOMAIN="<OIDC-domain>"
      VANTAGE_AGENT_OIDC_CLIENT_ID="<OIDC-audience>"
      VANTAGE_AGENT_OIDC_CLIENT_SECRET="<OIDC-app-client-id>"
      VANTAGE_AGENT_OIDC_USE_HTTPS="<OIDC-app-client-secret>"
      ```



  1. Run app

      ```bash
      vtg-run
      ```

      **Note**: this command assumes you're inside a virtual environment in which the package is installed.


pkgId: 8c32adbf63b4c16a68ab7d38549c2cb15aa4dfbf03184810d1dac2d8fa426bbc
name: python-vargram-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for vargram
url: https://pypi.org/project/vargram/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vargram-0.3.0-1.src.rpm
location_href: Packages/python-vargram-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  ![Docs Build Status](https://github.com/cjpalpallatoc/test-repo/actions/workflows/docs.yml/badge.svg?)
  ![Tests Status](https://github.com/cjpalpallatoc/test-repo/actions/workflows/tests.yml/badge.svg?)

  <div style="text-align: center;">
      <img src="https://github.com/pgcbioinfo/vargram/blob/main/docs/assets/images/vargram_header.png?raw=True" alt="VARGRAM Header" />
  </div>
  <h1 style="text-align:center;">VARGRAM (Visual ARrays for GRaphical Analysis of Mutations)</h1>


  🧬 VARGRAM is a Python package that makes it easy to generate insightful figures for genomic surveillance, born out of our experience during the COVID-19 pandemic. With the latest update, VARGRAM can be used to generate mutation profiles straight from sequence files by hooking into existing tools such as Nextclade. The figures can be easily customized within a Python script or Jupyter notebook using a declarative syntax.

  🔥 We are actively developing VARGRAM into a full visualization library for common use cases in molecular epidemiology. More modules will be added in the coming months. If you have a feature request or find a bug, please [submit an issue](https://github.com/pgcbioinfo/vargram/issues).



  Full installation instructions and tutorials are available on [the VARGRAM documentation website](https://pgcbioinfo.github.io/vargram/).



  Install with [pip](https://pip.pypa.io/en/stable/):
  ```bash
  pip install vargram
  ```
  Python version ≥3.11 is required.

  VARGRAM relies on [Nextclade](https://clades.nextstrain.org/) to perform mutation calling when sequence files are provided. Make sure to [download the Nextclade CLI](https://docs.nextstrain.org/projects/nextclade/en/stable/user/nextclade-cli/installation/index.html) and add it to the path. (Alternatively, you may provide Nextclade's analysis CSV output directly and VARGRAM can still produce a mutation profile without Nextclade installed.)



  To produce a mutation profile, VARGRAM requires a single FASTA file (or a directory of FASTA files) of samples, a FASTA file for the reference, and a genome annotation file following the [GFF3](https://docs.nextstrain.org/projects/nextclade/en/stable/user/input-files/03-genome-annotation.html) format.

  A mutation profile can be generated in just four lines of code:
  ```python
  from vargram import vargram # Importing the package

  vg = vargram(seq='path/to/covid_samples/', # Provide sample sequences
              ref='path/to/covid_reference.fa', # Provide reference sequence
              gene='path/to/covid_annotation.gff') # Provide genome annotation
  vg.profile() # Tell VARGRAM you want to create a mutation profile
  vg.show() # And show the resulting figure
  ```

  Alternatively, you can simply provide a CSV file. For example, you can upload your sequences to the [Nextclade web app](https://clades.nextstrain.org/) and download the analysis CSV output. VARGRAM recognizes this output and can process it:
  ```python
  from vargram import vargram

  vg = vargram(data='path/to/nextclade_analysis.csv') # Provide Nextclade analysis file
  vg.profile()
  vg.show()
  ```
  Calling the mutation profile this way does not require Nextclade CLI to be installed.



  A sample mutation profile is shown below:
  <div style="text-align: center;">
      <img src="https://github.com/pgcbioinfo/vargram/blob/main/docs/assets/images/readme_profile.png?raw=True" alt="mutation profile" />
  </div>

  Note that by default, VARGRAM favors placing genes with the most number of mutations first. Thus, the S gene above is shown at the very top. You may wish to force VARGRAM to show the genes in order based on the start position. You can do so by setting `vg.profile(order=True)`. The mutation profile above will then look like the following:

  <div style="text-align: center;">
      <img src="https://github.com/pgcbioinfo/vargram/blob/main/docs/assets/images/ordered_profile.png?raw=True" alt="mutation profile with genes ordered" />
  </div>


pkgId: f5d60a233304365bb195ef1f0627c1ba3f24aa4277fe7e2b39f61d98d3efd08d
name: python-variable-tracker-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for variable-tracker
url: https://github.com/vimal0207/variable-tracker
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-variable-tracker-0.1.1-1.src.rpm
location_href: Packages/python-variable-tracker-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  +----------+--------------+-------+
  | Variable | Change Type  | Value |
  +----------+--------------+-------+
  | total    | initialized  | 0     |
  | total    | modified     | 10    |
  | total    | modified     | 30    |
  | total    | returned     | 30    |
  +----------+--------------+-------+
  ```


pkgId: b34228512d05dd68505c6423e6c55c3089231cc52116e1319f4a27f7e78451e3
name: python-vastdb-help
arch: noarch
version: 1.3.4
epoch: 0
release: 1
summary: Development documents and examples for vastdb
url: https://github.com/vast-data/vastdb_sdk
rpm_license: Copyright (C) VAST Data Ltd.
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vastdb-1.3.4-1.src.rpm
location_href: Packages/python-vastdb-help-1.3.4-1.noarch.rpm
checksum_type: sha256
description:
  `vastdb` is a Python-based SDK designed for interacting
  with [VAST Database](https://vastdata.com/database)
  and [VAST Catalog](https://vastdata.com/blog/vast-catalog-treat-your-file-system-like-a-database),
  enabling schema and table management, efficient ingest, query and modification of columnar data.

  For more details, see [our whitepaper](https://vastdata.com/whitepaper/#TheVASTDataBase).


pkgId: 7262edef190b95c6fa3e196885808a3761fdfddf824b1124f4bcb32583b72422
name: python-vault-service-help
arch: noarch
version: 0.6.0
epoch: 0
release: 1
summary: Development documents and examples for vault-service
url: https://pypi.org/project/vault-service/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vault-service-0.6.0-1.src.rpm
location_href: Packages/python-vault-service-help-0.6.0-1.noarch.rpm
checksum_type: sha256
description:
  Retrieves a secret from HashiCorp Vault for the specified service, tenant, and secret name.
  **Parameters:**
  - `service_id`: The ID of the service.
  - `tenant_id`: The ID of the tenant.
  - `secret_name`: The name of the secret to retrieve.
  - `credentials`: Optional dictionary containing Vault credentials:
    ```python
    {
        'base_path': 'your-base-path',
        'app_role_id': 'your-app-role-id',
        'app_secret_id': 'your-app-secret-id'
    }
    ```
  **Returns:**
  - `dict`: The retrieved secret data
  - Raises `VaultError` if there's an issue with the Vault operation
  - Raises `SecretNotFoundError` if the secret doesn't exist


pkgId: 63c0a58df54ccadb0c6eee11fb2e24cb6d34e0e783a690000c63ec497dcd4f78
name: python-vaultrun-help
arch: noarch
version: 2.0.2
epoch: 0
release: 1
summary: Development documents and examples for vaultrun
url: https://github.com/RedHatQE/vaultrun
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vaultrun-2.0.2-1.src.rpm
location_href: Packages/python-vaultrun-help-2.0.2-1.noarch.rpm
checksum_type: sha256
description:
  Vault cli helper


  [rofi](https://github.com/davatorium/rofi) or [dmenu](https://tools.suckless.org/dmenu/) needs to be installed.
  Optionally, `xsel`, if exists, selected secrets will be copied to clipboard.

  config file should be located at `/home/{user}/.config/vaultrun/config.yaml` with:

  ```yaml
  name:
    mount_point: <Secret mount point>
    secret_path: <Secret path to query>
    
    role_id: <Role ID>
    secret_id: <Secret ID>
  ```



  from Pypi:

  ```bash
  python -m pip3 install vaultrun```
  ```

  Local installation:

  ```bash
  poetry install
  ```



  From Pypi:

  ```bash
  vaultrun
  ```

  Local run:

  ```bash
  poetry run vaultrun
  ```


pkgId: 9d40de42418bd3aa10a02477968147e3ef43589cccc36b7a41b8a132df7eb293
name: python-vdma-lif-help
arch: noarch
version: 1.0.0.6
epoch: 0
release: 1
summary: Development documents and examples for vdma-lif
url: https://github.com/continua-systems/vdma-lif.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vdma-lif-1.0.0.6-1.src.rpm
location_href: Packages/python-vdma-lif-help-1.0.0.6-1.noarch.rpm
checksum_type: sha256
description:
  JSON parsers and models for the VDMA - LIF (Layout Interchange Format), which is used for defining track layouts and exchanging information between the integrator of driverless transport vehicles and a third-party master control system.

  The models are generated from a json schema which can be found in the [vdma-lif repository](https://github.com/continua-systems/vdma-lif.git).



  ```bash
  pip install vmda_lif
  ```




  ```python
  from vdma_lif.parser import LIFParser
  layout_collection = LIFParser.from_file("example.lif.json")
  ```


  ```python
  from vdma_lif.parser import LIFParser
  layout_collection = LIFParser.from_json(layout_collection_str)
  ```


  ```
  layout_collection_str = LIFParser.to_json(layout_collection)
  ```


  ```python
  LIFParser.to_file(layout_collection, "example.lif.json")
  ```



  This project is licensed under the **MIT License**.



  This repository is maintained by Continua Systems GmbH. For any inquiries, please contact us at:

  * Website: https://continua.systems
  * Email: info@continua.systems


pkgId: 9793781ec82a99432588d20774752d04e31554247de452b46bbe0a646859770a
name: python-vecs-help
arch: noarch
version: 0.4.5
epoch: 0
release: 1
summary: Development documents and examples for vecs
url: https://github.com/supabase/vecs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vecs-0.4.5-1.src.rpm
location_href: Packages/python-vecs-help-0.4.5-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://supabase.github.io/vecs/latest/" target="_blank">https://supabase.github.io/vecs/latest/</a>


pkgId: 1d4676c56d8f63fc80f344f981781e88212d8072db9ccacc88b2977224129256
name: python-vectara-agentic-help
arch: noarch
version: 0.1.21
epoch: 0
release: 1
summary: Development documents and examples for vectara-agentic
url: https://github.com/vectara/py-vectara-agentic
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vectara-agentic-0.1.21-1.src.rpm
location_href: Packages/python-vectara-agentic-help-0.1.21-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://vectara.github.io/vectara-agentic-docs">Documentation</a> ·
    <a href="#examples">Examples</a> ·
    <a href="https://discord.gg/S9dwgCNEFs">Discord</a>
  </p>

  <p align="center">
    <a href="https://opensource.org/licenses/Apache-2.0">
      <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License">
    </a>
    <a href="https://github.com/vectara/py-vectara-agentic/graphs/commit-activity">
      <img src="https://img.shields.io/badge/Maintained%3F-yes-green.svg" alt="Maintained">
    </a>
    <a href="https://twitter.com/vectara">
      <img src="https://img.shields.io/twitter/follow/vectara.svg?style=social&label=Follow%20%40Vectara" alt="Twitter">
    </a>
  </p>



  `vectara-agentic` is a Python library for developing powerful AI assistants and agents using Vectara and Agentic-RAG. It leverages the LlamaIndex Agent framework, customized for use with Vectara.

  <p align="center">
  <img src="https://raw.githubusercontent.com/vectara/py-vectara-agentic/main/.github/assets/diagram1.png" alt="Agentic RAG diagram" width="100%" style="vertical-align: middle;">
  </p>



  - Enables easy creation of custom AI assistants and agents.
  - Create a Vectara RAG tool with a single line of code.
  - Supports `ReAct`, `OpenAIAgent`, `LATS' and `LLMCompiler` agent types.
  - Includes pre-built tools for various domains (e.g., finance, legal).
  - Integrates with various LLM inference services like OpenAI, Anthropic, Gemini, GROQ, Together.AI, Cohere and Fireworks
  - Built-in support for observability with Arize Phoenix



  Check out our example AI assistants:

  - [Financial Assistant](https://huggingface.co/spaces/vectara/finance-chat)
  - [Justice Harvard Teaching Assistant](https://huggingface.co/spaces/vectara/Justice-Harvard)
  - [Legal Assistant](https://huggingface.co/spaces/vectara/legal-agent)




  - [Vectara account](https://console.vectara.com/signup/?utm_source=github&utm_medium=code&utm_term=DevRel&utm_content=vectara-agentic&utm_campaign=github-code-DevRel-vectara-agentic)
  - A Vectara corpus with an [API key](https://docs.vectara.com/docs/api-keys)
  - [Python 3.10 or higher](https://www.python.org/downloads/)
  - OpenAI API key (or API keys for Anthropic, TOGETHER.AI, Fireworks AI, Cohere, GEMINI or GROQ, if you choose to use them)



  ```bash
  pip install vectara-agentic
  ```





  ```python
  import os
  from vectara_agentic.tools import VectaraToolFactory
  from pydantic import BaseModel, Field

  vec_factory = VectaraToolFactory(
      vectara_api_key=os.environ['VECTARA_API_KEY'],
      vectara_customer_id=os.environ['VECTARA_CUSTOMER_ID'],
      vectara_corpus_id=os.environ['VECTARA_CORPUS_ID']
  )

  class QueryFinancialReportsArgs(BaseModel):
      query: str = Field(..., description="The user query.")
      year: int = Field(..., description="The year. An integer between {min(years)} and {max(years)}.")
      ticker: str = Field(..., description="The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")

  query_financial_reports_tool = vec_factory.create_rag_tool(
      tool_name="query_financial_reports",
      tool_description="Query financial reports for a company and year",
      tool_args_schema=QueryFinancialReportsArgs,
  )
  ```



  In addition to RAG tools, you can generate a lot of other types of tools the agent can use. These could be mathematical tools, tools
  that call other APIs to get more information, or any other type of tool.

  See [Agent Tools](#agent-tools) for more information.



  ```python
  from vectara_agentic import Agent

  agent = Agent(
      tools=[query_financial_reports_tool],
      topic="10-K financial reports",
      custom_instructions="""
          - You are a helpful financial assistant in conversation with a user. Use your financial expertise when crafting a query to the tool, to ensure you get the most accurate information.
          - You can answer questions, provide insights, or summarize any information from financial reports.
          - A user may refer to a company's ticker instead of its full name - consider those the same when a user is asking about a company.
          - When calculating a financial metric, make sure you have all the information from tools to complete the calculation.
          - In many cases you may need to query tools on each sub-metric separately before computing the final metric.
          - When using a tool to obtain financial data, consider the fact that information for a certain year may be reported in the following year's report.
          - Report financial data in a consistent manner. For example if you report revenue in thousands, always report revenue in thousands.
      """
  )
  ```



  ```python
  response = agent.chat("What was the revenue for Apple in 2021?")
  print(response)
  ```



  `vectara-agentic` provides a few tools out of the box:
  1. **Standard tools**:
  - `summarize_text`: a tool to summarize a long text into a shorter summary (uses LLM)
  - `rephrase_text`: a tool to rephrase a given text, given a set of rephrase instructions (uses LLM)

  2. **Legal tools**: a set of tools for the legal vertical, such as:
  - `summarize_legal_text`: summarize legal text with a certain point of view
  - `critique_as_judge`: critique a legal text as a judge, providing their perspective

  3. **Financial tools**: based on tools from Yahoo! Finance:
  - tools to understand the financials of a public company like: `balance_sheet`, `income_statement`, `cash_flow`
  - `stock_news`: provides news about a company
  - `stock_analyst_recommendations`: provides stock analyst recommendations for a company.

  4. **Database tools**: providing tools to inspect and query a database
  - `list_tables`: list all tables in the database
  - `describe_tables`: describe the schema of tables in the database
  - `load_data`: returns data based on a SQL query
  - `load_sample_data`: returns the first 25 rows of a table
  - `load_unique_values`: returns the top unique values for a given column

  In addition, we include various other tools from LlamaIndex ToolSpecs:
  * Tavily search
  * EXA.AI
  * arxiv
  * neo4j & Kuzu for Graph integration
  * Google tools (including gmail, calendar, and search)
  * Slack

  Note that some of these tools may require API keys as environment variables

  You can create your own tool directly from a Python function using the `create_tool()` method of the `ToolsFactory` class:

  ```python
  def mult_func(x, y):
      return x * y

  mult_tool = ToolsFactory().create_tool(mult_func)
  ```



  Configure `vectara-agentic` using environment variables:

  - `VECTARA_AGENTIC_AGENT_TYPE`: valid values are `REACT`, `LLMCOMPILER`, `LATS` or `OPENAI` (default: `OPENAI`)
  - `VECTARA_AGENTIC_MAIN_LLM_PROVIDER`: valid values are `OPENAI`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `COHERE`, `GEMINI` or `FIREWORKS` (default: `OPENAI`)
  - `VECTARA_AGENTIC_MAIN_MODEL_NAME`: agent model name (default depends on provider)
  - `VECTARA_AGENTIC_TOOL_LLM_PROVIDER`: tool LLM provider (default: `OPENAI`)
  - `VECTARA_AGENTIC_TOOL_MODEL_NAME`: tool model name (default depends on provider)
  - `VECTARA_AGENTIC_OBSERVER_TYPE`: valid values are `ARIZE_PHOENIX` or `NONE` (default: `NONE`)

  When creating a VectaraToolFactory, you can pass in a `vectara_api_key`, `vectara_customer_id`, and `vectara_corpus_id` to the factory. If not passed in, it will be taken from the environment variables. Note that `VECTARA_CORPUS_ID` can be a single ID or a comma-separated list of IDs (if you want to query multiple corpora).





  The custom instructions you provide to the agent guide its behavior.
  Here are some guidelines when creating your instructions:
  - Write precise and clear instructions, without overcomplicating.
  - Consider edge cases and unusual or atypical scenarios.
  - Be cautious to not over-specify behavior based on your primary use-case, as it may limit the agent's ability to behave properly in others.



  The `Agent` class defines a few helpful methods to help you understand the internals of your application.
  * The `report()` method prints out the agent object’s type, the tools, and the LLMs used for the main agent and tool calling.
  * The `token_counts()` method tells you how many tokens you have used in the current session for both the main agent and tool calling LLMs. This can be helpful if you want to track spend by token.



  The `Agent` class supports serialization. Use the `dumps()` to serialize and `loads()` to read back from a serialized stream.



  vectara-agentic supports observability via the existing integration of LlamaIndex and Arize Phoenix.
  First, set `os["VECTARA_AGENTIC_OBSERVER_TYPE"] = "ARIZE_PHOENIX"`.
  Then you can use Arize Phoenix in three ways:
  1. **Locally**.
     1. If you have a local phoenix server that you've run using e.g. `python -m phoenix.server.main serve`, vectara-agentic will send all traces to it.
     2. If not, vectara-agentic will run a local instance during the agent's lifecycle, and will close it when finished.
     3. In both cases, traces will be sent to the local instance, and you can see the dashboard at `http://localhost:6006`
  2. **Hosted Instance**. In this case the traces are sent to the Phoenix instances hosted on Arize.
     1. Go to `https://app.phoenix.arize.com`, setup an account if you don't have one.
     2. create an API key and put it in the `PHOENIX_API_KEY` variable. This variable indicates you want to use the hosted version.
     3. To view the traces go to `https://app.phoenix.arize.com`.

  Now when you run your agent, all call traces are sent to Phoenix and recorded.
  In addition, vectara-agentic also records `FCS` (factual consistency score, aka HHEM) values into Arize for every Vectara RAG call. You can see those results in the `Feedback` column of the arize UI.



  `vectara-agentic` can be easily hosted locally or on a remote machine behind an API endpoint, by following theses steps:


  Ensure that you have your API key set up as an environment variable:

  ```
  export VECTARA_AGENTIC_API_KEY=<YOUR-ENDPOINT-API-KEY>
  ```

  if you don't specify an Endpoint API key it uses the default "dev-api-key".


  Initialize the agent and start the FastAPI server by following this example:


  ```
  from vectara_agentic.agent import Agent
  from vectara_agentic.agent_endpoint import start_app
  agent = Agent(...)            # Initialize your agent with appropriate parameters
  start_app(agent)
  ```

  You can customize the host and port by passing them as arguments to `start_app()`:
  * Default: host="0.0.0.0" and port=8000.
  For example:
  ```
  start_app(agent, host="0.0.0.0", port=8000)
  ```


  Once the server is running, you can interact with it using curl or any HTTP client. For example:

  ```
  curl -G "http://<remote-server-ip>:8000/chat" \
  --data-urlencode "message=What is Vectara?" \
  -H "X-API-Key: <YOUR-ENDPOINT-API-KEY>"
  ```



  We welcome contributions! Please see our [contributing guide](https://github.com/vectara/py-vectara-agentic/blob/main/CONTRIBUTING.md) for more information.



  This project is licensed under the Apache 2.0 License. See the [LICENSE](https://github.com/vectara/py-vectara-agentic/blob/master/LICENSE) file for details.



  - Website: [vectara.com](https://vectara.com)
  - Twitter: [@vectara](https://twitter.com/vectara)
  - GitHub: [@vectara](https://github.com/vectara)
  - LinkedIn: [@vectara](https://www.linkedin.com/company/vectara/)
  - Discord: [Join our community](https://discord.gg/GFb8gMz6UH)


pkgId: 58432335ad9a2e965d04002de797af21d580aab977251068ef9a2978f0fc71ac
name: python-vectara-help
arch: noarch
version: 0.2.39
epoch: 0
release: 1
summary: Development documents and examples for vectara
url: https://pypi.org/project/vectara/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vectara-0.2.39-1.src.rpm
location_href: Packages/python-vectara-help-0.2.39-1.noarch.rpm
checksum_type: sha256
description:
  Install the library via pip:
  ```bash
  pip install vectara
  ```


  API reference documentation is available [here](https://vectara.docs.buildwithfern.com/).

  Complete examples can be found in the [Getting Started notebooks](./examples/01_getting_started).

  First, create an SDK client.<br />
  You can use either an `api_key` or OAuth (`client_id` and `client_secret`) for [authentication](https://docs.vectara.com/docs/console-ui/api-access-overview).
  ```python
  from vectara import Vectara

  client = Vectara(
      api_key="YOUR_API_KEY"
  )

  client = Vectara(
      client_id="YOUR_CLIENT_ID",
      client_secret="YOUR_CLIENT_SECRET",
  )
  ```
  If you don't already have a corpus, you can create it using the SDK:
  ```python
  client.corpora.create(name="my-corpus", key="my-corpus-key")
  ```

  You can add documents to a corpus in two formats: [structured](https://docs.vectara.com/docs/learn/select-ideal-indexing-api#structured-document-definition) or [core](https://docs.vectara.com/docs/learn/select-ideal-indexing-api#core-document-definition).<br/> For more information, refer to the [Indexing Guide](https://docs.vectara.com/docs/learn/select-ideal-indexing-api).
  Here is an example for adding a Structured document
    ```python
    from vectara import StructuredDocument, StructuredDocumentSection
    client.documents.create(
        corpus_key="my-corpus-key",
        request=StructuredDocument(
            id="my-doc-id",
            type="structured",
            sections=[
              StructuredDocumentSection(
                  id="id_1",
                  title="A nice title.",
                  text="I'm a nice document section.",
                  metadata={'section': '1.1'}
              ),
              StructuredDocumentSection(
                  id="id_2",
                  title="Another nice title.",
                  text="I'm another document section on something else.",
                  metadata={'section': '1.2'}
              ),
            ],
            metadata={'url': 'https://example.com'}
        ),
    )
    ```
  And here is one with Core document:
  ```python
  from vectara import CoreDocument, CoreDocumentPart
  client.documents.create(
      corpus_key="my-corpus-key",
      request=CoreDocument(
          id="my-doc-id",
          type="core",
          document_parts=[
              CoreDocumentPart(
                  text="I'm a first document part.",
                  metadata={'author': 'Ofer'}
              )
              CoreDocumentPart(
                  text="I'm a second document part.",
                  metadata={'author': 'Adeel'}
              )
          ],
          metadata={'url': 'https://example.com'}
      ),
  )
  ```

  In addition to creating a document as shown above (using StructuredDocument or CoreDocument), you can also upload files (such as PDFs or Word Documents) directly to Vectara.
  In this case Vectara will parse the files automatically, extract text and metadata, chunk them and add them to the corpus.
  Using the SDK you need to provide both the file name, the binary content of the file, and the content_type, as follows:
  ```python
  filename = "examples.pdf"
  with open(filename, "rb") as f:
      content = f.read()
  client.upload.file(
      'my-corpus-key',
      file=content,
      filename=filename,
      metadata={"author": "Adeel"}
  )
  ```

  With the SDK it's super easy to run a query from one or more corpora. For more detailed information, see this [Query API guide](https://docs.vectara.com/docs/api-reference/search-apis/search)
  A query uses two important objects:
  * The `SearchCorporaParameters` object defines parameters for search such as hybrid search, metadata filtering or reranking
  * The `GenerationParameters` object defines parameters for the generative step.
  Here is an example query for our corpus above:
  ```python
  search = SearchCorporaParameters(
          corpora=[
              KeyedSearchCorpus(
                  corpus_key="my-corpus-key",
                  metadata_filter="",
                  lexical_interpolation=0.005,
              )
          ],
          context_configuration=ContextConfiguration(
              sentences_before=2,
              sentences_after=2,
          ),
          reranker=CustomerSpecificReranker(
              reranker_id="rnk_272725719"
          ),
      )
  generation = GenerationParameters(
          response_language="eng",
          enable_factual_consistency_score=True,
      )
  client.query(
      query="Am I allowed to bring pets to work?",
      search=search,
      generation=generation
  )
  ```

  Vectara [chat](https://docs.vectara.com/docs/api-reference/chat-apis/chat-apis-overview) provides a way to automatically store chat history to support multi-turn conversations.
  Here is an example of how to start a chat with the SDK:
  ```python
  from vectara import SearchCorporaParameters
  search = SearchCorporaParameters(
          corpora=[
              KeyedSearchCorpus(
                  corpus_key="test-corpus",
                  metadata_filter="",
                  lexical_interpolation=0.005,
              )
          ],
          context_configuration=ContextConfiguration(
              sentences_before=2,
              sentences_after=2,
          ),
          reranker=CustomerSpecificReranker(
              reranker_id="rnk_272725719"
          ),
      )
  generation = GenerationParameters(
          response_language="eng",
          citations=CitationParameters(
              style="none",
          ),
          enable_factual_consistency_score=True,
      )
  chat = ChatParameters(store=True)
  session = client.create_chat_session(
      search=search,
      generation=generation,
      chat_config=chat,
  )
  response_1 = session.chat(query="Tell me about machine learning.")
  print(response_1.answer)
  response_2 = session.chat(query="what is generative AI?")
  print(response_2.answer)
  ```
  Note that we used the `create_chat_session` with `chat_config` set for storing chat history. The resulting session can then be used for turn-by-turn chat, simply by using the `chat()` method of the session object.

  The SDK supports streaming responses for both query and chat. When using streaming, the response will be a generator that you can iterate.
  Here's an example of calling `query_stream`:
  Streaming the query response
  ```python
  from vectara import SearchCorporaParameters
  search = SearchCorporaParameters(
      corpora=[...],
  )
  generation = GenerationParameters(...)
  response = client.query_stream(
      query="Am I allowed to bring pets to work?",
      search=search,
      generation=generation
  )
  for chunk in response:
      yield chunk
  ```
  And streaming the chat response:
  ```python
  from vectara import SearchCorporaParameters
  search = SearchCorporaParameters(
      corpora=[...],
  )
  generation = GenerationParameters(...)
  chat_params = ChatParameters(store=True)
  session = client.create_chat_session(
      search=search_params,
      generation=generation_params,
      chat_config=chat_params,
  )
  response = session.chat_stream(query="Tell me about machine learning.")
  for chunk in response:
      yield response
  ```

  There is a lot more functionality packed into the SDK, matching [all API endpoints](https://docs.vectara.com/docs/rest-api) that are available in Vectara including for things like managing documents, corpora, api keys, users, and even for query history retrieval.

  When the API returns a non-success status code (4xx or 5xx response), a subclass of the following error
  will be thrown.
  ```python
  from vectara.core.api_error import ApiError
  try:
      client.query(...)
  except ApiError as e:
      print(e.status_code)
      print(e.body)
  ```

  Paginated requests will return a `SyncPager` or `AsyncPager`, which can be used as generators for the underlying object.
  ```python
  from vectara import Vectara
  client = Vectara(
      api_key="YOUR_API_KEY",
      client_id="YOUR_CLIENT_ID",
      client_secret="YOUR_CLIENT_SECRET",
  )
  response = client.corpora.list(
      limit=1,
  )
  for item in response:
      yield item

  for page in response.iter_pages():
      yield page
  ```

  For more information related to customization, Timeouts and Retries in the SDK, refer to the [Advanced Usage Guide](./advanced.md)

  The Python library can be used in a number of environments with different requirements:
  1. **Notebooks** - using implicit configuration from a users home directory
  2. **Docker Environments** - using ENV variables for configuration
  3. **Complex Applications** - allowing explicit configuration from mutable stores (e.g. RDBMS / NoSQL)
  For more details, refer to the [Configuration Guide](./configuration.md)

  👤 **Vectara**
  - Website: https://vectara.com
  - Twitter: [@vectara](https://twitter.com/vectara)
  - GitHub: [@vectara](https://github.com/vectara)
  - LinkedIn: [@vectara](https://www.linkedin.com/company/vectara/)
  - Discord: [@vectara](https://discord.gg/GFb8gMz6UH)

  Contributions, issues and feature requests are welcome!<br/>
  Feel free to check [issues page](https://github.com/vectara/python-sdk/issues). You can also take a look at the [contributing guide](./contributing.md).

  Give a ⭐️ if this project helped you!


pkgId: f2d35d39656c0a70524f074619bc715e45df308cd235964c6f154e0bcfd4300f
name: python-vectice-help
arch: noarch
version: 24.4.10.0
epoch: 0
release: 1
summary: Development documents and examples for vectice
url: https://www.vectice.com
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vectice-24.4.10.0-1.src.rpm
location_href: Packages/python-vectice-help-24.4.10.0-1.noarch.rpm
checksum_type: sha256
description:
  Auto-documentation for ML projects & their governance. View https://github.com/vectice/GettingStarted to get started.



  Official documentation for Vectice can be found at https://docs.vectice.com.


pkgId: 81afd6fb9025a3e876c94861bf71bfaadf47c651e9535902005806c8a591fa00
name: python-vectocore-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for vectocore
url: https://www.vectocore.com/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vectocore-0.3.0-1.src.rpm
location_href: Packages/python-vectocore-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Vectocore is a simple Python package for working with vector cores.



  You can install the package using pip:


pkgId: 18a5e9762f611ad9c051e65169d45f7f3880fa7544e1385832ae0b7fa181d7dd
name: python-vectorbt-help
arch: noarch
version: 0.27.0
epoch: 0
release: 1
summary: Development documents and examples for vectorbt
url: https://github.com/polakowo/vectorbt
rpm_license: Apache 2.0 with Commons Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vectorbt-0.27.0-1.src.rpm
location_href: Packages/python-vectorbt-help-0.27.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">
      <a href="https://vectorbt.pro/" alt="https://vectorbt.pro/">
          <img src="https://raw.githubusercontent.com/polakowo/vectorbt/master/docs/docs/assets/logo/header-pro.svg" />
      </a>
  </div>
  <div align="center">
      <a href="https://vectorbt.dev/" alt="https://vectorbt.dev/">
          <img src="https://raw.githubusercontent.com/polakowo/vectorbt/master/docs/docs/assets/logo/header.svg" />
      </a>
  </div>
  <br>
  <p align="center">
      <a href="https://pepy.tech/project/vectorbt" alt="Downloads">
          <img src="https://pepy.tech/badge/vectorbt" />
      </a>
      <a href="https://pypi.org/project/vectorbt" alt="PyPi">
          <img src="https://img.shields.io/pypi/v/vectorbt?color=blueviolet" />
      </a>
      <a href="https://github.com/polakowo/vectorbt/blob/master/LICENSE.md" alt="License">
  	<img src="https://img.shields.io/badge/license-Fair%20Code-yellow" />
      </a>
      <a href="https://codecov.io/gh/polakowo/vectorbt" alt="codecov">
          <img src="https://codecov.io/gh/polakowo/vectorbt/branch/master/graph/badge.svg?token=YTLNAI7PS3" />
      </a>
      <a href="https://vectorbt.dev/" alt="Website">
          <img src="https://img.shields.io/website?url=https://vectorbt.dev/" />
      </a>
      <a href="https://mybinder.org/v2/gh/polakowo/vectorbt/HEAD?urlpath=lab" alt="Binder">
          <img src="https://img.shields.io/badge/launch-binder-d6604a" />
      </a>
      <a href="https://gitter.im/vectorbt/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge" alt="Join the chat at https://gitter.im/vectorbt/community">
          <img src="https://badges.gitter.im/vectorbt.svg" />
      </a>
  </p>
  <p align="center">
      <a href="https://pypi.org/project/vectorbt" alt="Python Versions">
          <img src="https://img.shields.io/pypi/pyversions/vectorbt.svg?logo=python&logoColor=white" />
      </a>
  </p>



  vectorbt allows you to easily backtest strategies with a couple of lines of Python code.

  * Here is how much profit we would have made if we invested $100 into Bitcoin in 2014:

  ```python
  import vectorbt as vbt

  price = vbt.YFData.download('BTC-USD').get('Close')

  pf = vbt.Portfolio.from_holding(price, init_cash=100)
  pf.total_profit()
  ```

  ```plaintext
  8961.008555963961
  ```

  * Buy whenever 10-day SMA crosses above 50-day SMA and sell when opposite:

  ```python
  fast_ma = vbt.MA.run(price, 10)
  slow_ma = vbt.MA.run(price, 50)
  entries = fast_ma.ma_crossed_above(slow_ma)
  exits = fast_ma.ma_crossed_below(slow_ma)

  pf = vbt.Portfolio.from_signals(price, entries, exits, init_cash=100)
  pf.total_profit()
  ```

  ```plaintext
  16423.251963801864
  ```

  * Generate 1,000 strategies with random signals and test them on BTC and ETH:

  ```python
  import numpy as np

  symbols = ["BTC-USD", "ETH-USD"]
  price = vbt.YFData.download(symbols, missing_index='drop').get('Close')

  n = np.random.randint(10, 101, size=1000).tolist()
  pf = vbt.Portfolio.from_random_signals(price, n=n, init_cash=100, seed=42)

  mean_expectancy = pf.trades.expectancy().groupby(['randnx_n', 'symbol']).mean()
  fig = mean_expectancy.unstack().vbt.scatterplot(xaxis_title='randnx_n', yaxis_title='mean_expectancy')
  fig.show()
  ```

  ![rand_scatter.svg](https://raw.githubusercontent.com/polakowo/vectorbt/master/docs/docs/assets/images/usage_rand_scatter.svg)

  * For fans of hyperparameter optimization: here is a snippet for testing 10,000 window combinations of a
  dual SMA crossover strategy on BTC, USD, and LTC:

  ```python
  symbols = ["BTC-USD", "ETH-USD", "LTC-USD"]
  price = vbt.YFData.download(symbols, missing_index='drop').get('Close')

  windows = np.arange(2, 101)
  fast_ma, slow_ma = vbt.MA.run_combs(price, window=windows, r=2, short_names=['fast', 'slow'])
  entries = fast_ma.ma_crossed_above(slow_ma)
  exits = fast_ma.ma_crossed_below(slow_ma)

  pf_kwargs = dict(size=np.inf, fees=0.001, freq='1D')
  pf = vbt.Portfolio.from_signals(price, entries, exits, **pf_kwargs)

  fig = pf.total_return().vbt.heatmap(
      x_level='fast_window', y_level='slow_window', slider_level='symbol', symmetric=True,
      trace_kwargs=dict(colorbar=dict(title='Total return', tickformat='%')))
  fig.show()
  ```

  <img width="650" src="https://raw.githubusercontent.com/polakowo/vectorbt/master/docs/docs/assets/images/usage_dmac_heatmap.gif">

  Digging into each strategy configuration is as simple as indexing with pandas:

  ```python
  pf[(10, 20, 'ETH-USD')].stats()
  ```

  ```plaintext
  Start                          2015-08-07 00:00:00+00:00
  End                            2021-08-01 00:00:00+00:00
  Period                                2183 days 00:00:00
  Start Value                                        100.0
  End Value                                  620402.791485
  Total Return [%]                           620302.791485
  Benchmark Return [%]                        92987.961948
  Max Gross Exposure [%]                             100.0
  Total Fees Paid                             10991.676981
  Max Drawdown [%]                               70.734951
  Max Drawdown Duration                  760 days 00:00:00
  Total Trades                                          54
  Total Closed Trades                                   53
  Total Open Trades                                      1
  Open Trade PnL                              67287.940601
  Win Rate [%]                                   52.830189
  Best Trade [%]                               1075.803607
  Worst Trade [%]                               -29.593414
  Avg Winning Trade [%]                          95.695343
  Avg Losing Trade [%]                          -11.890246
  Avg Winning Trade Duration    35 days 23:08:34.285714286
  Avg Losing Trade Duration                8 days 00:00:00
  Profit Factor                                   2.651143
  Expectancy                                   10434.24247
  Sharpe Ratio                                    2.041211
  Calmar Ratio                                      4.6747
  Omega Ratio                                     1.547013
  Sortino Ratio                                   3.519894
  Name: (10, 20, ETH-USD), dtype: object
  ```

  The same for plotting:

  ```python
  pf[(10, 20, 'ETH-USD')].plot().show()
  ```

  ![dmac_portfolio.svg](https://raw.githubusercontent.com/polakowo/vectorbt/master/docs/docs/assets/images/usage_dmac_portfolio.svg)

  It's not all about backtesting - vectorbt can be used to facilitate financial data analysis and visualization.

  * Let's generate a GIF that animates the %B and bandwidth of Bollinger Bands for different symbols:

  ```python
  symbols = ["BTC-USD", "ETH-USD", "ADA-USD"]
  price = vbt.YFData.download(symbols, period='6mo', missing_index='drop').get('Close')
  bbands = vbt.BBANDS.run(price)

  def plot(index, bbands):
      bbands = bbands.loc[index]
      fig = vbt.make_subplots(
          rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.15,
          subplot_titles=('%B', 'Bandwidth'))
      fig.update_layout(template='vbt_dark', showlegend=False, width=750, height=400)
      bbands.percent_b.vbt.ts_heatmap(
          trace_kwargs=dict(zmin=0, zmid=0.5, zmax=1, colorscale='Spectral', colorbar=dict(
              y=(fig.layout.yaxis.domain[0] + fig.layout.yaxis.domain[1]) / 2, len=0.5
          )), add_trace_kwargs=dict(row=1, col=1), fig=fig)
      bbands.bandwidth.vbt.ts_heatmap(
          trace_kwargs=dict(colorbar=dict(
              y=(fig.layout.yaxis2.domain[0] + fig.layout.yaxis2.domain[1]) / 2, len=0.5
          )), add_trace_kwargs=dict(row=2, col=1), fig=fig)
      return fig

  vbt.save_animation('bbands.gif', bbands.wrapper.index, plot, bbands, delta=90, step=3, fps=3)
  ```

  ```plaintext
  100%|██████████| 31/31 [00:21<00:00,  1.21it/s]
  ```

  <img width="750" src="https://raw.githubusercontent.com/polakowo/vectorbt/master/docs/docs/assets/images/usage_bbands.gif">

  And this is just the tip of the iceberg of what's possible. Check out the [website](https://vectorbt.dev/) to learn more.



  ```sh
  pip install -U vectorbt
  ```

  To also install optional dependencies:

  ```sh
  pip install -U "vectorbt[full]"
  ```



  [Google Colaboratory](https://colab.research.google.com/drive/1ibqyrf6LPFlzRb6mkPpl3hxqL6ryNBXI?usp=sharing)



  This work is [fair-code](http://faircode.io/) distributed under [Apache 2.0 with Commons Clause](https://github.com/polakowo/vectorbt/blob/master/LICENSE.md) license.
  The source code is open and everyone (individuals and organizations) can use it for free.
  However, it is not allowed to sell products and services that are mostly just this software.

  If you have any questions about this or want to apply for a license exception, please [contact the author](mailto:olegpolakow@gmail.com).

  Installing optional dependencies may be subject to a more restrictive license.



  [![Star History Chart](https://api.star-history.com/svg?repos=polakowo/vectorbt&type=Timeline)](https://star-history.com/#polakowo/vectorbt&Timeline)



  This software is for educational purposes only. Do not risk money which you are afraid to lose.
  USE THE SOFTWARE AT YOUR OWN RISK. THE AUTHORS AND ALL AFFILIATES ASSUME NO RESPONSIBILITY FOR YOUR TRADING RESULTS.


pkgId: 7c9801a7ac1e2e878547f645ea18b7d5d95a94798e0a71d058c66776d08a9257
name: python-veetility-help
arch: noarch
version: 0.5.1
epoch: 0
release: 1
summary: Development documents and examples for veetility
url: https://pypi.org/project/veetility/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-veetility-0.5.1-1.src.rpm
location_href: Packages/python-veetility-help-0.5.1-1.noarch.rpm
checksum_type: sha256
description:
  A library to help create python pipelines for processing Tracer Data

  [Full Online Documentation](https://vaynermedia-london.github.io/veetility/)

  This is primarily for working with Social Media Organic and Paid Advertisement Data but also contains
  generic functions for writing to postgreSQL and snowflake databases, creating notifications in Slack
  Channels and writing to Google Sheets


  ```
  pip install veetility
  ```
  To upgrade the library after an update
  ```
  pip install veetility --upgrade
  ```

  An instance of the "UtilityFunctions" class can be initiated with the ability to read/write with
  google sheets and also to read/write to tables in a postgreSQL database. However none of these
  are mandatory.


  In order to use the functions that read/write from google sheets then a dictionary
  needs to be passed to the "gspread_auth_dict" argument.
  This dictionary can be obtained from a google API credentials JSON file.

  The instructions for creating this JSON file can be found from the [gspread documentation](https://docs.gspread.org/en/latest/oauth2.html)

  Then copy the JSON information in curly brackets as a python dictionary into the gspread.service_account_from_dict() authentication method. The "client_email" parameter in the JSON material is the email address of the google sheet
  client we have created. **This email address must be given read or write access to any google sheet you want to
  interact with.**


  The following correction parameters need to be passed in during initialisation of the class instance

  1. db_name e.g. "vayner_external_XXXXXXXXXXX"
  2. db_host e.g. "dashboard-vayner-XXXXXXXXXXXXXXXXXXXX.rds.amazonaws.com"
  3. db_port e.g. "5432" (this is the default for postgreSQL)
  4. db_user e.g. "tom.jones"
  5. db_password e.g. "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"


  It is advisable to put the parameters into a config.py file (cf) which can then be imported into
  the main script

  ```
  import config as cf
  from veetility import utility_functions

  util = utility_functions.UtilityFunctions(cf.google_sheet_auth_dict,cf.db_user,
                                            cf.db_password,cf.db_host,
                                            cf.db_port, cf.db_name)
  ```


  Once an instance of the class UtilityFunctions has been created, e.g. "util" then functions (methods)
  of the class can be used e.g. "write_to_gsheet()".

  This can write a pandas.DataFrame to any google sheet the "client_email" has been given "editor" access to.
  First pass in the name of the Google Sheet workbook, then the tab of the workbook, then the pandas.DataFrame
  ```
  util.write_to_gsheet("Indeed Data Error Tracking","PaidNoBoostedMatch",
                          paid_no_boosted_match)
  ```


pkgId: 817e9febfc486685cf0fc5a8ae58d3060f5b6ace52611c9c7ce5018742f03c5c
name: python-veevatools-help
arch: noarch
version: 0.1.30
epoch: 0
release: 1
summary: Development documents and examples for veevatools
url: https://github.com/michaelpay
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-veevatools-0.1.30-1.src.rpm
location_href: Packages/python-veevatools-help-0.1.30-1.noarch.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/veevatools)](https://pepy.tech/project/veevatools)



  This python package is a set of Salesforce.com, Veeva Network, Veeva Vault, and Veeva Nitro libraries, scripts, and functions used to help expedite the development of Veeva Tools.
  <br/>
  <br/>



  Ensure you have **at least Python version 3.10** installed.
  To Check your installation version, type the following commands in the terminal (MacOs) / command prompt (Windows):
  ```
  python --version
  ```
  To install python, go to https://www.python.org/ then navigate to the download page of your Operating System.

  ![Screenshot 2022-06-24 140724](https://user-images.githubusercontent.com/59848012/175649491-0eafdef7-acd2-4631-85cb-f9dee8630b04.png)

  You will need to have Packager Installer for Python (pip) installed. To install pip, run the following command in the terminal (MacOs) / command prompt (Windows):

  ```
  curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
  python3 get-pip.py
  ```
  To install the Veeva Tools library:

  ```
  pip install veevatools
  ```
  To upgrade to the latest version of Veeva Tools library:
  ```
  pip install veevatools --upgrade
  ```



  The Veeva Tools package currently contains 3 major components:




  ```python
  from salesforce import Sf
  from pandas import pd
  sf = Sf()
  sf.authenticate(
      sfUsername='yourname@salesforce.com',
      sfPassword='password123',
      sfOrgId='00D2C0000008jIK',
      isSandbox= false
      )
  ```
  > Sidenote on Pandas DataFrames: <br/>
  Pandas DataFrame (pd) is used to prepare the data for import (i.e. create, update methods) and additional export methods such as pd.to_excel() in order to save the output into an Excel file.<br/>
  Additionally, Complex data manipuation (joins, merges, groupbys, filters)and data analytics (describe, statistical analysis) can all be performed using Pandas. <br />
  To learn more about Pandas DataFrames, go to the [Pandas documentation](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html)
  <br \>
  > Or just Google tutorials on Pandas DataFrames.
  [This YouTube playlist by Corey Schafer](https://www.youtube.com/watch?v=ZyhVh-qRZPA&list=PL-osiE80TeTsWmV9i9c58mdDCSskIFdDS&ab_channel=CoreySchafer)
  provides an excellent starting point into the world of Pandas!

  <br/>


  The salesforce class (Sf) contains methods that can help you interact with data and metadata components:
  <br/>


  ```python
  account_recordtypes = sf.query("SELECT Id, Name, SobjectType from RecordType WHERE SobjectType = 'Account'")]

  account_recordtypes
  ```

  `Return -> pd.DataFrame():`
  |    |                 Id |                      Name | SobjectType |
  |---:|-------------------:|--------------------------:|------------:|
  |  0 | 012f4000001ArT3AAK |          Professional_vod |     Account |
  |  1 | 012f4000001ArT4AAK |           Institution_vod |     Account |
  |  2 | 012f4000001ArT5AAK |                   MCO_vod |     Account |
  |  3 | 012f4000001ArT6AAK |          Organization_vod |     Account |
  |  4 | 012f4000001ArWzAAK |              Hospital_vod |     Account |

  > Sidenote: <br />
  You can use any Pandas (pd) methods on the return value of the query output. For example <br/>```account_recordtypes.to_excel("Account RecordTypes.xlsx")``` <br/>
  Will save the results of the DataFrame into an Excel file.

  <br/>


  ```python


  account_records = pd.DataFrame([{'FirstName': 'Test', 'LastName': 'Account'}, {'FirstName': 'Test2', 'LastName': 'Account2'}])

  result = sf.create('Account', account_records)

  result
  ```
  `Return -> pd.DataFrame():`
  |   | success | created |                 Id |
  |--:|--------:|--------:|-------------------:|
  | 0 |    True |    True | 0010r00000tF7L1AAK |
  | 1 |    True |    True | 0010r00000tF7L2AAK |

  <br/>


  ```python


  update_account_name = pd.DataFrame(
      [{'FirstName': 'Updated', 'Id': '0010r00000tF7L1AAK'},
       {'FirstName': 'Name', 'Id': '0010r00000tF7L2AAK'}]
      )

  result = sf.update('Account', update_account_name)

  result
  ```
  `Return -> pd.DataFrame()`
  |   | success | created |                 Id |
  |--:|--------:|--------:|-------------------:|
  | 0 |    True |   False | 0010r00000tF7L1AAK |
  | 1 |    True |   False | 0010r00000tF7L2AAK |
  <br/>


  ```python





  upsert_account = pd.DataFrame(
      [{'NET_External_Id__c': '242977178138969088', 'Name': 'Updated Hospital Name'},
       {'NET_External_Id__c': '555579769212255555', 'Name': 'Create New Hospital'}]
      )

  result = sf.upsert(object_api='Account', external_id_field_api='NET_External_Id__c', record_dataframe=upsert_account)

  result
  ```
  `Return -> pd.DataFrame()`
  |   | success | created |                 id |
  |--:|--------:|--------:|-------------------:|
  | 0 |    True |   False | 001f400000PKOrwAAH |
  | 1 |    True |    True | 0010r00000tF7stAAC |

  <br/>


  ```python



  delete_account = pd.DataFrame([{'Id': '0010r00000tF7stAAC'}, {'Id': '001f400000PKOrwAAH'}])

  result = sf.delete(object_api='Account', record_dataframe=delete_account)

  result
  ```
  `Return -> pd.DataFrame()`

  |   | success | created |                 Id |
  |--:|--------:|--------:|-------------------:|
  | 0 |    True |   False | 0010r00000tF7stAAC |
  | 1 |    True |   False | 001f400000PKOrwAAH |

  <br/>


  ```python


  ```
  <br/>


  ```python


  ```
  <br/>


  ```python


  ```
  <br/>


  ```python


  ```
  <br/>


  ```python


  ```
  <br/>


  ```python


  ```


pkgId: 41b0a36d56a2894efe57d4b3541c956211726f05c7a30bfc3000309615553a8b
name: python-vellum-ai-help
arch: noarch
version: 0.11.3
epoch: 0
release: 1
summary: Development documents and examples for vellum-ai
url: https://pypi.org/project/vellum-ai/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vellum-ai-0.11.3-1.src.rpm
location_href: Packages/python-vellum-ai-help-0.11.3-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <h1 align="center">
    Vellum
    </h1>
    <p align="center">
      <a href="https://vellum.ai">Learn more</a>
      ·
      <a href="https://www.vellum.ai/landing-pages/request-demo">Talk to us</a>
    </p>
  </p>

  <p align="center">
    <a href="https://pepy.tech/project/vellum-ai">
      <img src="https://img.shields.io/pypi/dm/vellum-ai" alt="Vellum AI PyPI - Downloads" >
    </a>
    <a href="https://pypi.org/project/vellum-ai" target="_blank">
      <img src="https://img.shields.io/pypi/v/vellum-ai?color=%2334D058&label=pypi%20package" alt="Package version">
    </a>
    <a href="https://www.ycombinator.com/companies/vellum">
      <img src="https://img.shields.io/badge/Y%20Combinator-W23-orange?style=flat-square" alt="Y Combinator S24">
    </a>
  </p>



  [Vellum](https://www.vellum.ai/) is the end-to-end development platform for building production-grade AI applications



  - **Orchestration:** A powerful SDK and IDE for defining and debugging the control flow of your AI applications
  - **Prompting:** A best-in-class prompt playground for iterating on and refining prompts between models from any provider
  - **Evaluations**: An evaluations framework that makes it easy to measure the quality of your AI systems at scale.
  - **Retrieval:** A ready-to-go service for turning unstructured content into intelligent, context-aware solutions
    optimized for AI systems
  - **Deployment:** Decouple updates to your AI systems from your application code with an easy integration +
    one-click deploy
  - **Observability:** Monitor and debug your AI systems in real-time with detailed logs, metrics, and end-user feedback



  - [Get Started](#get-started)
  - [Client SDK](#client-sdk)
  - [Workflows SDK](#workflows-sdk)
  - [Contributing](#contributing)
  - [Open-source vs paid](#open-source-vs-paid)



  Most functionality within the SDKs here requires a Vellum account and API key. To sign up, [talk to us](https://www.vellum.ai/landing-pages/request-demo)
  or visit our [pricing page](https://www.vellum.ai/pricing).

  Even without a Vellum account, you can use the Workflows SDK to define the control flow of your AI systems. [Learn
  more below](#workflows-sdk).



  The Vellum Client SDK, found within `src/client` is a low-level client used to interact directly with the Vellum API.
  Learn more and get started by visiting the [Vellum Client SDK README](/src/vellum/client/README.md).



  The Vellum Workflows SDK is a high-level framework for defining and debugging the control flow of AI systems. At
  it's core, it's a powerful workflow engine with syntactic sugar for intuitively defining graphs, the nodes within,
  and the relationships between them.

  The Workflows SDK can be used with or without a Vellum account, but a Vellum account is required to use certain
  out-of-box nodes and features, including the ability to push and pull your Workflow definition to Vellum for editing
  and debugging via a UI.

  To learn more and get started, visit the [Vellum Workflows SDK README](/src/vellum/workflows/README.md).



  See the [CONTRIBUTING.md](/CONTRIBUTING.md) for information on how to contribute to the Vellum SDKs.



  This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
  for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.

  To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).


pkgId: 40c875068c49416e31b3d7378f8e82b7005cadbe5a051c27ad9274b6acfd2935
name: python-venvwrapper-help
arch: noarch
version: 0.5.0
epoch: 0
release: 1
summary: Development documents and examples for venvwrapper
url: https://github.com/andy-maier/venvwrapper
rpm_license: Apache License, Version 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-venvwrapper-0.5.0-1.src.rpm
location_href: Packages/python-venvwrapper-help-0.5.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Version on Pypi](https://img.shields.io/pypi/v/venvwrapper.svg)](https://pypi.python.org/pypi/venvwrapper/)

  venvwrapper is a Python package that provides commands that make it easier to
  manage Python virtual environments that are based on the
  [venv](https://docs.python.org/3/library/venv.html) package from the Python
  standard library.

  Basically, venvwrapper is to venv what
  [virtualenvwrapper](https://pypi.org/project/virtualenvwrapper/) is to
  [virtualenv](https://pypi.org/project/virtualenv/):
  It provides more convenient commands to make the management of virtual
  environments easier. However, virtualenv supports only a subset of the
  functionality of virtualenvwrapper.

  venvwrapper combines nicely with virtualenvwrapper:
  The virtual environments created by both packages can reside in the same
  directory side by side, regardless which of the two created them. That
  allows you to gradually convert your existing virtualenv/virtualenvwrapper
  based environments to be based on venv.

  Since Python 3.5, venv is the recommended tool for Python virtual environments,
  as stated in
  [Creating virtual environments](https://docs.python.org/3/library/venv.html#creating-virtual-environments):
  ```
  The use of venv is now recommended for creating virtual environments.
  ```

  Also note [this tweet](https://x.com/gvanrossum/status/1319328122618048514) by
  the BDFL on the topic:
  ```
  I use venv (in the stdlib) and a bunch of shell aliases to quickly switch.
  ```



  * Install the venvwrapper Python package into your default system Python 3 (i.e.
    with no virtual environment active):

    ```
    $ pip3 install --break-system-packages venvwrapper
    ```

    This installs the `venvwrapper.sh` script so that it is available in the
    PATH.

    Note that this Python package has no Python dependencies, so it does not break
    your system Python in any way.

  * Verify that `venvwrapper.sh` is available in the PATH:

    ```
    $ which venvwrapper.sh
    /opt/homebrew/bin/venvwrapper.sh
    ```

  * Add the following to your shell startup script (e.g. `~/.bash_profile` or
    `~/.zshrc`) in a place where no Python virtual environment is active:

    ```
    
    venv_wrapper=$(which venvwrapper.sh)
    if [[ -n $venv_wrapper ]]; then
        source $venv_wrapper
    fi
    ```

    `VENV_HOME` specifies the directory under which the directories for the
    virtual environments are created. If not set, it defaults to `~/.venv`.

    `VENV_HOME` can be set to the same directory that is used for
    virtualenvwrapper (i.e. its `WORKON_HOME` directory).

  * Verify the installation by starting a new terminal session, and invoking:

    ```
    $ mkvenv --help
    ```

    This should display the help:

    ```
    mkvenv - Create and activate a new Python virtual environment

    Usage: mkvenv ENV [PYTHON]

    Where:
      ENV      Name of the new virtual environment
      PYTHON   Python command to use for creation. Default: python3
    ```



  An active virtual environment is indicated by an `(env)` prefix in the command
  prompt. That is the normal behavior of venv.

  All commands provided by venvwrapper explain their usage when called with `-h`
  or `--help`:

  * `venv` - activate an existing virtual environment
  * `mkvenv` - create and activate a new virtual environment
  * `rmvenv` - remove one or more virtual environments
  * `lsvenv` - list existing virtual environments

  The standard `deactivate` script provided by the virtual environment is used
  to deactivate the virtual environment.

  The commands provided by venvwrapper are actually shell functions, so they
  cannot be used in other scripts. If you need to activate virtual environments
  in other scripts, call the `activate` script provided by the virtual
  environment.

  If venvwrapper is configured to use the same directory for its virtual
  environments as virtualenv/virtualenvwrapper, then the commands that operate on
  existing virtual environments can be used on either kind of virtual environment,
  regardless of which package created it. For example, `lsvenv` will list both
  kinds of virtual environments.

  The `venv` and `rmvenv` commands support tab completion.



  The venvwrapper.sh script provided in this package is based on the script
  by Ismail Demirbilek at
  https://gist.github.com/dbtek/fb2ddccb18f0cf63a654ea2cc94c8f19.



  The venvwrapper project welcomes contributions.

  For how to set up a development environment, see [DEVELOP.md](DEVELOP.md).


pkgId: 992565a617e4c100e59f632c65314e57029b03ab5ad51a509378144154f6ee15
name: python-verblaze-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for verblaze
url: https://verblaze.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-verblaze-1.0.1-1.src.rpm
location_href: Packages/python-verblaze-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  <a href="https://verblaze.com">
    <img src="logo.png" alt="Verblaze Logo" width="300"/>
  </a>

  Verblaze is an automatic localization generation tool that helps you manage and generate translations for your projects.

  📚 **[Visit verblaze.com](https://verblaze.com)** for detailed guides and examples.



  - 🚀 Quick and easy setup
  - 🌍 Support for multiple frameworks and technologies
  - 📦 Automatic string extraction
  - 🔄 Seamless integration with Verblaze Dashboard
  - 💻 Simple command-line interface



  ```bash
  pip install verblaze
  ```





  First, set up your Verblaze configuration using your secret key from the dashboard:

  ```bash
  verblaze config --secret-key YOUR_SECRET_KEY
  ```



  Extract strings from your project using the generate command:

  ```bash
  verblaze generate -t TEMPLATE -d PROJECT_DIRECTORY -f FOLDERS
  ```



  - `-t`: Template/framework (Required)
    - Supported templates: flutter, react, react-native, angular, plain-html, vue, svelte, ember, backbone, swift, kotlin, javafx, wpf, qt, blazor, nextjs
  - `-d`: Project directory path (Required)
  - `-f`: Folders containing UI code, comma-separated (Required)



  ```bash
  verblaze generate -t react -d /path/to/project -f "src,components,pages"
  ```



  To import existing translations from JSON or ARB files into Verblaze:

  ```bash
  verblaze import_translations -p PATH --language LANG_CODE --format FORMAT
  ```



  - `-p` or `--path`: Path to translation file (Required)
  - `--language`: Language code (e.g., en, tr, es) (Required)
  - `--format`: File format (json or arb) (Required)



  ```bash
  verblaze import_translations -p translations/en.json --language en --format json
  ```



  - React
  - React Native
  - Angular
  - Vue
  - Svelte
  - Flutter
  - Plain HTML
  - Ember
  - Backbone
  - Swift
  - Kotlin
  - JavaFX
  - WPF
  - Qt
  - Blazor
  - Next.js



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



  - Website: [verblaze.com](https://verblaze.com)
  - Email: support@verblaze.com
  - [Github](https://github.com/Verblaze)



  **Q: How do I get my secret key?**
  A: You can obtain your secret key from the Verblaze Dashboard after creating an account.

  **Q: Which Python versions are supported?**
  A: Python 3.6 and above are supported.

  **Q: Can I use Verblaze with my existing project?**
  A: Yes, Verblaze supports multiple frameworks and can be integrated with existing projects.





  - First stable release
  - Added new command: `import_translations` with support for JSON and ARB file imports
  - Enhanced loading animations
  - Improved error messages and user feedback
  - Updated documentation



  - Added loading animation during string synchronization
  - Fixed regex pattern for Flutter string extraction
  - Improved user feedback during synchronization process
  - Updated documentation and README



  - Initial release
  - Added support for multiple frameworks
  - Implemented string extraction functionality
  - Created CLI interface with config and generate commands


pkgId: d160f9c495f63a3d7d422abde1bca96580ca43a2f74563c0d432051f6d67651e
name: python-verify-oidc-identity-help
arch: noarch
version: 0.4.8
epoch: 0
release: 1
summary: Development documents and examples for verify-oidc-identity
url: https://github.com/rjw57/verify-oidc-identity
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-verify-oidc-identity-0.4.8-1.src.rpm
location_href: Packages/python-verify-oidc-identity-help-0.4.8-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Version](https://img.shields.io/pypi/v/verify-oidc-identity)](https://pypi.org/p/verify-oidc-identity/)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/verify-oidc-identity)
  [![GitHub Release](https://img.shields.io/github/v/release/rjw57/verify-oidc-identity)](https://github.com/rjw57/verify-oidc-identity/releases)
  [![Test suite status](https://github.com/rjw57/verify-oidc-identity/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/rjw57/verify-oidc-identity/actions/workflows/main.yml?query=branch%3Amain)

  [OpenID connect][oidc] identity tokens are a popular choice for federating identity between
  different systems without the need to share secrets. For example [Trusted publishing on
  PyPI](https://docs.pypi.org/trusted-publishers/) allows use of OIDC tokens created by
  GitHub or GitLab CI jobs to be used to authenticate when uploading new Python packages.
  Similarly, OIDC tokens can be used to authenticate to [Google
  Cloud](https://cloud.google.com/iam/docs/workload-identity-federation),
  [AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles)
  and
  [Azure](https://learn.microsoft.com/en-us/graph/api/resources/federatedidentitycredentials-overview?view=graph-rest-1.0)
  from any OIDC identity provider.

  The [jwt.io](https://jwt.io/) and [jwt.ms](https://jwt.ms/) tools allow validating OIDC
  id tokens without first configuring public keys by means of the [OpenID connect
  discovery][oidc-discovery] protocol.

  This library implements the OpenID Connect discovery standard in Python to allow
  verification of OpenID Connect id tokens without previous configuration of public keys,
  etc.

  Both synchronous and asynchronous (`asyncio`) implementations are provided.

  [oidc]: https://openid.net/specs/openid-connect-core-1_0.html
  [oidc-discovery]: https://openid.net/specs/openid-connect-discovery-1_0.html



  Suppose you created a [GitLab OIDC
  token](https://docs.gitlab.com/ee/ci/secrets/id_token_authentication.html) as part of a
  CI job to make an authenticated HTTP GET request to some service:

  ```yaml


  job_with_id_token:
    id_tokens:
      ID_TOKEN:
        aud: https://my-service.example.com
    script:
      - curl -X GET -H "Authorization: Bearer $ID_TOKEN" https://my-service.example.com
  ```

  The following example shows how to verify the OIDC token came from a specific project
  within a backend implementation:

  ```py
  from typing import Any
  from federatedidentity import Issuer, verifiers, verify_id_token


  GITLAB_ISSUER = Issuer.from_discovery("https://gitlab.com")


  EXPECTED_PROJECT_PATH = "my-group/my-project"


  EXPECTED_AUDIENCE_CLAIM = "https://my-service.example.com"

  def verify_gitlab_token(token: str) -> dict[str, Any]:
      """
      Verify an OIDC token from GitLab and return the dictionary of claims. Raises
      federatedidentity.exceptions.FederatedIdentityError if the token failed verification.
      """
      return verify_id_token(
          token,
          valid_issuers=[GITLAB_ISSUER],
          valid_audiences=[EXPECTED_AUDIENCE_CLAIM],
          required_claims=[
              
              {"project_path": EXPECTED_PROJECT_PATH},
          ],
      )
  ```

  See [the full documentation](https://rjw57.github.io/verify-oidc-identity/) for more
  examples.


pkgId: 43a705a6c49147704585961b9993b6bfd44b9dfc4e01b7e01dfc7bc8b2b11f2a
name: python-verime-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for verime
url: https://pypi.org/project/verime/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-verime-2.0.0-1.src.rpm
location_href: Packages/python-verime-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  In the context of the side-channel analysis of hardware implementations, an evaluator usually requires to have access to the internal values of a target circuitry. For this purpose, a circuit oracle simulating these values is implemented, which may turn out to be time consuming to do manually (e.g., each probed internal value should be modeled and any modification of the original circuitry implies to rewrite the circuit oracle) and/or achieve poor performances (e.g., spawning a simulator process for each simulation).

  The Verime tool is proposed to tackle these issues. In particular, it automatically generates a prediction library of a circuit (described in Verilog). More precisely, it performs behavioral verilog simulations during an arbitrary amount of clock cycles thanks to a Verilator backend. Verilator is a powerful tool, but requires some expertise and predicting certain internal states using the `\* verilator public *\` pragma can be challenging and time consuming to setup for a non-experienced user. Based on that, the Verime tools acts as a wrapper for verilator and aims to (significantly) reduce the evaluator work: it automatically generates the C++ Verilator backend code and generates a user friendly python package thant can be easily integrated and used.

  The advantages over "raw" Verilator usage are:

  - Easy integration with python: no bindings to write.
  - Nultiple simulations in a single process, that can even run in parallel, achieving excellent performance (no process startup overhead).
  - No need to handle complicated Verilator model interface to probe the value of wires.

  In short, the workflow is as follows:

  1. Annotate the targeted signal in the Verilog source(s) file(s) with the attribute `(* verime = "probed_sig_name" *)`.
  1. Write a C++ simple simulation wrapper for the top-level module that indicates:
      - How the top-level module should be interfaced and how the input data is routed.
      - When the probed signals values should be stored (e.g., all clock cycles or some specific ones).
  1. Run the Verime tool to build a python package (wheel) and install it as any other python package with pip.
  1. Use the simulation package in python scirpts.



  In addition to Python (`>= 3.11`), Verime has the following native dependencies:

  - [Yosys](https://yosyshq.net/yosys/) (versions 0.20 and 0.23 known to work)
  - [Verilator](https://www.veripool.org/verilator/) (version 5.006 known to work)
  - GNU Make

  **CAUTION: Verilator dependency**:

  - If a recent-enough version is available, we recommand to install Verilator using the packet manager of your OS.
  - If you build from [source](https://github.com/verilator/verilator), we
    **highly recommend** using an in-place version of Verilator, as recommended
    in the official
    [documentation](https://veripool.org/guide/latest/install.html#run-in-place-from-verilator-root).
    Then, set the `VERILATOR_ROOT` environmnent variable appropriately (no `PATH`
    modification needed).
    Some versions of Verilator are known to not behave correctly when installed with `make install`.



  ```
  python3 -m pip install verime
  ```

  You can also build it locally (it is a pure-python package).



  This section demonstrates how Verime can be used for a simple example provided under the [tests](tests/example) directory. In particular, the later contains the Verilog file implementing a programmable delay counter (i.e., a module that counts up to an arbitrary value and indicates when it finishes). In particular, the following files can be found:

  - [FA1bit.v](tests/example/srcs/FA1bit.v): a 1-bit full adder.
  - [FANbits.v](tests/example/srcs/FANbits.v): a N-bit full adder.
  - [counter.v](tests/example/srcs/counter.v): the top level counter.

  These modules have been coded to use different coding styles (e.g., generate loop, multiple depth levels, generics and localparam, ... ). For the provided top level, `cnt_bound` is used to specify a delay (in terms of clock cycles), `start` is a control signal used to start a new count and `busy` is asserted when a count is in progress. An execution begins when `start` is asserted (and that `busy` is not). Then, the core will assert `busy` during `cnt_bound`+1 cycles.



   In this simple example, we use Verime to probe some internals signals accross the hierarchy of the counter. To do so, we first annotate the internal signals that we want to probe with the `verime` attribute. In particular, we annotate the signals `reg [N-1:0] counter_state` (in [counter.v](tests/example/srcs/counter.v)), `input a` (in [FA1bit.v](tests/example/srcs/FA1bit.v)) and `input b` (in [FA1bit.v](tests/example/srcs/FA1bit.v)) as depicted in the following code snippets

   ```verilog
   ...
   // Register to hold the value
  (* verime = "counter_state" *)
  reg [N-1:0] counter_state;
  wire [N-1:0] counter_nextstate;
  ...
   ```

   and

   ```verilog
  ...
  (* verime = "FA1_ina" *)
  input a;
  (* verime = "FA1_inb" *)
  input b;
  input cin;
  ...
   ```



  Once the HW design annotated, the file [test_counter.cpp](tests/example/test_counter.cpp) implements the C++ simulation wrapper of the top-level module.
  This code follows the structure:

  ```c
  // MUST be included, as is.


  // The simulation function. Only function that MUST be implemented
  void run_simu(SimModel *sm, Prober *p, char* data, size_t data_size) {
     // See below for the content of this function.
  }
  ```

  For our simple example, the `run_simu` function only perfoms four basic steps:

  1. First, the core is reset

  ```c
  ...
  // Reset the top module core
  sm->vtop->rst = 1;
  sim_clock_cycle(sm);
  sm->vtop->rst = 0;
  sim_clock_cycle(sm);
  ...
  ```

  2. Then, the programmable delay is fetched from the input buffer and the dedicated input bus of the core is set accordingly

  ```c
  ...
  // Prepare the run with input data
  // Set the cnt_bound value
  memcpy(&sm->vtop->cnt_bound,data,BYTES_BOUND);
  ...
  ```

  Where `BYTES_BOUND` is a macro derived from `GENERIC_N`, which is defined by
  Verime as the value of the `N` generic parameter of the top-level module.
  3. Afterwards, a core execution is started

  ```c
  ...
  // Start the run
  sm->vtop->start = 1;
  sim_clock_cycle(sm);
  sm->vtop->start = 0;
  sm->vtop->eval();
  ...
  ```

  4. Finally, we wait for the end of the execution. While waiting for the counter to reach the configuration, the value of the probed states are saved at every clock cycles. Their values are also saved the cycle after the completion of the counting process.

  ```c
  ...
  // Run until the end of the computation
  while(sm->vtop->busy==1){
     // Save all the probed values for the current clock cycle.
     save_state(p);
     // Simulate a single clock cycle
     sim_clock_cycle(sm);
  }
  // Save the probed value once the operation is over
  save_state(p);
  ...
  ```



  It is now time to compile everything together in order to have our 'easy-to-use' simulation python package.
  This is done in two steps: first generate the source files for the package using Verime, then running `make` with the generated `Makefile`.

  The example [Makefile](tests/example/Makefile) follows this procedure to follow, you can simply run `make` in `tests/example`.
  If the build is successful (otherwise check if you have installed all the required dependencies in correct versions), a wheel package should be created under the directory named after the `PACK_NAME` variable of the Makefile.



  Now that the package has been built for our simple design, the file [example_simu.py](tests/example/example_simu.py) demonstrates how the it can be used. In the example, we use it to validate the (functional) behavior of our HW module (i.e., by verifying the value of the internal counter after an execution). The following commands (under `tests/example`) can be used to verify that everything went well (here, we rely on a virtual environment which is recommanded but not stricly required):

  ```bash
  python3 -m venv ve
  source ve/bin/activate # change according to your OS and shell
  pip install --upgrade pip
  pip install counter_example_16_lib/*.whl # default value
  python3 example_simu.py
  ```

  At the end, a message similar to the following should be displayed

  ```
  ...
  Check the prediction results for the 100 cases:
  All simulated cases where successfully verified!
  [0:00:00.583404 elapsed (100 pred. cases ; 3387683 clock cycles simulated)]
  ```



  This section explains with more details the functions and parameters that can be used at the different steps of the flow when using the Verime tool.



  The simulation wrapper is the only file that need to be written by as user. In in this file, the user only needs to implement to function `run_simu`:

  ```c
  void run_simu(SimModel *sm, Prober *p, char *data, size_t data_size);
  ```

  The following parameters are used:
  - `SimModel *sm`: A Verime-specific structure holding the circuit model generated by the Verilator backend. It is typically used to simulate the stimuli at the top-level of the simulated hardware architecture.
  - `Prober *p`: A Verime-specific structure used to easily to save the value of the probed (i.e., annotaded) signals at a given simulation time.
  - `char *data`: An array of bytes, provided to the python API as the input data of a single simulation. These are the data required to perform a simulation.
  - `size_t data_size`: The length of the `data` array.

  The definitions of the structures `SimModel` and `Prober` depend on the hardware architecture as well as the annotated signals and are automatically generated by Verime. The directive `#include "verime_lib.h"` **must** be used in order to properly include the generated library code in the compilation flow. Besides, the Verilog top-level generic values can be recovered in the wrapper: Verime will define the macro `GENERIC_${PARAM}` for each generic defined at the Verilog top-level (where `PARAM` is the generic name).

  To implement the top-level stimuli, the input/output of the core can be accessed through the `SimModel`. In particular `sm->vtop` references to an instance of the top module simulation object generated with Verilator. As an example, the statement `sm->vtop->sig_name = value;` can be used to set the value of the hardware top level I/O bus `sig_name`. The exact types of each data bus depends on its practical size, as summarized by the following table

  | size $`s`$ (bits) | C++ type |
  | --- | --- |
  | $`s\leq 8`$ | `uint8_t` |
  | $`8< s \leq 16`$ | `uint16_t` |
  | $`16< s \leq 32`$ | `uint32_t` |
  | $`32< s \leq 64`$ | `uint64_t` |
  | $`64<s`$ | `uint32_t` [$`\lceil s/32 \rceil`$]|

  In addition, the following functions are provided when including `verime_lib.h`:
  - `sim_clock_cycle(SimModel * sm)`: simulates a posedge clock cycle. This function only works for a design that is synchronous to the positive edge of a top-level input clock.
  - `save_state(Prober * p)`: save the value of the probed signal at the current simulation time.
  - `sm->vtop->eval()`: evaluates the circuit internal signals values at the current simulation time. This is a call to the `eval()` function of the generated Verilator object. This function should be used only if you cannot use `sim_clock_cycle`.



  The verime tool is used to build the front-end python package based on the HDL Verilog source and the C++ simulation wrapper. As shown by the tool helper, several parameter can be used.

  ```
  verime -h
  usage: verime [-h] [-y YDIR [YDIR ...]] [-g GENERICS [GENERICS ...]] -t TOP [--yosys-exec YOSYS_EXEC] --pack PACK --simu SIMU [--build-dir BUILD_DIR] [--clock CLOCK]

  options:
    -h, --help            show this help message and exit
    -y YDIR [YDIR ...], --ydir YDIR [YDIR ...]
                          Directory for the module search. (default: [])
    -g GENERICS [GENERICS ...], --generics GENERICS [GENERICS ...]
                          Verilog generic value, as -g<Id>=<Value>. (default: None)
    -t TOP, --top TOP     Path to the top module file, e.g. /home/user/top.v. (default: None)
    --yosys-exec YOSYS_EXEC
                          Yosys executable. (default: yosys)
    --pack PACK           The Verilator-me package name. (default: None)
    --simu SIMU           Path to the C++ file defining run_simu (default: None)
    --build-dir BUILD_DIR
                          The build directory. (default: .)
    --clock CLOCK         The clock signal to use. (default: clk)
  ```

  The only required parameters are `-t`, `--pack` and `--simu`.



  Once installed, the simulation library package can be used to simulate the probed internal state value by creating a `Simu` object, as shown next

  ```python
  import generated_verime_lib as prediction_lib
  ...
  predictions = prediction_lib.Simu(
     cases_inputs,
     am_probed_states
  )
  ```

  where `cases_inputs` is a 2D numpy array of bytes (i.e., `np.uint8`) that holds the input bytes for each simulation (each row will be used as the `data` argument of `run_simu` in the C++ code) and `am_probed_states` specifies the maximum amount of time that the probed states will be saved (i.e., the number of calls to `save_state` in `run_simu`).

  The `Simu` object can be index with keys which are the Verime probed signals names, returning the corresponding simulation results. These are 3D numpy arrays, where the first dimension is the simulation index, the second dimension is the saving index (i.e., result of the i-th call to `save_state()` in `run_simu()`) and the third dimension is the byte index of the probed signal value. Putting all together, the following code snippet represents a generic template for the usage of the generated prediction library.

  ```python

  import generated_verime_lib as plib

  import numpy as numpy


  Ncases = 100
  Nbytes_per_case = 7




  cases = np.random.randint(0,256,[Ncases,Nbytes_per_case],dtype=np.uint8)



  predictions = plib.Simu(
     cases,
     100
  )



  useful_state = predictions["probed_state"][cid,sid,:]
  ... # do some stuff
  ```

  Finally, some metadata are embedded in the library package and can be easily accessed for further usage. These are summarized here (use `help($VERIME_LIB)` to get detailled information):

  | field | data |
  | --- | --- |
  | `GENERICS` | A dictionary holding the value of the Verilog top-level generics used. |
  | `PROBED_STATE_BYTES` | Amount of bytes required to encode all the probed internal state values |
  | `SIGNALS` | List containing the names of the signal generated by Verime |
  | `SIG_BITS` | A dictionary holding the width (in bits) for each probed signals |
  | `SIG_BYTES` | A dictionary holding the amount of bytes used to encode each probe signals |



  The generated simulation library releases the python global interpreter lock
  (GIL) when running the simulations, hence simulations can be parallelized on
  multi-core CPUs using python's thread-based concurrency such as
  `concurrent.futures.ThreadPoolExecutor`.


pkgId: 02dd9828c21aae4b771139b05952374ae0c389758a4b5d28dc665613971135c9
name: python-verithon-help
arch: noarch
version: 0.4
epoch: 0
release: 1
summary: Development documents and examples for verithon
url: https://github.com/autohdw/Voldelog.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-verithon-0.4-1.src.rpm
location_href: Packages/python-verithon-help-0.4-1.noarch.rpm
checksum_type: sha256
description:
  1. Every verilog line should follow a magic comment: `#/`.
       - **Warning:** The verilog line must be consistent with python indent
       - **Warning:** No blank spaces are allowed between `#` and `/`. Some IDEs (such as pycharm) automatically adds a blank space after `#`
  2. Inside a magic comment, the content enclosed by 2 apostrophes are intepreted as python variables. For instance: ```#/ LLR_RECV[`h_bit`:`l_bit`] <= 12'b`llr_1`;```
       - Idealy, PyTV supports all sorts of python expressions between 2 apostrophes. But for safety considerations, we do recommand doing operations outside the apostrophes and write only single python variable between the apostrophes.


  1. Every definition of a verilog module is written in magic comments and embodied in the definition of a **python function**.
     - The name of the python function must start with `Module`. The function name is formulated as `Module_abstract_module_name`. In the current PyTV version, please **do not** define a normal function whose name start with `Module`. Also, the module function definition should be written in a **single** line. (We prepare to solve these 2 issues in future releases)
     - Every module function should be decorated with pytv using `@pytv`. Please write `@pytv` only in the line above each module function definition.
     - The parameters of the python function can be of any data type.
     - The function must **not** have any return value (We will support module functions with return values in future releases).
     - -Below is a very short definition of a verilog module using PyTV
       ``` python
          @pytv
          def ModuleBasic(p1, p2):
              
              if p1 > 0:
                 
                 pass
              if p2 > 0:
                 
                 pass
              
              
              
              
              


  1. Module Instantiation with PyTV is done by directly calling the defined module function with the original parameters and extra parameters for ports and inst name (This parameter can be left out with auto-naming).
  2. Grammar for instantiation: `ModuleYOUR_MODULE_TO_INSTANTIATE (param1 = p1, param2 = p2, paramN = pN, PORTS = PORTS_DICT, INST_NAME = MY_INST_NAME)`.
  3. An example for instantiation:
     ```python
        ModuleMUL(param1 = 1, param2 = 1, paramN = 1, PORTS = ["my_mul_port1", "my_mul_port2", "my_mul_port3"], INST_NAME = "mymul_inst")
        inst_ports_dict = {'PORT1':'name_port1', 'PORT2':'name_port2'}
        for i in range (1,5):
              ModuleBasic(p1=1, p2=1, PORTS=inst_ports_dict)
              ModuleBasic(p1=rst1, p2=-10, PORTS=["PORTA"])
              ModuleBasic(p1=1, p2=1, PORTS=inst_ports_dict)
     ```
  4. Constraints:
     - The function param `PORTS` does not appear in the user's definition of the python function. It's a parameter added to the function by the decorator `pytv`. Unless you are instantiating a top module, you should assign value to this parameter (otherwise you will see warning message). Value assigned to this param can either be a  python `list` or  `dict`. It is **NOT** allowed to assign `PORTS` with a string.
     - The function param `INST_NAME` is not compulsory. Actually, we recommend the users to uuse automatic inst naming. (If this `INST_NAME` is not assigned a value, pytv will automatically name the instance the module)
     - The function param `MODULE_NAME` is supported but we strongly recommend the users to avoid using it because its usage may potentially corrupt the naming space in pytv.
     - Before generating instantiation code in the upper module, pytv will check whether the number of ports in the list/dict assigned to `PORTS` matches the ports in the module to be instantiated. If mismatch is found, pytv will throw an exception and terminate code generation. So make sure you have passed correct value to `PORTS`.
     - All parameters should be passed in the **keyword argument** format, but the order in which you pass the arguments can be switched.


  PyTV enables auto naming of modules, module files and instances. Auto-naming is done whenever a module function is called without the argument `MODULE_NAME` or `INST_NAME`. There are 3 naming modes to choose from (`HASH`, `MD5_SHORT`, `SEQUENTIAL`). `SEQUENTIAL` is the most recommended naming mode.

  1. PyTV provides an api for specifying naming mode:
     ```python
         pytv.set_naming_mode("SEQUENTIAL")
     ```
  3. You can also set naming mode by passing args in command line:
     ```shell
         --naming_mode "SEQUENTIAL"
     ```


  1. Naming of modules or module files
     - Whether to generate new module: Every time a module function is called, pytv reads the python level params and inspects whether the params overlap with some earlier calls. If overlap is found, pytv will not generate a new module file.
     - Naming newly generated module: The module name in pytv is formulated as `abstract_module_name + module_identifier`. `abstract_module_name` is read from the name of the module function. `module_identifier` is auto-generated according to certain rules to distinguish between different modules. In `SEQUENTIAL` naming mode, `module_identifier` is a 10-digit hexadecimal number. In `HASH` mode, `module_identifier` is a hash value of the python layer params the module function received. In `MD5_SHORT` mode, `module_identifier` is a cut MD5 value of the python layer params.
  2. Naming of instances
     - Instances are named according to the module they belong to. To avoid naming conflict across different instances, there is also an instance sequence number included in the instance names.
     - The instance name is formulated as: `u_sequence_number_module_name`.
  3. An example for naming of module and instance.
     - pytv line: `ModuleBasic(p1=1, p2=1, PORTS=inst_ports_dict)`
     - generated module name: `Basic0000000001`
     - generated module file name: `Basic0000000001.v`
     - generated instance name: `Basic0000000001  u_0000000002_Basic0000000001` (This is 2nd time that the module function ModuleBasic is called with the same python layer params)



  You can run pytv with the following shell script:
  ```shell
  cd "C:\your\path"
  python your_pytv_file.py --naming_mode HASH --root_dir "C:\your\root_dir" --flag_save_param --disable_warning
  ```

  Meaning of each command line argument is presented below:
  1. `--naming_mode`
     - **Meaning**: Sets the naming mode for the RTL files.
     - **Possible Values**:
       - `HASH`: Uses a hash value as part of the filename (default).
       - `MD5_SHORT`: Uses a shortened MD5 value as part of the filename.
       - `SEQUENTIAL`: Uses a sequential number as part of the filename.

  2. `--root_dir`
     - **Meaning**: Specifies the path where RTL files will be saved.
     - **Possible Values**: Any valid folder path. The user must either pass this argument in command line or set moduleloader.root_dir with api functions. Otherwise, exceptions will be raised and RTL code generation will not start.

  3. `--flag_save_param`
     - **Meaning**: Indicates whether to save the parameter file.
     - **Possible Values**:
       - `store_true`: If this parameter is present, the parameter file will be saved.
       - Default is `False` if this parameter is not provided.

  4. `--disable_warning`
     - **Meaning**: Indicates whether to disable warnings (if true, pytv will display no warnings).
     - **Possible Values**:
       - `store_true`: If this parameter is present, the warnings will be dis-enabled.
       - Default is `False` if this parameter is not provided.


  If you want to run your pytv file without command line, you can configure root directory, naming, saving and warning settings with api functions of pytv. Examples of usage are presented below:
  1. `moduleloader.set_naming_mode("SEQUENTIAL")`
  2. `moduleloader.set_root_dir("C:\淇￠亾缂栫爜\SummerSchool\鎻愪氦")`
  3. `moduleloader.saveParams()`
  4. `moduleloader.disEnableWarning()`
  Note that these api functions must be called **before** you call a pytv module function.


  1. You can find the generated module files in the folder `your_root_dir\\RTL_GEN`.
  2. You can find the saved module parameters in the folder `your_root_dir\\PARAMS`.
  3. You can view info and warning messages in the terminal.


pkgId: ce417ff50a363cc09f29a0603acf66451572b95699a04365e91b95c52e1cfb6a
name: python-version-finder-git-based-versions-help
arch: noarch
version: 10.1.0
epoch: 0
release: 1
summary: Development documents and examples for version-finder-git-based-versions
url: https://github.com/LevyMatan/version_finder
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-version-finder-git-based-versions-10.1.0-1.src.rpm
location_href: Packages/python-version-finder-git-based-versions-help-10.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![Coverage Report](https://img.shields.io/badge/Coverage-Report-green)](https://LevyMatan.github.io/version_finder/)
  [![Latest Release](https://img.shields.io/github/v/release/LevyMatan/version_finder)](https://github.com/LevyMatan/version_finder/releases/latest)

  Version Finder is a command-line utility for finding and comparing versions in Git repositories. It provides an easy way to manage and analyze version information across multiple branches and submodules. The tool also supports easier GUI and CLI for more powerful operations.



  - Find versions across different branches and submodules in a Git repository
  - Handle Git submodules
  - Retrieve detailed commit information



  You can install Version Finder in 3 ways:



  ```bash

  pip install version-finder-git-based-verions

  pip install version-finder-git-based-verions[gui]

  pip install version-finder-git-based-verions[cli]

  pip install version-finder-git-based-verions[cli-gui]

  pip install version-finder-git-based-verions[all]
  ```

  > **Note:** The installation name is not `version_finder`, but `version-finder-git-based-verions`. Worry Not! Usage name is `version_finder`.



  Download the latest wheel file from the [releases page](https://github.com/LevyMatan/version_finder/releases/latest) and install with:

  Install core library only:

  ```bash
  pip install version_finder-*.whl
  ```

  Install core library with CLI:

  ```bash
  pip install version_finder-*.whl[cli]
  ```

  Install core library with GUI:

  ```bash
  pip install version_finder-*.whl[gui]
  ```

  (**Recomended**) Install core library with CLI and GUI:

  ```bash
  pip install version_finder-*.whl[cli+gui]
  ```



  1. Ensure you have Python 3.6 or higher installed on your system.
  2. Clone the repository:

     ```bash
     git clone https://github.com/LevyMatan/version_finder.git
     cd version_finder
     ```

  3. Install the package using pip:

     ```bash
     make install
     ```

     You will be prompted to use what will be installed, the option are:
     - Core Library only
     - Core Library and CLI
     - Core Library and GUI
     - All

     Please note that this installation does not inlude the requierments for development.



  After installation, you can use the `version_finder` command-line tool.

  > **Note:** At the moment it is highly advised to have a separate clone of your repository to be used for version searching.

  Here are some example commands:

  ```bash
  version_finder -p /path/to/repo -b <branch> -c <commit>  # Find versions in specified repository
  version_finder --gui                            # Run the GUI
  version-finder --cli                            # Run the CLI
  version_finder -v                               # Run with verbose output


  version_finder -b <branch> -c <commit> -s <submodule>
  ```

  For a full list of options, run:

  ```bash
  version_finder --help
  ```



  You can invoke a simple version finder with:

  ```bash
  version_finder -p /path/to/repo -b target_branch -c target_commit [-s submodule_path]
  ```

  This will find the first version containing the target commit within the target branch.



  The CLI will enable user to interact with the library in a more interactive way.
  The first step will be to select the repository to work on.
  After that, the user will be asked to select the branch to work on.

  Now the user will given the option to choose a TASK to perform.
  Based on the task chosen, user will have to enter additional information.
  Tasks include:

  - Find the first version containing a specific commit
  - Find the first version containing a specific commit in a specific submodule
  - Show all commits between two versions
  - Show all commits between two versions in a specific submodule



  Reveales the same functionality as the CLI, but with a GUI interface.
  It also provides instant feedback for parameter correctness and hints in the form of autocomplete.



  The Version Finder utility is structured as follows:

  - `version_finder/__main__.py`: Contains the a gateway to the library and will preform a simple task or open CLI or GUI.
  - `version_finder/core.py`: Implements the `VersionFinder` class, which handles Git operations, branch handling, and version extraction.
  - `version_finder/logger.py`: Sets up logging for the application
  - `version_finder/protocols.py`: Defines protocol classes for type hinting
  - `version_finder/__cli__.py`: Defines the CLI interface for the application
  - `version_finder/__gui__.py`: Defines the GUI interface for the application
  - `version_finder/__common__.py`: Defines common utility functions for both CLI and GUI



  1. `VersionFinder` class:
     - Manages Git repository operations
     - Handles submodules and branches
     - Performs version extraction and retrieves commit information

  2. CLI Interface:
     - Provides a command-line interface for interacting with the application
     - Provides an interactive interface for selecting branches
     - Executes version finding operations based on user input



  Contributions to Version Finder are welcome! Here are some ways you can contribute:

  1. Report bugs or request features by opening issues
  2. Submit pull requests with bug fixes or new features
  3. Improve documentation or add examples

  When contributing code, please ensure that you:

  - Follow the existing code style and conventions
  - Write appropriate tests for new features or bug fixes
  - Update the documentation as necessary

  To set up a development environment:

  1. Clone the repository
  2. Create a virtual environment: `python -m venv venv`
  3. Activate the virtual environment:
     - On Windows: `venv\Scripts\activate`
     - On Unix or MacOS: `source venv/bin/activate`
  4. Install the package in editable mode: `make install-dev`
  5. Run tests: `make test`
  6. flake8: `make lint`
  7. autopep8: `make format`
  8. coverage report: `make coverage`

  Before submitting a pull request, please ensure that all tests pass and the code adheres to the project's coding standards.



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


pkgId: c012c978031710f71601d9f0897617a53293e295a9e267c0eb6997d8cfeaefe8
name: python-verstack-help
arch: noarch
version: 4.1.7
epoch: 0
release: 1
summary: Development documents and examples for verstack
url: https://github.com/DanilZherebtsov/verstack
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-verstack-4.1.7-1.src.rpm
location_href: Packages/python-verstack-help-4.1.7-1.noarch.rpm
checksum_type: sha256
description:
  - Python (>= 3.6)
  - numpy
  - pandas<=2.0.3
  - scikit-learn>=0.23.2,<=1.1.3
  - lightgbm>=3.3.0,<=4.0.0
  - optuna>=2.10.0,<=3.2.0
  - plotly>=5.3.1,<=5.11.0
  - matplotlib
  - python-dateutil>=2.8.1,<=2.8.2
  - holidays==0.11.3.1
  - mlxtend
  - category_encoders>=2.4.0,<=2.5.1


pkgId: f937c799a7881412246aeb33e48197cc530297c5271027aa3018b29382ae24b4
name: python-vesuvius-phalanx-help
arch: noarch
version: 0.1.8
epoch: 0
release: 1
summary: Development documents and examples for vesuvius-phalanx
url: https://github.com/mvrcii/phalanx
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vesuvius-phalanx-0.1.8-1.src.rpm
location_href: Packages/python-vesuvius-phalanx-help-0.1.8-1.noarch.rpm
checksum_type: sha256
description:
  ![UniversityHeader](https://github.com/mvrcii/phalanx/blob/main/assets/phalanx_banner.jpg)



  phalanx is a specialized tool for downloading scrolls and fragments, allowing users to efficiently retrieve specific slices from volumes and fragments. The name "phalanx" draws inspiration from the mythical phoenix, symbolizing rebirth and revival. Just as the phoenix rises from its ashes, phalanx is designed to help resurrect and breathe new life into ancient scrolls buried under the ashes of Mount Vesuvius, offering a modern way to explore and preserve these fragments of history.



  ```sh
  pip install vesuvius-phalanx
  ```


  - Python 3.8+



  - **requests**: For handling HTTP requests and downloading content from the web.
  - **beautifulsoup4**: For parsing HTML and extracting useful information from web pages.
  - **tqdm**: Provides a progress bar to visualize the download progress.
  - **click**: A package for creating user-friendly command-line interfaces.





  ```sh
  phalanx download-volume --scroll-name SCROLL_NAME [--volpkg-name VOLPKG_NAME] [--volume-id VOLUME_ID] [--slices SLICES]
  ```

  - `--scroll-name`: Name of the scroll (e.g., 'Scroll1').
  - `--volpkg-name`: Name of the volpkg (optional).
  - `--volume-id`: Volume identifier (optional).
  - `--slices`: Slice ranges to download (default is all).



  ```sh
  phalanx download-fragment --scroll-name SCROLL_NAME [--volpkg-name VOLPKG_NAME] --fragment-id FRAGMENT_ID [--slices SLICES] [--mask]
  ```

  - `--scroll-name`: Name of the scroll (e.g., 'Scroll1').
  - `--volpkg-name`: Name of the volpkg (optional).
  - `--fragment-id`: Fragment identifier.
  - `--slices`: Slice ranges to download (default is all).
  - `--mask`: Download mask (default is true).





  ```sh
  phnx download-volume --scroll-name Scroll1 --volume-id 20230205180739 --slices 1-5
  ```



  ```sh
  phnx download-volume --scroll-name Scroll1 --volume-id 20230205180739
  ```



  ```sh
  phnx download-fragment --scroll-name Scroll1 --fragment-id 20230503225234 --slices all
  ```



  - **Multithreaded Downloads**: Download slices in parallel for improved performance.
  - **Flexible Slice Selection**: Download specific slices, ranges, or all slices.
  - **User-Friendly CLI**: Command-line interface built with [Click](https://click.palletsprojects.com/en/stable/).



  Contributions are welcome! Please submit a pull request or open an issue.



  This project is licensed under the MIT License.



  - **Progress Bar**: Tracks the number of files downloaded and total data.
  - **Error Handling**: Informs users if any files fail to download after retries.
  - **Extensibility**: Easily add new downloaders or features.

rpm_license:
  The MIT License (MIT)  Copyright © 2024 <copyright holders>  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: 51d62cec85e594c07c6ae563f3be4afdafbdd7c01a327c17deeaa20336502db2
name: python-vetiver-help
arch: noarch
version: 0.2.6
epoch: 0
release: 1
summary: Development documents and examples for vetiver
url: https://pypi.org/project/vetiver/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vetiver-0.2.6-1.src.rpm
location_href: Packages/python-vetiver-help-0.2.6-1.noarch.rpm
checksum_type: sha256
description:
  <!-- badges: start -->

  [![Lifecycle:
  experimental](https://img.shields.io/badge/lifecycle-experimental-orange.svg)](https://lifecycle.r-lib.org/articles/stages.html#experimental) [![codecov](https://codecov.io/gh/isabelizimm/vetiver-python/branch/main/graph/badge.svg?token=CW6JHVS6ZX)](https://codecov.io/gh/isabelizimm/vetiver-python)

  <!-- badges: end -->

  _Vetiver, the oil of tranquility, is used as a stabilizing ingredient in perfumery to preserve more volatile fragrances._

  The goal of vetiver is to provide fluent tooling to version, share, deploy, and monitor a trained model. Functions handle both recording and checking the model's input data prototype, and predicting from a remote API endpoint. The vetiver package is extensible, with generics that can support many kinds of models, and available for both Python and R. To learn more about vetiver, see:

  - the documentation at <https://vetiver.rstudio.com/>
  - the R package at <https://rstudio.github.io/vetiver-r/>

  You can use vetiver with:

  -   [scikit-learn](https://scikit-learn.org/)
  -   [torch](https://pytorch.org/)
  -   [statsmodels](https://www.statsmodels.org/stable/index.html)
  -   [xgboost](https://xgboost.readthedocs.io/en/stable/)
  -   [spacy](https://spacy.io/)
  -   or utilize [custom handlers](https://rstudio.github.io/vetiver-python/stable/advancedusage/custom_handler.html) to support your own models!



  You can install the released version of vetiver from [PyPI](https://pypi.org/project/vetiver/):

  ```python
  python -m pip install vetiver
  ```

  And the development version from [GitHub](https://github.com/rstudio/vetiver-python) with:

  ```python
  python -m pip install git+https://github.com/rstudio/vetiver-python
  ```



  A `VetiverModel()` object collects the information needed to store, version, and deploy a trained model.

  ```python
  from vetiver import mock, VetiverModel

  X, y = mock.get_mock_data()
  model = mock.get_mock_model().fit(X, y)

  v = VetiverModel(model, model_name='mock_model', prototype_data=X)
  ```

  You can **version** and **share** your `VetiverModel()` by choosing a [pins](https://rstudio.github.io/pins-python/) "board" for it, including a local folder, [Connect](https://posit.co/products/enterprise/connect/), Amazon S3, and more.

  ```python
  from pins import board_temp
  from vetiver import vetiver_pin_write

  model_board = board_temp(versioned = True, allow_pickle_read = True)
  vetiver_pin_write(model_board, v)
  ```

  You can **deploy** your pinned `VetiverModel()` using `VetiverAPI()`, an extension of [FastAPI](https://fastapi.tiangolo.com/).

  ```python
  from vetiver import VetiverAPI
  app = VetiverAPI(v, check_prototype = True)
  ```

  To start a server using this object, use `app.run(port = 8080)` or your port of choice.



  This project is released with a [Contributor Code of Conduct](https://www.contributor-covenant.org/version/2/1/CODE_OF_CONDUCT.html). By contributing to this project, you agree to abide by its terms.

  - For questions and discussions about deploying models, statistical modeling, and machine learning, please [post on Posit Community](https://forum.posit.co/new-topic?category_id=15&tags=vetiver,question).

  - If you think you have encountered a bug, please [submit an issue](https://github.com/rstudio/vetiver-python/issues).


pkgId: 38e0cdaeab7100fd4ea2298696f5477c6848a56b671d9cdc1e7012ee261246ed
name: python-vex-reader-help
arch: noarch
version: 0.9.2
epoch: 0
release: 1
summary: Development documents and examples for vex-reader
url: https://github.com/vdanen/vex-reader
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vex-reader-0.9.2-1.src.rpm
location_href: Packages/python-vex-reader-help-0.9.2-1.noarch.rpm
checksum_type: sha256
description:
  Public on : 2002-06-15
  Impact    : Moderate
  CVSS Score: 5.0
  Vulnerability summary
  krb5: UDP ping-pong flaw in kpasswd
  Vulnerability description
  schpw.c in the kpasswd service in kadmind in MIT Kerberos 5 (aka krb5) before 1.11.3 does not properly validate UDP packets before
  sending responses, which allows remote attackers to cause a denial of service (CPU and bandwidth consumption) via a forged packet that
  triggers a communication loop, as demonstrated by krb_pingpong.nasl, a related issue to CVE-1999-0103.
  CVSS score applicability
  The CVSS score(s) listed for this vulnerability do not reflect the associated product's status, and are included for informational
  purposes to better understand the severity of this vulnerability.
  Terms of Use
  This content is licensed under the Creative Commons Attribution 4.0 International License
  (https://creativecommons.org/licenses/by/4.0/). If you distribute this content, or a modified version of it, you must provide
  attribution to Red Hat Inc. and provide a link to the original.
  Additional Information
    Bugzilla: 962531
  External References
    https://bugzilla.redhat.com/show_bug.cgi?id=962531
    https://www.cve.org/CVERecord?id=CVE-2002-2443
    https://nvd.nist.gov/vuln/detail/CVE-2002-2443
  Red Hat affected packages and issued errata
    RHSA-2013:0942 -- Red Hat Enterprise Linux Workstation (v. 6)
  CVSS v2 Vector
    Red Hat: AV:N/AC:L/Au:N/C:N/I:N/A:P
    NVD    : AV:N/AC:L/Au:N/C:N/I:N/A:P
  CVSS v2 Score Breakdown
                             Red Hat    NVD
    CVSS v2 Base Score       5.0        5.0
    Access Vector            Network    Network
    Access Complexity        Low        Low
    Authentication           None       None
    Confidentiality Impact   None       None
    Integrity Impact         None       None
    Availability Impact      Partial    Partial
  Copyright © Red Hat, Inc. All rights reserved
  ```
  By default, `vex-reader` will pull the CVSS score from NVD's API.  If this
  is undesirable (for testing, etc) you can pass the `--no-nvd` argument to
  prevent lookups. Currently, `vex-reader` requires the VEX file to parse to
  be on-disk.
  A good place to find some VEX documents to play with is here: https://wid.cert-bund.de/.well-known/csaf-aggregator/aggregator.json


pkgId: 9c38fdf4ca99680b235031c0215e6fd56591c8a40ed64fab95fc157999fa675b
name: python-vfbLib-help
arch: noarch
version: 0.8.0
epoch: 0
release: 1
summary: Development documents and examples for vfbLib
url: https://pypi.org/project/vfblib/
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vfbLib-0.8.0-1.src.rpm
location_href: Packages/python-vfbLib-help-0.8.0-1.noarch.rpm
checksum_type: sha256
description:
  Converter and deserializer for FontLab Studio 5 VFB files.

  FontLab’s own `vfb2ufo` converter is from 2015, only outputs UFO v2, and
  contains serious bugs that are never going to be fixed. Its support on macOS is
  subject to Apple’s mercy (no native support for Apple Silicon).

  That’s why a single determined programmer with a hex editor set out to rectify
  this situation.




  - Outputs normalized UFO v3
  - Outputs FontLab user data (font and glyph level)
  - Mark colors are written to the official UFO v3 lib key
  - Guideline data is written to the official UFO v3 elements
  - Anchors are preserved in composite glyphs
  - PostScript hinting is written correctly, but to the Adobe lib key
  - TrueType hinting is supported in composite glyphs
  - Supports more UFO font info attributes:
    - `openTypeGaspRangeRecords`
    - `openTypeHeadLowestRecPPEM`
    - `openTypeNameRecords`
    - `openTypeOS2WeightClass` is written correctly






  Convert a VFB to one UFO per master. Command line options are compatible to
  FontLab’s `vfb2ufo`, but not all of them are implemented yet.

  ```bash
  $ vfb3ufo MyFile.vfb
  ```

  will convert the file to `MyFile.ufo` in the same directory. Existing files will
  not be overwritten unless you specify the `-fo` option.

  ```
  vfb3ufo -h
  usage: vfb3ufo [-h] [-p PATH] [-fo] [-k] [-ttx] [-64] [-s] [-nops] [-z] [-m] [-u] inputpath [outputpath]

  VFB3UFO Converter Copyright (c) 2023 by LucasFonts Build 2024-01-10

  positional arguments:
    inputpath             input file path (.vfb)
    outputpath            output file path (.ufo[z])

  options:
    -h, --help            show this help message and exit
    -p PATH, --path PATH  output folder
    -fo, --force-overwrite
                          force overwrite
    -k, --add-kerning-groups
                          add kerning groups to feature code
    -64, --base64         write GLIF lib 'data' section using base64 (recommended)
    -s, --silent          no display (silent mode)
    -nops, --no-postscript-hints
                          Don't output PostScript hinting
    -z, --zip             write UFOZ (compressed UFO)
    -m, --minimal         parse only minimal amount of data, drop missing glyphs from groups, etc.
    -u, --unicode-strings
                          interpret name table strings as Unicode instead of Windows-1252

  Not yet implemented options:

    -ttx, --ttx           convert binary OpenType Layout data using TTX-like format
  ```




  Generate a representation that closely adheres to the VFB structure.

  ```bash
  $ vfb2json MyFile.vfb
  ```

  will convert the file to `MyFile.vfb.json` in the same directory. Existing files will be overwritten.

  We expect this to be mostly used for debugging purposes.

  ```
  vfb2json -h
  usage: vfb2json [-h] [-d] [--header] [-m] [-p PATH] inputpath

  VFB2JSON Converter Copyright (c) 2023 by LucasFonts Build 2023-07-18

  positional arguments:
    inputpath             input file path (.vfb)

  options:
    -h, --help            show this help message and exit
    -d, --no-decompile    don't decompile data, output binary in JSON
    --header              only read the VFB header, not the actual data
    -m, --minimal         parse only minimal amount of data
    -p PATH, --path PATH  output folder
  ```




  Convert a VFB file to quadratic using the `cu2qu` library.

  ```bash
  $ vfbcu2qu MyFile.vfb
  ```

  will convert the file and save it with the suffix `.qu.vfb` in the same directory.

  ```
  usage: vfbcu2qu [-h] [-p PATH] [-fo] [-m MAX_ERR_EM] inputpath [outputpath]

  VFB Cubic to Quadratic Converter Copyright (c) 2023 by LucasFonts Build 2023-07-18

  positional arguments:
    inputpath             input file path (.vfb)
    outputpath            output file path (.vfb)

  options:
    -h, --help            show this help message and exit
    -p PATH, --path PATH  output folder
    -fo, --force-overwrite
                          force overwrite
    -m MAX_ERR_EM, --max-err-em MAX_ERR_EM
                          Maximum allowed error, relative to the font's units per em. Default is 0.001.
  ```




  Generate a diff of two VFB files, either in unified diff or HTML format.

  ```
  usage: vfbdiff [-h] [--html HTML] file1 file2

  vfbdiff Copyright (c) 2023 by LucasFonts Build 2023-07-18

  positional arguments:
    file1        First input file path (.vfb)
    file2        Second input file path (.vfb)

  options:
    -h, --help   show this help message and exit
    --html HTML  Output diff in HTML format to file path
  ```



  © 2022–2024 by [LucasFonts GmbH](https://www.lucasfonts.com/), Berlin


pkgId: de2a4d6e26242a18b177ab39965c195451ede99445547869eabd8777281f8826
name: python-viadot2-help
arch: noarch
version: 2.1.27
epoch: 0
release: 1
summary: Development documents and examples for viadot2
url: https://pypi.org/project/viadot2/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-viadot2-2.1.27-1.src.rpm
location_href: Packages/python-viadot2-help-2.1.27-1.noarch.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://dyvenia.github.io/viadot/" target="_blank">https://viadot.docs.dyvenia.com</a>


pkgId: d1fd0ae080e5c55c2ad63029fc419923201f1593291f9d06ee93210ccb1c0850
name: python-viafoundry-sdk-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for viafoundry-sdk
url: https://github.com/viascienific/viafoundry-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-viafoundry-sdk-1.0.1-1.src.rpm
location_href: Packages/python-viafoundry-sdk-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  1. **Install via pip**:
     ```bash
     pip install viafoundry-sdk
     ```
  2. **Verify Installation**:
     - For CLI:
       ```bash
       foundry --help
       ```
     - For SDK:
       Open a Python interpreter and ensure the package is importable:
       ```python
       import viafoundry


pkgId: 0b760d9ed731531fff54791894849687902659c3084245de09005a9ec6d7dcd6
name: python-victron-help
arch: noarch
version: 1.0.1
epoch: 0
release: 1
summary: Development documents and examples for victron
url: https://gitlab.com/jfk344/python-victron-sdk
rpm_license: mit
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-victron-1.0.1-1.src.rpm
location_href: Packages/python-victron-help-1.0.1-1.noarch.rpm
checksum_type: sha256
description:
  > **__NOTE:__** This is not an offical Victron SDK.






  ```bash
  pip install victron
  ```



  ```python
  from victron import Victron


  config = {
      "grid_limit": device.get(c.CFG_GRID_LIMIT),
      "ess_feed_limit": device.get(c.CFG_ESS_FEED_LIMIT),
      "ess_soc_limit": device.get(c.CFG_ESS_SOC_LIMIT),
  }


  victron = victron(
      host="my-Victron.local",
      port=502,
      unit_id=100,
      config=config
  )


  soc = victron.getSoc()


  print(soc)
  ```


  ```python
  Victron(
      host:str,
      port:int=502,
      unit_id:int=100,
      config:dict={}
  )
  ```


  > **__NOTE:__** The Configuration is to prevent the devices form overloading the grid or other components! Handle with care!

  When values are not provided or None the are unused.
  ```python
  {
      "grid_limit": None, # The limit of the grid the deivce is connected to
      "ess_feed_limit": None, # The limit of the feed from ESS to the grid
      "ess_soc_limit": None, # The limit of the state of charge of the ESS
  }
  ```



  - Get the state of charge


  - Read a single holding register
  - Parse = True handles signed values


pkgId: bee355577b34e2650bb57f11bdd2c984e298e0e9ce1d0e21fb59a95b67fe73d1
name: python-video-editor-mcp-help
arch: noarch
version: 0.1.7
epoch: 0
release: 1
summary: Development documents and examples for video-editor-mcp
url: https://github.com/burningion/video-editing-mcp
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-video-editor-mcp-0.1.7-1.src.rpm
location_href: Packages/python-video-editor-mcp-help-0.1.7-1.noarch.rpm
checksum_type: sha256
description:
  Upload, edit, and generate videos from everyone's favorite LLM and [Video Jungle](https://www.video-jungle.com/).

  You'll need to sign up for an account at [Video Jungle](https://app.video-jungle.com/register) in order to use this tool, and add your API key.

  [![PyPI version](https://badge.fury.io/py/video-editor-mcp.svg)](https://badge.fury.io/py/video-editor-mcp)





  The server implements an interface to upload, generate, and edit videos with:
  - Custom vj:// URI scheme for accessing individual videos and projects
  - Each project resource has a name, description
  - Search results are returned with metadata about what is in the video, and when, allowing for edit generation directly



  Coming soon.



  The server implements a few tools:
  - add-video: Add a video from a URL
    - Returns an vj:// URI to reference the Video file
  - search-videos: Search videos using embeddings
    - Returns video matches based upon embeddings and keywords
  - generate-edit-from-videos
    - Generates a rendered video edit from a set of video files
  - generate-edit-from-single-video
    - Generate an edit from a single input video file



  In order to use the tools, you'll need to sign up for Video Jungle and add your API key.

  **add-video**

  Here's an example prompt to invoke the `add-video` tool:

  ```
  can you download the video at https://www.youtube.com/shorts/RumgYaH5XYw and name it fly traps?
  ```

  This will download a video from a URL, add it to your library, and analyze it for retrieval later. Analysis is multi-modal, so both audio and visual components can be queried against.

  **search-videos**

  Once you've got a video downloaded and analyzed, you can then do queries on it using the `search-videos` tool:

  ```
  can you search my videos for fly traps?
  ```

  Search results contain relevant metadata for generating a video edit according to details discovered in the initial analysis.

  **generate-edit-from-videos**

  Finally, you can use these search results to generate an edit:

  ```
  can you create an edit of all the times the video says "fly trap"?
  ```

  (Currently), the video edits tool relies on the context within the current chat.

  **generate-edit-from-single-video**

  Finally, you can cut down an edit from a single, existing video:

  ```
  can you create an edit of all the times this video says the word "fly trap"?
  ```



  You must login to [Video Jungle settings](https://app.video-jungle.com/profile/settings), and get your [API key](https://app.video-jungle.com/profile/settings). Then, use this to start Video Jungle MCP:

  ```bash
  $ uv run video-editor-mcp YOURAPIKEY
  ```







  You'll need to adjust your `claude_desktop_config.json` manually:

  On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
  On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

  <details>
    <summary>Development/Unpublished Servers Configuration</summary>

   ```json
    "mcpServers": {
      "video-editor-mcp": {
        "command": "/Users/YOURDIRECTORY/.local/bin/uv",
        "args": [
          "--directory",
          "/Users/YOURDIRECTORY/video-editor-mcp",
          "run",
          "video-editor-mcp",
          "YOURAPIKEY"
        ]
      }
    }
    ```

  </details>

  <details>
    <summary>Published Servers Configuration</summary>

   ```json
    "mcpServers": {
      "video-editor-mcp": {
        "command": "uvx",
        "args": [
          "video-editor-mcp",
          "YOURAPIKEY"
        ]
      }
    }
    ```
  </details>

  Be sure to replace the directories with the directories you've placed the repository in on **your** computer.





  To prepare the package for distribution:

  1. Sync dependencies and update lockfile:
  ```bash
  uv sync
  ```

  2. Build package distributions:
  ```bash
  uv build
  ```

  This will create source and wheel distributions in the `dist/` directory.

  3. Publish to PyPI:
  ```bash
  uv publish
  ```

  Note: You'll need to set PyPI credentials via environment variables or command flags:
  - Token: `--token` or `UV_PUBLISH_TOKEN`
  - Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`



  Since MCP servers run over stdio, debugging can be challenging. For the best debugging
  experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


  You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

  (Be sure to replace `YOURDIRECTORY` and `YOURAPIKEY` with the directory this repo is in, and your Video Jungle API key, found in the settings page.)

  ```bash
  npx @modelcontextprotocol/inspector uv --directory /Users/YOURDIRECTORY/video-editor-mcp run video-editor-mcp YOURAPIKEY
  ```


  Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

  Additionally, I've added logging to `app.log` in the project directory. You can add logging to diagnose API calls via a:

  ```
  logging.info("this is a test log")
  ```

  A reasonable way to follow along as you're workin on the project is to open a terminal session and do a:

  ```bash
  $ tail -f 90 app.log
  ```


pkgId: 65eef8df50b10ce9df722071e15dd26a22b463a55b90778288c374fdaab7689f
name: python-video-representations-extractor-help
arch: noarch
version: 1.7.4
epoch: 0
release: 1
summary: Development documents and examples for video-representations-extractor
url: https://gitlab.com/video-representations-extractor/video-representations-extractor
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-video-representations-extractor-1.7.4-1.src.rpm
location_href: Packages/python-video-representations-extractor-help-1.7.4-1.noarch.rpm
checksum_type: sha256
description:
  ![logo](logo.png)



  The purpose of this repository is to export various representations starting from RGB videos only. Representations are
  defined as ways of 'looking at the world'. One can watch at various levels of information:
  - low level: colors, edges
  - mid level: depth, orientation of planes (normals)
  - high level: semantics and actions

  For GitHub users: this is a mirror of the
  [gitlab repository](https://gitlab.com/video-representations-extractor/video-representations-extractor).

  <u>Supported representations</u>

  - See [here](vre/representations/build_representations.py) for a comprehensive list, since it updates faster
  than this README.

  Weights are stored in this directory using `git-lfs`: [weights dir](./resources/weights/). If you just want to download
  the code, without the weights resources, use `GIT_LFS_SKIP_SMUDGE=1 git clone ...`.




  Here's is a recent google colab run: [link](https://colab.research.google.com/drive/1vAp71H-TLewhF56odv33TkmGwwhuoFJ-?usp=sharing)
  that is based in [this examples notebook](examples/semantic_mapper/semantic_mapper.ipynb).


  Using the VRE CLI tool is as simple as:
  ```bash
  vre <path/to/video.mp4> --config_path <path/to/cfg> -o <path/to/export_dir>
  ```

  **Relevant env variables**
  - `VRE_WEIGHTS_DIR` The path where the weights are downloaded from the weights repository. If not set, will be defaulted
  in the root of the project in a resources dir.
  - `VRE_DEVICE` Some default cfgs will use this to set the device of representations. Usage is:
   `VRE_DEVICE=cuda CUDA_VISIBLE_DEVICES=0 vre ...`. You can of course update the yaml config files to not use this
   pattern.

  For testing that the installation works, we recommend you to run with this test video first:
  ```bash
  mkdir example/
  chmod 777 -R example/ # required only for docker
  curl "https://gitlab.com/video-representations-extractor/video-representations-extractor/-/raw/master/resources/test_video.mp4" \
    -o example/video.mp4 # you can of course use any video, not just our test one
  curl https://gitlab.com/video-representations-extractor/video-representations-extractor/-/raw/master/test/end_to_end/imgur/cfg.yaml -o example/cfg.yaml
  ```



  ```
  conda create -n vre python=3.11 anaconda # >=3.10 tested
  pip install video-representations-extractor
  [VRE_DEVICE=cuda CUDA_VISIBLE_DEVICES=0] vre example/video.mp4 --connfig_path example/cfg.yaml -o example
  ```


  We offer a pre-pushed VRE image in dockerhub.

  ```
  docker run -v `pwd`/example:/app/example -v `pwd`/resources/weights:/app/weights \
    --gpus all -e VRE_DEVICE='cuda' -e VRE_WEIGHTS_DIR=/app/weights \
    meehai/vre:latest /app/example/video.mp4 \
    --config_path /app/example/cfg.yaml -o /app/example/output_dir --start_frame 100 --end_frame 101
  ```

  Note: For the `--gpus all -e VRE_DEVICE='cuda'` part to work, you need to install `nvidia-container-toolkit` as well.
  Check NVIDIA's documentation for this. If you are only on a CPU machine, then remove them from the docker run command.


  You can, of course, clone this repository and add it to your path for development:
  ```
  conda create -n vre python=3.11 anaconda # >=3.10 tested
  [GIT_LFS_SKIP_SMUDGE=1] git clone https://gitlab.com/video-representations-extractor/video-representations-extractor [/local/vre/dir]
  pip install -r /local/vre/dir/requirements.txt # there's a setup.py file too if you wish

  export PYTHONPATH="$PYTHONPATH:/local/vre/dir"
  export PATH="$PATH:/local/vre/dir/cli"

  pytest /local/vre/dir/test # requires that pytest is installed
  [VRE_DEVICE=cuda CUDA_VISIBLE_DEVICES=0] bash test/end_to_end/imgur/run.sh # run the e2e test
  [VRE_DEVICE=cuda CUDA_VISIBLE_DEVICES=0] vre example/video.mp4 --connfig_path example/cfg.yaml -o example
  ```



  You can get the representations for a single image (or a directory of images) by placing your image in a standalone
  directory.

  ```bash
  vre <path/to/dir_of_images> --config_path <path/to/cfg> -o <path/to/export_dir>
  ```





  Any video format that is supported by `ffmpeg`. Representations were mostly tested on UAV-like videos, but they should
  be fine for self driving videos or even indoor handheld videos.



  The config file will have the hyperparameters required to instantiate each supported method as well as global
  hyperparameters for the output. These parameters are sent to the constructor of each representation, so one can pass
  additional semantics to each representation, such as classes of a semantic segmentation or the maximum global depth
  value in meters.

  High level format:

  ```yaml
  name_of_representation: # spaces work too in the name but it's less desired due to other tools having issues
    type: some high level type (such as depth/dpt, semantic/mask2former, edges/dexined etc.)
    dependencies: [a list of dependencies given by their names]
    parameters: # as defined in the constructor of the implementation
      param1: value1
      param2: value2
    learned_parameters: # applies only to representations that are learned and require weights (only torch atm)
      device: "cuda" # for representations that have in their vre_setup() method a model.to(device) call

  name_of_representation_2:
    type: some other type
    name: some other method
    dependencies: [name_of_representation] # since this representation depends on the prev one, it'll be computed after
    parameters: []
    compute_paramters:
      batch_size: 5 # overwrite the global default (that is 1)
    io_parameters:
      image_format: not-set
      binary_format: npy # overwrite the global default (that is npz)
      compress: False
  ```

  Example cfg file: See [out of the box supported representations](test/end_to_end/imgur/cfg.yaml) and the CFG defined
  in the [CI process](test/end_to_end/imgur/run.sh) for an actual export that is done at every commit on a real video.

  Note: If the topological sort fails (because of cycle dependencies), an error will be thrown.



  All the outputs are going to be stored in the output directory (`--output_dir/-o`) with one file for each frame.
  A subdirectory will be created for each representation. We have 2 options right now: binary_format (npz or npy only) and
  image_format (png, jpg, whatever is supported by the PIL writer etc.) though we might merge this into a single
  'exporter' thsat will receive a list of possible output formats for each representation.

  For the above CFG file, 2 subdirectories will be created:

  ```
  /path/to/output_dir/
    name_of_representation/
      npz/ # if binary_format=='npz'
        1.npz, ..., N.npz
      png/ # if image_format=='png'
        1.png, ..., N.png
    name_of_representation_2/
      npz/
        1.npz, ..., N.npz
  ```

  The `cfg.yaml` file for each representation is created so that we know what parameters were used for that
  representation.



  In the [cli/](cli) dir we have a bunch of exported tools, besides `vre` itself.



  `vre_collage` that takes all the image files (png, jpg etc.) from an output_dir as above and
  stacks them together in a single image. This is useful if we want to create a single image of all representations which
  can later be turned into a video as well.

  Usage:
  ```
  vre_collage /path/to/output_dir --config_path /path/to/config.yaml -o /path/to/collage_dir
  [--overwrite] [--video] [--fps] [--output_resolution H W]
  ```

  ```
  /path/to/collage_dir/
    collage/
      1.png, ..., N.png # 1.png = stack([name_of_representation/png/1.png, name_of_representation_2/png/1.png])
  ```

  Note: you can also get video from a collage dir like this (in case you forgot to set --video or want more control):

  ```bash
  cd /path/to/collage_dir
  ffmpeg -start_number 1 -framerate 30 -i %d.png -c:v libx264 -pix_fmt yuv420p /path/to/collage.mp4;
  ```



  The `vre_reader` tool can be used to iterate over the extracted vre dataset from the provided output path.

  Usage:
  ```
  vre_reader /path/to/output_dir --config_path /path/to/config.yaml --mode [MODE] [--batch_size B]
  [--handle_missing_data H]
  ```

  We have 2 choices for `--mode`:
  - `read_one_batch` Reads a single batch at random using `torch.utils.data.DataLoader` and, after reading, it will invoke
  the plotting function (similar to `vre_collage`). It only prints the shapes.
  - `iterate_all_data` Will iterate the entire dataset to see if the data is corrupted.

  Handle missing data is passed to the `MultiTaskDataset` dataset constructor and accepts all the choices from there.
  Defaults to 'raise' which will raise an exception if any representation has missing data (i.e. each xxx.npz must be
  present for all the representations).


pkgId: 0bd3bc6198363364ba3fd2f05356840d2052ab8edfa8a1a09b5f2b5464c9d93e
name: python-vidformer-help
arch: noarch
version: 0.7.0
epoch: 0
release: 1
summary: Development documents and examples for vidformer
url: https://ixlab.github.io/vidformer/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vidformer-0.7.0-1.src.rpm
location_href: Packages/python-vidformer-help-0.7.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/vidformer.svg)](https://pypi.org/project/vidformer/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ixlab/vidformer/blob/main/LICENSE)

  vidformer-py is a Python 🐍 interface for [vidformer](https://github.com/ixlab/vidformer).
  Our [getting started guide](https://ixlab.github.io/vidformer/getting-started.html) explains how to use it.

  **Quick links:**
  * [📦 PyPI](https://pypi.org/project/vidformer/)
  * [📘 Documentation - vidformer-py](https://ixlab.github.io/vidformer/vidformer-py/)
  * [📘 Documentation - vidformer.cv2](https://ixlab.github.io/vidformer/vidformer-py-cv2/)
  * [🧑‍💻 Source Code](https://github.com/ixlab/vidformer/tree/main/vidformer-py/)

  **Publish:**
  ```bash
   export FLIT_USERNAME='__token__' FLIT_PASSWORD='<token>'
  flit publish
  ```


pkgId: 2083eba025d82b44cabc9da842e739286933ec51385af744f55e178f44239551
name: python-viresclient-help
arch: noarch
version: 0.12.1
epoch: 0
release: 1
summary: Development documents and examples for viresclient
url: https://pypi.org/project/viresclient/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-viresclient-0.12.1-1.src.rpm
location_href: Packages/python-viresclient-help-0.12.1-1.noarch.rpm
checksum_type: sha256
description:
  You can reference *viresclient* directly using the DOI of our zenodo_ record. VirES uses data from a number of different sources so please also acknowledge these appropriately.
      | "We use the Python package, viresclient [1], to access [...] from ESA's VirES for Swarm service [2]"
      | [1] https://doi.org/10.5281/zenodo.2554162
      | [2] https://vires.services


pkgId: 7ba953b8fc3979b98b37e0601bf7a03495cb47563347ee7078e635bf762307b0
name: python-virtual-term-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for virtual-term
url: https://github.com/MatthewScholefield/virtual-term
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-virtual-term-0.1.0-1.src.rpm
location_href: Packages/python-virtual-term-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  _A simple Python library for creating and interacting with virtual terminals_

  VirtualTerm is a Python library designed for creating and managing virtual terminal sessions programmatically. It allows users to run interactive shell commands, handle command timeouts, and monitor output streams within isolated terminal environments. This library is particularly useful for developers building automation tools, testing environments, or managing interactive shell-based workflows.

  ```python
  import asyncio
  from virtual_term import VirtualTerm

  async def main():
      with await VirtualTerm.spawn() as term:
          term.write("sudo apt-get upgrade\n")
          await asyncio.sleep(1)
          print(term.read_new_output().decode())

          term.write("y\n")  # Respond with 'y' to confirm upgrade
          result = await term.wait_for_last_command()

          print(result.output)
          assert result.return_code == 0

  asyncio.run(main())
  ```



  Install with pip:

  ```sh
  pip install virtual-term
  ```



  VirtualTerm uses Rye for dependency management and development workflows. To get started with development, ensure you have [Rye](https://github.com/astral-sh/rye) installed, then clone the repository and set up the environment:

  ```sh
  git clone https://github.com/MatthewScholefield/virtual-term.git
  cd virtual-term
  rye sync
  rye run pre-commit install


  rye test
  ```


pkgId: 6577906fe6fb5ea1945432a1a1a5438c830559703e0bf8a7e67fc12ee7f959fd
name: python-virtuals-sdk-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for virtuals-sdk
url: https://github.com/Virtual-Protocol/virtuals-python
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-virtuals-sdk-0.1.1-1.src.rpm
location_href: Packages/python-virtuals-sdk-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  For


  ```bash
  pip install virtuals_sdk
  ```


  ```python
  from virtuals.game import Agent


  agent = Agent(
  		api_key=VIRTUALS_API_KEY,
      goal="Autonomously analyze crypto markets and provide trading insights",
      description="HODL-9000: A meme-loving trading bot powered by hopium and ramen",
      world_info="Virtual crypto trading environment where 1 DOGE = 1 DOGE"
  )


  response = agent.simulate_twitter()


  agent.deploy_twitter()
  ```


pkgId: b5b0b5ba83e8031dccfe87ecfbe55ab93090fe825f191ee7287c67198c567a60
name: python-virusrecom-help
arch: noarch
version: 1.3.6
epoch: 0
release: 1
summary: Development documents and examples for virusrecom
url: https://github.com/ZhijianZhou01/virusrecom
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-virusrecom-1.3.6-1.src.rpm
location_href: Packages/python-virusrecom-help-1.3.6-1.noarch.rpm
checksum_type: sha256
description:
  ![](https://img.shields.io/badge/System-Windows/Linux/MacOS-green.svg)
  ![](https://img.shields.io/pypi/pyversions/virusrecom)
  [![](https://img.shields.io/badge/Doi-10.1093/bib/bbac513-yellow.svg)](https://doi.org/10.1093/bib/bbac513)

  ![](https://img.shields.io/pypi/wheel/virusrecom)
  ![](https://img.shields.io/pypi/dm/virusrecom)
  ![](https://img.shields.io/github/stars/ZhijianZhou01/virusrecom)





  VirusRecom is developed based on ```Python 3```, and you can get and install the VirusRecom in a variety of ways.



  virusrecom has been distributed to the standard library of PyPI (https://pypi.org/project/virusrecom/), and the latest version can be easily installed by the tool ```pip```.

  Firstly, download ```Python3``` (https://www.python.org/), and install ```Python3``` and ```pip``` tool, then,

  ```
  pip install virusrecom
  virusrecom -h
  ```


  virusrecom has been distributed to bioconda (https://anaconda.org/bioconda/virusrecom), and the latest version can be installed using the tool ```conda```.

  ```

  conda config --add channels defaults
  conda config --add channels bioconda
  conda config --add channels conda-forge



  conda create -n virusrecom_env python=3.7  # python >=3.5 but != 3.8
  conda activate virusrecom_env
  conda install virusrecom  # or "conda install bioconda::virusrecom"


  conda install virusrecom  # or "conda install bioconda::virusrecom"


  virusrecom -h
  ```




  In addition to the  ```pip``` and  ```conda``` methods, you can also install virusrecom manually using the file ```setup.py```.

  Firstly, download this repository, then, run:
  ```
  python setup.py install
  virusrecom -h
  ```



  virusrecom can also be run using the source code without installation. First, download this repository, then, install the required python environment of virusrecom:

  ```
  pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
  ```

  finally, run virusrecom by the file ```main.py```. Please view the help documentation by ```python main.py -h```.



  For the two earlier release packages (versions v1.0 and v1.1), you can also directly run the binary files of virusrecom without installation. The  binary files are provided at https://github.com/ZhijianZhou01/virusrecom/releases.

  In general, the executable file of virusrecom is located at the  ```main``` folder. Then, running the ```virusrecom.exe``` (windows system) or ```virusrecom``` (Linux or MacOS system) to start. If you could not get permission to run virusrecom on Linux system or MacOS system, you could change permissions by ```chmod -R 775 Directory``` or ```chmod -R 777 Directory```.



  virusrecom is a command-line-interface program, users can get help documentation of the software by entering  ```virusrecom -h ``` or  ```virusrecom --help ```.

  <b>Tip: since version 1.1, virusrecom optimizes the parameters of input-file, which is slightly different from virusrecom v1.0.</b>

  <b>The simple help documentation of virusrecom v1.3.6 is as follows.</b>

  | Parameter | Description |
  | --- | --- |
  |-h, --help | Show this help message and exit.|
  |-a ALIGNMENT | Aligned sequence file (*.fasta). Note, each sequence name requires containing lineage mark.|
  |-ua UNALIGNMENT | Unaligned (non-alignment) sequence file (*.fasta). Note, each sequence name requires containing lineage mark.|
  |-at ALIGN_TOOL | Program used for multiple sequence alignments (MSA).|
  |-iwic INPUT_WIC | Using the already obtained WIC values of reference lineages directly by a *.csv input-file.|
  |-q QUERY | Name of query lineage (usually potential recombinant), such as ‘-q xxxx’. Besides, ‘-q auto’ can scan all lineages as potential recombinant in turn.|
  |-l LINEAGES | Path of a text-file containing multiple lineage marks.|
  |-g GAP | Reserve sites containing gaps(-) in analyses? ‘-g y’ means to reserve, and ‘-g n’ means to delete.|
  |-m METHOD | Method for site scanning. ‘-m p’ uses polymorphic sites only, ‘-m a’ uses all the sites.|
  |-w WINDOW | Number of nucleotides sites per sliding window. Note: if the ‘-m p’ has been used, -w refers to the number of polymorphic sites per windows.|
  |-s STEP | Step size of the sliding window. Note: if the ‘-m p’ has been used, -s refers to the number of polymorphic sites per jump.|
  |-mr MAX_REGION | The maximum allowed recombination region. Note: if the ‘-m p’ method has been used, it refers the maximum number of polymorphic sites contained in a recombinant region.|
  |-cp PERCENTAGE | The cutoff threshold of proportion (cp, default: 0.9) used for searching recombination regions when mWIC/EIC >= cp, the maximum value of cp is 1.|
  |-cu CUMULATIVE | Simply using the max cumulative WIC of all sites to identify the major parent. Off by default. If required, specify ‘-cu y.|
  |-b BREAKPOINT | Possible breakpoint scan of recombination. ‘-b y’ means yes, ‘-b n’ means no. Note: this option only takes effect when ‘-m p’ has been specified.|
  | -bw BREAKWIN | The window size (default: 200) used for breakpoint scan. The step size is fixed at 1. Note: this option only takes effect when ‘-m p -b y’ has been specified.|
  |-t THREAD | Number of threads (or cores) for calculations, default: 4.|
  |-y Y_START | Starting value (default: 0) of the Y-axis in plot diagram.|
  |-le LEGEND | The location of the legend, the default is adaptive. '-le r' indicates placed on the right.|
  |-owic ONLY_WIC | Only calculate site WIC value. Off by default. If required, please specify ‘-owic y’.|
  |-e ENGRAVE | Engraves file name to sequence names in batches. By specifying a directory containing one or multiple sequence files (*.fasta).|
  |-en EXPORT_NAME | Export all sequence name of a *.fasta file.|
  |-o OUTDIR | Output directory to store all results.|
  |--block BLOCK_SIZE | Specifies the maximum number of sites per sub-block, different sub-blocks in sequence file will be sequentially loaded to calculate WIC. Default: 40000 sites.|
  |--no_wic_fig | Do not draw the image of WICs.|
  |--no_mwic_fig | Do not draw the image of mWICs.|

  <b>For detailed documentation, please refer to</b> [Manual of VirusRecom v1.1.3](https://github.com/ZhijianZhou01/virusrecom/blob/main/Manual%20of%20VirusRecom%20v1.1.3.pdf)

  For more information about the algorithm of virusrecom, please refer to [the publication of virusrecom](https://academic.oup.com/bib/article-abstract/24/1/bbac513/6886420).


  The sequences data for test in the documentation was stored at https://github.com/ZhijianZhou01/virusrecom/tree/main/example.

  <b>Note, the ```recombination_test_data.zip``` in directory ```example``` is against virusrecom v1.0, not virusrecom v1.1</b>.

  In this demonstration, the test data is from the the ```recombination_test_data_v1.1.zip``` provided in the directory ```example```.


  If the input sequence-data has been aligned, and it should be loaded via the ```-a``` parameter. Multiple sequence alignments (MSA) can be pre-completed by many programs, this is not introduced. Now, let's focus on the directory ```aligned_input_sequences``` in the file ```recombination_test_data_v1.1.zip```.

  (1) An aligned sequence-file named ```alignment_lineages_data.fasta```, which including multiple sequences from the query lineage and other reference lineages.

  (2) A text-file named ```reference_lineages_name.txt```, which including the names (marks) of these reference lineages.

  ```
       reference_lineage_1
       reference_lineage_2
       reference_lineage_3
       reference_lineage_4
       reference_lineage_5
       reference_lineage_6
       reference_lineage_7
       reference_lineage_8
       reference_lineage_9
  ```

  Note, these marks of reference lineages should also appear in sequence names of the file ```alignment_lineages_data.fasta```. <b>The mark of each reference lineage should be unique</b>, otherwise, there will be duplicate matches in subsequent analysis.

  Before running the command of VirusRecom, let's think about the search strategy for recombination events. Firstly, we use only polymorphic sites considering that sequences from these lineages are highly similar, which means that the parameter ```-m p``` needs to be specified. Secondly, we do not consider gap-containing sites in this test and use the parameter ```-g n```. Instead, if you consider these gap sites, you need to use the parameter ```-g y```. Next, in the first run, let's try first with a window size of 100 and a step size of 20. Of note the value of “size” at this time represents the number of polymorphic sites because the ```-m p``` parameter has been specified. For the two parameters ```-cp``` and ```-mr```, we use the default value of 0.9 and 1000 in this test. Finally, we specify a folder to save the results by parameter ```-o```.

  Then, switch the current directory to ```aligned_input_sequences```, and run the following command (an example) to detect recombination events in query lineage:

  ```
  virusrecom -a alignment_lineages_data.fasta -q query_recombinant -l reference_lineages_name.txt -g n -m p -w 100 -s 20 -o outdir
  ```

  Note: (1) if the current directory is not switched to ```aligned_input_sequences```, the file and directory path in command need the absolute paths instead of relative paths.
  (2) the string “query_recombinant” in command is the corresponding mark of query lineage in the file ```alignment_lineages_data.fasta```.


  <b>After the run is complete</b>, in the directory ```outdir```, there are three subdirectories and two aggregated reports:

  ![outdir.png](https://github.com/ZhijianZhou01/virusrecom/blob/main/figture/outdir.png)

  (1) In the directory ```run_record```, if ```-g n``` is specified, and the file ```Record_of_deleted_gap_sites_*.txt``` containing all the gap sites will be created. Besides, If ```-m p``` is specified, and the file ```Record_of_same_sites_in_aligned_sequence*.txt``` containing all the same sites will be created.

  (2) In the directory ```WICs_of_sites```, the file ```*_site_WIC_from_lineages.pdf```, ```*_site_WIC_from_lineages.xlsx``` and the file ```*_site_WIC.csv``` are used to record the WIC value of each site.

  (3) In the directory ```WICs_of_slide_window```, the file ```*_mWIC_from_lineages.xlsx``` and the file ```*_mWIC_from_lineages.pdf``` are used to record the mean WIC of each sliding window.

  ![recombination_step4.png](https://github.com/ZhijianZhou01/virusrecom/blob/main/figture/recombination_step4.png)

  The user can fine-tune the window size and step size according to the density of points in the generated graph. In general, very dense points means that the noise is too high and the window size can be increased appropriately in next scan.

  In addition to the three sub-directories above, VirusRecom provides two summary files. The file ```Possible_recombination_event_conciseness.txt``` only retains results of recombination events with p-values less than 0.05.
  ```
  Possible major parent: reference_lineage_1(global mWIC: 1.8976186779157704)

  Other possible parents and significant recombination regions (p<0.05):
  reference_lineage_2	7237 to 11539(mWIC: 1.9553354371515168), p_value: 7.831109305531908e-06

  Significance test of recombinant regions using Mann-Whitney-U test with two-tailed probabilities, p-value less than 0.05 indicates a significant difference.
  ```

  In this output report, the major parent of query lineage was ```reference_lineage_1``` and the minor parent was ```reference_lineage_2```, and the recombination region was site 7237 to 11539 and the p-value was 7.83e-06. The identified recombination event was relatively close to the actual (from site 7333 to 11473 in the genome), and the error of the recombination boundary is also acceptable.

  In fact, ```Possible_recombination_event_conciseness.txt``` is interpretations of the recombination information contained in ```*_mWIC_from_lineages.pdf```. Although VirusRecom shows a good balance between precision and recall in simulated data, false positive or false negatives sometimes occur. Therefore, for the identification results from VirusRecom, users can make own judgment.

  Besides, the output file ```Possible_recombination_event_detailed.txt``` shows those results with p-values greater than 0.05. <b>Tip: recombination events with p-values over 0.001 are less reliable</b>.

  If ```-b y``` is specified, then VirusRecom will perform the search of recombination breakpoint and plot. For example:
  ```
  virusrecom -a alignment_lineages_data.fasta -q query_recombinant -l reference_lineages_name.txt -g n -m p -w 100 -s 20 -b y -bw 200 -o outdir
  ```
  <b>Tip:</b> (1) ```-b y``` only takes effect when ```-m p``` has been specified.
  (2) the step size of breakpoint search is fixed to 1.

  The negative logarithm of p-value in each site is in the file ```*_-lg(p-value)_for_potential_breakpoint.pdf``` and the file ```*_-lg(p-value)_for_potential_breakpoint.xlsx```.

  ![breakpoint.jpg](https://github.com/ZhijianZhou01/virusrecom/blob/main/figture/breakpoint.jpg)

  The highest peak (the highest −lgP value) indicated the possible recombination breakpoint.


  VirusRecom can also handle unaligned input-sequences. In this case, multiple sequence alignment is performed by calling external program. In <b>virusrecom v1.1</b>, mafft, muscle, and clustal-omega is supported. It is worth mentioning that VirusRecom call them from the system path, so they need to be installed on the machine beforehand.

  For the example data in directory ```unaligned_input_sequences```, run the following command:
  ```
  virusrecom -ua unalignment_lineages_data.fas -at mafft -q query_recombinant -l reference_lineages_name.txt -g n -m p -w 100 -s 20 -o outdir
  ```
  <b>Note:</b> (1) ```-at mafft``` means to call mafft in the system path, and the alignment strategy is auto. Besides, using ```-at muscle``` to call muscle and using ```-at clustalo``` to call clustal-omega.
  (2) the string ```query_recombinant``` in command is the corresponding mark of query lineage in the file ```unalignment_lineages_data.fas```.

  The interpretation of the output result is consistent with section 3.1.



  In VirusRecom, the reference lineage is allowed to contain only one single sequence. Under this condition, mWIC value of the fragment is essentially a multiple of shared identity. If -g n is used in the calculation, the mWIC is twice as large as shared identity. If ```-g y``` is used in the calculation, the mWIC is $\log_2{5}$ as large as shared identity.

  Of noted, for recombination analysis without lineage data, the additional feature is only recommended for non-highly similar sequences and the user can use it to draw an identity point map.

  The test data is in directory ```non_lineage_data``` of the file ```recombination_test_data_v1.1.zip```.

  The Delta-CoV HNU1-1 is a known recombinant from SpCoV HKU17-USA and ThCoV HKU12, and the break points were identified at genome positions nt 21017 and 25056, which is jointly identified and confirmed by RDP3 and Simplot by [Wang et al., 2022](https://onlinelibrary.wiley.com/doi/10.1111/tbed.14029).

  Considering that they are not highly similar sequences, we use all sites (```-m a```) in the alignment. Then, we use a larger window value, and run following command:
  ```
  virusrecom -a alns.fasta -q HNU1-1 -l alns_seq_taxon.txt -g n -m a -w 800 -s 100 -cp 0.7 -mr 6000 -le r -o output

  ```

  The mWIC from reference lineages is as follows:

  ![hnu1-1.jpg](https://github.com/ZhijianZhou01/virusrecom/blob/main/figture/hnu1-1.jpg)

  <b>Note,</b> because each “lineage” contains only one sequence and ```-g n``` is used in the example, the mWIC in the picture is actually twice the size of “sequence identity”.

  The possible recombination event identified by VirusRecom is as follows:
  ```
  Possible major parent: HKU17-USA(global mWIC: 1.5914816042426252)

  Other possible parents and significant recombination regions (p<0.05):
  HKU12	20720 to 25297(mWIC: 1.8039433490697028), p_value: 2.783880536189705e-204
  ```

  The possible major parent of HNU1-1 is HKU17-USA and minor parent is HKU12, and the recombination region is about 20720-25297 nt in the alignment.




  For the value of a parameter, if not specified, the software uses the default value.
  However, the default value is not suitable for all data. In addition to window size (```-w```) and step size (```-s```) of sliding window, values of ```-cp``` and ```-mr``` also require users to adjust based on the data.

  When VirusRecom runs, the value of each parameter is printed printed on the screen and you can check them. <b>What is more, users should try different values in multiple runs, which will effectively reduce false positives and false negatives.</b>


  For the <b>recombination analysis using polymorphic sites</b> (```-m p``` in virusrecom), the following is recommended based on our limited experience,

  | Number of polymorphic sites in alignment | window size | step size |
  | --- | --- | --- |
  |polymorphic sites <= 2000 | 4% ~ 6% of all polymorphic sites | 10% ~ 20% of the window size |
  |polymorphic sites > 2000 | >= 100 | 10% ~ 20% of the window size |

  <b>Note, too large window size can't be used for the alignment with too few polymorphic sites.</b>


  Typically, this is part of the data preparation. In virusrecom v1.1, users can easily get it done via ```-e``` parameter. The ```-e``` parameter can engrave file-name to sequence names in batches. The example is as follows:
  ```
  virusrecom -e input_directory -o outdir
  ```
  <b>Tip:</b> The directory ```input_directory``` can contain multiple fasta files, and each fasta file can contain multiple sequences. After the running, finally, each sequence name will contain its file-name.

  Therefore, if the file-name of fasta file is a lineage name, the lineage name can be written into the sequence name in batches.


  If you own programming skills, you can directly modify the order of the colors in the ```plt_corlor_list.py``` file. If not, you can use output matrix provided by VirusRecom, and they are usually suffixed with ```.xlsx```.


  Zhou ZJ, Yang CH, Ye SB, Yu XW, Qiu Y, Ge XY. VirusRecom: an information-theory-based method for recombination detection of viral lineages and its application on SARS-CoV-2. <i>Brief Bioinform</i>. 2023 Jan 19;24(1):bbac513. [doi: 10.1093/bib/bbac513](https://academic.oup.com/bib/article-abstract/24/1/bbac513/6886420). PMID: 36567622.


pkgId: bae6177dea23735598071487d72a655e815a37756265c2d8bb38f0e36b85d875
name: python-vision-agent-help
arch: noarch
version: 0.2.212
epoch: 0
release: 1
summary: Development documents and examples for vision-agent
url: https://landing.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vision-agent-0.2.212-1.src.rpm
location_href: Packages/python-vision-agent-help-0.2.212-1.noarch.rpm
checksum_type: sha256
description:
      >>> custom_tool("image.jpg")
      """
      return np.zeros((10, 10))
  ```
  You need to ensure you call `@va.tools.register_tool` with any imports it uses. Global
  variables will not be captured by `register_tool` so you need to include them in the
  function. Make sure the documentation is in the same format above with description,
  `Parameters:`, `Returns:`, and `Example\n-------`. The `VisionAgent` will use your
  documentation when trying to determine when to use your tool. You can find an example
  use case [here](examples/custom_tools/) for adding a custom tool. Note you may need to
  play around with the prompt to ensure the model picks the tool when you want it to.
  Can't find the tool you need and want us to host it? Check out our
  [vision-agent-tools](https://github.com/landing-ai/vision-agent-tools) repository where
  we add the source code for all the tools used in `VisionAgent`.

  All of our agents are based off of LMMs or Large Multimodal Models. We provide a thin
  abstraction layer on top of the underlying provider APIs to be able to more easily
  handle media.
  ```python
  from vision_agent.lmm import AnthropicLMM
  lmm = AnthropicLMM()
  response = lmm("Describe this image", media=["apple.jpg"])
  >>> "This is an image of an apple."
  ```
  Or you can use the `OpenAI` chat interaface and pass it other media like videos:
  ```python
  response = lmm(
      [
          {
              "role": "user",
              "content": "What's going on in this video?",
              "media": ["video.mp4"]
          }
      ]
  )
  ```

  Underneath the hood, `VisionAgent` uses `VisionAgentCoder` to generate code to solve
  vision tasks. You can use `VisionAgentCoder` directly to generate code if you want:
  ```python
  >>> from vision_agent.agent import VisionAgentCoder
  >>> agent = VisionAgentCoder()
  >>> code = agent("What percentage of the area of the jar is filled with coffee beans?", media="jar.jpg")
  ```
  Which produces the following code:
  ```python
  from vision_agent.tools import load_image, florence2_sam2_image
  def calculate_filled_percentage(image_path: str) -> float:
      
      image = load_image(image_path)
      
      jar_segments = florence2_sam2_image("jar", image)
      
      coffee_beans_segments = florence2_sam2_image("coffee beans", image)
      
      jar_area = 0
      for segment in jar_segments:
          jar_area += segment['mask'].sum()
      
      coffee_beans_area = 0
      for segment in coffee_beans_segments:
          coffee_beans_area += segment['mask'].sum()
      
      if jar_area == 0:
          return 0.0  # To avoid division by zero
      filled_percentage = (coffee_beans_area / jar_area) * 100
      
      return filled_percentage
  ```
  To better understand how the model came up with it's answer, you can run it in debug
  mode by passing in the verbose argument:
  ```python
  >>> agent = VisionAgentCoder(verbosity=2)
  ```

  You can also have it return more information by calling `generate_code`. The format
  of the input is a list of dictionaries with the keys `role`, `content`, and `media`:
  ```python
  >>> results = agent.generate_code([{"role": "user", "content": "What percentage of the area of the jar is filled with coffee beans?", "media": ["jar.jpg"]}])
  >>> print(results)
  {
      "code": "from vision_agent.tools import ..."
      "test": "calculate_filled_percentage('jar.jpg')",
      "test_result": "...",
      "plans": {"plan1": {"thoughts": "..."}, ...},
      "plan_thoughts": "...",
      "working_memory": ...,
  }
  ```
  With this you can examine more detailed information such as the testing code, testing
  results, plan or working memory it used to complete the task.

  You can have multi-turn conversations with vision-agent as well, giving it feedback on
  the code and having it update. You just need to add the code as a response from the
  assistant:
  ```python
  agent = va.agent.VisionAgentCoder(verbosity=2)
  conv = [
      {
          "role": "user",
          "content": "Are these workers wearing safety gear? Output only a True or False value.",
          "media": ["workers.png"],
      }
  ]
  result = agent.generate_code(conv)
  code = result["code"]
  conv.append({"role": "assistant", "content": code})
  conv.append(
      {
          "role": "user",
          "content": "Can you also return the number of workers wearing safety gear?",
      }
  )
  result = agent.generate_code(conv)
  ```


  If you wish to run your code on the E2B backend, make sure you have your `E2B_API_KEY`
  set and then set `CODE_SANDBOX_RUNTIME=e2b` in your environment variables. This will
  run all the agent generated code on the E2B backend.

  `AnthropicVisionAgentCoder` uses Anthropic. To get started you just need to get an
  Anthropic API key and set it in your environment variables:
  ```bash
  export ANTHROPIC_API_KEY="your-api-key"
  ```
  Because Anthropic does not support embedding models, the default embedding model used
  is the OpenAI model so you will also need to set your OpenAI API key:
  ```bash
  export OPEN_AI_API_KEY="your-api-key"
  ```
  Usage is the same as `VisionAgentCoder`:
  ```python
  >>> import vision_agent as va
  >>> agent = va.agent.AnthropicVisionAgentCoder()
  >>> agent("Count the apples in the image", media="apples.jpg")
  ```

  `OpenAIVisionAgentCoder` uses OpenAI. To get started you just need to get an OpenAI API
  key and set it in your environment variables:
  ```bash
  export OPEN_AI_API_KEY="your-api-key"
  ```
  Usage is the same as `VisionAgentCoder`:
  ```python
  >>> import vision_agent as va
  >>> agent = va.agent.OpenAIVisionAgentCoder()
  >>> agent("Count the apples in the image", media="apples.jpg")
  ```

  `OllamaVisionAgentCoder` uses Ollama. To get started you must download a few models:
  ```bash
  ollama pull llama3.1
  ollama pull mxbai-embed-large
  ```
  `llama3.1` is used for the `OllamaLMM` for `OllamaVisionAgentCoder`. Normally we would
  use an actual LMM such as `llava` but `llava` cannot handle the long context lengths
  required by the agent. Since `llama3.1` cannot handle images you may see some
  performance degredation. `mxbai-embed-large` is the embedding model used to look up
  tools. You can use it just like you would use `VisionAgentCoder`:
  ```python
  >>> import vision_agent as va
  >>> agent = va.agent.OllamaVisionAgentCoder()
  >>> agent("Count the apples in the image", media="apples.jpg")
  ```
  > WARNING: VisionAgent doesn't work well unless the underlying LMM is sufficiently powerful. Do not expect good results or even working code with smaller models like Llama 3.1 8B.

  `AzureVisionAgentCoder` uses Azure OpenAI models. To get started follow the Azure Setup
  section below. You can use it just like you would use `VisionAgentCoder`:
  ```python
  >>> import vision_agent as va
  >>> agent = va.agent.AzureVisionAgentCoder()
  >>> agent("Count the apples in the image", media="apples.jpg")
  ```

  If you want to use Azure OpenAI models, you need to have two OpenAI model deployments:
  1. OpenAI GPT-4o model
  2. OpenAI text embedding model
  <img width="1201" alt="Screenshot 2024-06-12 at 5 54 48 PM" src="https://github.com/landing-ai/vision-agent/assets/2736300/da125592-b01d-45bc-bc99-d48c9dcdfa32">
  Then you can set the following environment variables:
  ```bash
  export AZURE_OPENAI_API_KEY="your-api-key"
  export AZURE_OPENAI_ENDPOINT="your-endpoint"

  export AZURE_OPENAI_CHAT_MODEL_DEPLOYMENT_NAME="your_gpt4o_model_deployment_name"

  export AZURE_OPENAI_EMBEDDING_MODEL_DEPLOYMENT_NAME="your_embedding_model_deployment_name"
  ```
  > NOTE: make sure your Azure model deployment have enough quota (token per minute) to support it. The default value 8000TPM is not enough.
  You can then run VisionAgent using the Azure OpenAI models:
  ```python
  import vision_agent as va
  agent = va.agent.AzureVisionAgentCoder()
  ```
  ******************************************************************************************************************************


  1. Visit the [OpenAI API platform](https://beta.openai.com/signup/) to sign up for an API key.
  2. Follow the instructions to purchase and manage your API credits.
  3. Ensure your API key is correctly configured in your project settings.
  Failure to have sufficient API credits may result in limited or no functionality for
  the features that rely on the OpenAI API. For more details on managing your API usage
  and credits, please refer to the OpenAI API documentation.
  ******************************************************************************************************************************


  If you keep seeing a `ModuleNotFoundError` when VisionAgent generating code and seeing VisionAgent got stuck and could not install the missing dependencies, you can manually add the missing dependencies into your Python environment by: `pip install <missing_package_name>`. And then try generating code again.


pkgId: 9bbb84bc660f9d203ac4b8f5ba8402ea54bce5017d6b9fffc10a01f2ea426b20
name: python-vision-agent-help
arch: noarch
version: 0.2.220
epoch: 0
release: 1
summary: Development documents and examples for vision-agent
url: https://landing.ai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vision-agent-0.2.220-1.src.rpm
location_href: Packages/python-vision-agent-help-0.2.220-1.noarch.rpm
checksum_type: sha256
description:
  **NOTE**
  You must have the Anthropic API key set in your environment variables to use
  VisionAgent. If you don't have an Anthropic key you can use another provider like


pkgId: f779a7580c399d99cb5f03342886a5c700dfd3f0acc3955b564191ea87010656
name: python-vision-parse-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for vision-parse
url: https://github.com/iamarunbrahma/vision-parse
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vision-parse-0.1.0-1.src.rpm
location_href: Packages/python-vision-parse-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
  [![Author: Arun Brahma](https://img.shields.io/badge/Author-Arun%20Brahma-purple)](https://github.com/iamarunbrahma)
  [![PyPI - Downloads](https://img.shields.io/pypi/dm/vision-parse)](https://pypi.org/project/vision-parse)

  > 🚀 Transform PDF documents into beautifully formatted markdown using state-of-the-art Vision Language Models - all with just a few lines of code!



  Vision Parse harnesses the power of Vision Language Models to revolutionize document processing:

  - 📝 **Smart Content Extraction**: Intelligently identifies and extracts text, tables, and images with high precision
  - ✨ **Markdown Magic**: Converts complex document layouts into clean, well-structured markdown
  - 🎨 **Format Preservation**: Maintains document hierarchy, styling, and visual elements
  - 🤖 **AI-Powered Analysis**: Leverages cutting-edge vision models for superior accuracy
  - 🔄 **Batch Processing**: Handle multi-page documents effortlessly






  - 🐍 Python >= 3.8
  - 🖥️ Ollama (for local model hosting)



  Install the package using pip:

  ```bash
  pip install vision-parse
  ```



  1. **Install Ollama** based on your operating system:

     **Linux:**
     ```bash
     curl -fsSL https://ollama.com/install.sh | sh
     ```

     **MacOS:**
     ```bash
     brew install ollama
     ```

     **Windows:**
     Download and install from [Ollama Website](https://ollama.com/download/OllamaSetup.exe)

  2. **Pull and start** the Ollama server:
     ```bash
     ollama pull llama3.2-vision:11b
     ollama serve
     ```

  3. **Verify** server status:
     ```bash
     curl http://localhost:11434/api/version
     ```






  ```python
  from vision_parse import VisionParser


  parser = VisionParser(
      model_name="llama3.2-vision:11b",
      temperature=0.7,
      top_p=0.7
  )


  pdf_path = "path/to/your/document.pdf"
  markdown_pages = parser.convert_pdf(pdf_path)


  for i, page_content in enumerate(markdown_pages, 1):
      print(f"\n--- Page {i} ---\n{page_content}")
  ```



  ```python
  from vision_parse import VisionParser, PDFPageConfig


  page_config = PDFPageConfig(
      dpi=400,
      color_space="RGB",
      include_annotations=True,
      preserve_transparency=False
  )


  parser = VisionParser(
      model_name="llama3.2-vision:11b",
      temperature=0.7,
      top_p=0.7,
      page_config=page_config
  )


  pdf_path = "path/to/your/document.pdf"
  markdown_pages = parser.convert_pdf(pdf_path)
  ```






  1. **Clone and Setup**:
     ```bash
     
     git clone https://github.com/iamarunbrahma/vision-parse.git
     cd vision-parse
     ```

  2. **Install Dependencies**:
     ```bash
     
     curl -LsSf https://astral.sh/uv/install.sh | sh

     
     powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

     
     uv sync --all-extras && source .venv/bin/activate
     ```

  3. **Quality Checks**:
     ```bash
     
     make test

     
     make lint    # Run code linting
     make format  # Format code
     ```




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


pkgId: 8535127ed765676fbf48b0adfdbdf4e119b55dcdaed5c77a3067a8a6f22a320b
name: python-vision_oslo_extension-help
arch: noarch
version: 3.3.0
epoch: 0
release: 1
summary: Development documents and examples for vision_oslo_extension
url: https://pypi.org/project/vision-oslo-extension/
rpm_license: Open Source Non-Commercial License (OSNCL) v1.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vision_oslo_extension-3.3.0-1.src.rpm
location_href: Packages/python-vision_oslo_extension-help-3.3.0-1.noarch.rpm
checksum_type: sha256
description:
  This is VISION-OSLO extension package in order to support the simulation data post processing.

  Please refer to the document manual for instructions.



  Copyright (c) 2024 [Jieming Ye, Engineering Services, Network Rail]

  This package is developed by Jieming Ye. Senior Design Engineer, Engineering Services, Network Rail.
  The source code is open to public but restrict for commerical use.

  Network Rail Infrastructure Limited are registered in England and Wales under company number 02904587.


  [![Python application - build and test](https://github.com/NR-JYe/Vision-Oslo-Extension/actions/workflows/py_app_test.yml/badge.svg)](https://github.com/NR-JYe/Vision-Oslo-Extension/actions/workflows/py_app_test.yml)


  The repository of this package is saved on GitHub:
  https://github.com/NR-JYe/Vision-Oslo-Extension


  Pre-installtion of Python and VISION-OSLO required.



  In 3.3.0: New feature on CIF filter removing platform information. New CIF import file analysis
  Multiple bugs fix and feature enhancement.


  Version 3.3.0: Add feature to support CIF import process.

  Version 3.2.0: Add feature to filter low voltage output

  Version 3.1.0: Add feature to remove TIPLOCS from CIF.

  Version 3.0.0: Including license mechanisim. License update.

  Version 2.0.0: Major UI update + Add Falling Voltage Protection assessment

  Version 1.3.0: Add Battery EMU Modelling Assessment

  Version 1.2.0: Add Single End Feeding assessment in DC.

  Version 1.1.0: Add SFC Assessment.

  Version 1.0.0 (Stable version): First official version to all stakeholders

  Version 0.1.1 (Beta version): First version published for user testing.


  Engineering Services, part of Route Services, Network Rail


  Copyright (c) 2024 [Jieming Ye]
  This Python source code is licensed under the
  Open Source Non-Commercial License (OSNCL) v1.0
  See LICENSE for details.


pkgId: cb9f9d94ac0e116aa97ea6db08256b86b18904def862bf944e1fe1963a9321f8
name: python-visiontext-help
arch: noarch
version: 0.22.1
epoch: 0
release: 1
summary: Development documents and examples for visiontext
url: https://pypi.org/project/visiontext/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-visiontext-0.22.1-1.src.rpm
location_href: Packages/python-visiontext-help-0.22.1-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
  <a href="https://github.com/simon-ging/visiontext/actions/workflows/build-py38-cpu.yml">
    <img alt="minimal build 3.8 status" title="build 3.8 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/visiontext/build-py38-cpu.yml?branch=main&label=minimal%20build%203.8%20cpu" />
  </a>
  <a href="https://github.com/simon-ging/visiontext/actions/workflows/build-py310-cpu.yml">
    <img alt="minimal build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/visiontext/build-py310-cpu.yml?branch=main&label=minimal%20build%203.10%20cpu" />
  </a>
  <a href="https://github.com/simon-ging/visiontext/actions/workflows/build-py312-cpu.yml">
    <img alt="minimal build 3.12 status" title="build 3.12 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/visiontext/build-py312-cpu.yml?branch=main&label=minimal%20build%203.12%20cpu" />
  </a>
  <br />
  <a href="https://github.com/simon-ging/visiontext/actions/workflows/build-py38-cpu.yml">
    <img alt="full build 3.8 status" title="build 3.8 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/visiontext/build-py38-cpu-full.yml?branch=main&label=full%20build%203.8%20cpu" />
  </a>
  <a href="https://github.com/simon-ging/visiontext/actions/workflows/build-py310-cpu.yml">
    <img alt="full build 3.10 status" title="build 3.10 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/visiontext/build-py310-cpu-full.yml?branch=main&label=full%20build%203.10%20cpu" />
  </a>
  <a href="https://github.com/simon-ging/visiontext/actions/workflows/build-py312-cpu.yml">
    <img alt="full build 3.12 status" title="build 3.12 status" src="https://img.shields.io/github/actions/workflow/status/simon-ging/visiontext/build-py312-cpu-full.yml?branch=main&label=full%20build%203.12%20cpu" />
  </a>
  <br />
  <img alt="coverage" title="coverage" src="https://raw.githubusercontent.com/simon-ging/visiontext/main/docs/coverage.svg" />
  <a href="https://pypi.org/project/visiontext/">
    <img alt="version" title="version" src="https://img.shields.io/pypi/v/visiontext?color=success" />
  </a>
  </p>

  Utilities for deep learning on multimodal data.

  * jupyter notebooks / jupyter lab / ipython
  * matplotlib
  * pandas
  * webdataset / tar
  * pytorch



  Requires `python>=3.8`, requires `pytorch` to be installed already,
  see [https://pytorch.org/](https://pytorch.org/)

  ```bash
  pip install visiontext
  ```



  Additionally requires `libjpeg-turbo` and `sqlite`

  ```bash
  pip install visiontext[full]
  ```



  Clone repository and cd into, then:

  ```bash
  pip install pytest pytest-cov pylint black[jupyter]
  pylint visiontext
  pylint tests


  pip install -e .[full]
  python -m pytest --cov


  pip install -e .
  python -m pytest --cov -m "not full"

  ```



  - 0.10.1: Test with python 3.12
  - 0.8.1: Set minimum python version to 3.8 since PyTorch requires it


pkgId: da187f05fd6f8f0bbadcdbb27bf397434e003bcbd704b2d4618ce85944adad15
name: python-visivo-help
arch: noarch
version: 1.0.48
epoch: 0
release: 1
summary: Development documents and examples for visivo
url: https://pypi.org/project/visivo/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-visivo-1.0.48-1.src.rpm
location_href: Packages/python-visivo-help-1.0.48-1.noarch.rpm
checksum_type: sha256
description:
  Please refer to https://docs.visivo.io for detailed instructions on how to use this package.



  ```
  pip install visivo
  ```

  If you want to install a preview version you can install from a beta tag:

  ```
  python -m pip install git+https://github.com/visivo-io/visivo.git@v1.1.0-beta-1 --force-reinstall
  ```





  The local development environment is a basic Create React App setup.  You can test any changes by:

  1. Install Visivo from above.
  1. Start `visivo serve` on a project.  You can do this in on `test-projects` in this repo. This acts as the server for your changes.
  1. In another terminal start the react app.
      1. `cd viewer`
      1. `yarn start`
      1. Navigate to localhost:3000 this will proxy any data requests to the running `visivo serve` command



  A release is created by running the action `Create Release`.  This will create a tag and trigger the deployment of the viewer. The input is without the `v` prefix. Example: `1.3.4`.


pkgId: 2e8adad76bca3ab46c8d06222af8e466fc7ad66f3d306bcffe1d5cd6f63e490d
name: python-visor-py-help
arch: noarch
version: 2024.12.3
epoch: 0
release: 1
summary: Development documents and examples for visor-py
url: https://pypi.org/project/visor-py/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-visor-py-2024.12.3-1.src.rpm
location_href: Packages/python-visor-py-help-2024.12.3-1.noarch.rpm
checksum_type: sha256
description:
  A Python Library for VISoR Image.



  ```sh
  pip install visor-py
  ```


  ```py
  import visor.image as vimg
  ```


  - Read .vsr
  ```py
  import visor.image as vimg



  img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
  print(img.info)
  ```

  - Read raw image
  ```py
  import visor.image as vimg
  img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')



  arr = img.read(img_type='raw',
                 zarr_file='slice_1_10x.zarr',
                 resolution=0)
  print(arr.info)
  ```

  - Read arrays by named stacks or channels
  ```py
  import visor.image as vimg
  img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
  arr = img.read(img_type='raw',
                 zarr_file='slice_1_10x.zarr',
                 resolution=0)



  s1_array = arr.read(stack='stack_1')
  print(f's1_array shape: {s1_array.shape}, dimensions: c,z,y,x')



  c488_array = arr.read(channel='488')
  print(f'c488_array shape: {c488_array.shape}, dimensions: s,z,y,x')



  s1c488_array = arr.read(stack='stack_1', channel='488')
  print(f's1c488_array shape: {s1c488_array.shape}, dimensions: z,y,x')
  ```

  - Read array by index
  ```py
  import visor.image as vimg
  img = vimg.open_vsr('path/to/VISOR001.vsr', 'r')
  arr = img.read(img_type='raw',
                 zarr_file='slice_1_10x.zarr',
                 resolution=0)



  the_array = arr.array
  print(f'the_array shape: {the_array.shape}, dimensions: s,c,z,y,x')

  subarr = the_array[0,0,:,:,:]
  print(f'subarr shape: {subarr.shape}, dimensions: z,y,x')
  ```

  - Write .vsr
  ```py
  import visor.image as vimg
  import numpy as np
  import dask.array as da



  img = vimg.open_vsr('path/to/VISOR001.vsr', 'w')



  new_arr = da.random.random(size=(2, 2, 4, 4, 4), chunks=(1, 1, 2, 2, 2))



  img_info = {}    # info.json
  arr_info = {}    # .zattrs
  selected = {}    # selected.json


  img.write(arr=new_arr,
            img_type='raw',
            file='slice_1_10x',
            resolution=0,
            img_info=img_info,
            arr_info=arr_info,
            selected=selected)
  ```


  [VISoR Image Schema](https://visor-tech.github.io/visor-data-schema)


pkgId: 48cef2338f1c1403d0e271f2092b54094fd7fa92fbc8079afd7536e5dbce5f56
name: python-vital-help
arch: noarch
version: 2.1.148
epoch: 0
release: 1
summary: Development documents and examples for vital
url: https://pypi.org/project/vital/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vital-2.1.148-1.src.rpm
location_href: Packages/python-vital-help-2.1.148-1.noarch.rpm
checksum_type: sha256
description:
  [![pypi](https://img.shields.io/pypi/v/vital.svg)](https://pypi.python.org/pypi/vital)
  [![fern shield](https://img.shields.io/badge/%F0%9F%8C%BF-SDK%20generated%20by%20Fern-brightgreen)](https://github.com/fern-api/fern)

  The Vital Python library provides access to the Vital API from applications written in Python.



  API reference documentation is available [here](https://docs.tryvital.io/home/welcome).



  Add this dependency to your project's build file:

  ```bash
  pip install vital

  poetry add vital
  ```



  ```python
  from vital.client import Vital

  vital_client = Vital(
    api_key="YOUR_API_KEY",
  )

  lab_test = vital_client.lab_tests.get('order-id')

  print(lab_test)
  ```



  The SDK also exports an async client.

  ```python
  from vital.client import AsyncVital

  import asyncio

  vital_client = AsyncVital(
    api_key="YOUR_API_KEY",
  )

  async def get_lab_test() -> None:
      lab_test = vital_client.lab_tests.get('order-id')
      print(lab_test)

  asyncio.run(get_lab_test())
  ```



  All exceptions thrown by the SDK will sublcass [ApiError](./src/vital/core/api_error.py).

  ```python
  from vital.core import ApiError
  from vital import BadRequestError

  try:
    vital_client.lab_tests.get('order-id')
  except BadRequestError as e:
    
  except APIError as e:
    
  ```



  When you sign up to Vital you get access to two environments, Sandbox and Production.

  | Environment URLs |                            |
  | ---------------- | -------------------------- |
  | `production`     | api.tryvital.io            |
  | `production-eu`  | api.eu.tryvital.io         |
  | `sandbox`        | api.sandbox.tryvital.io    |
  | `sandbox-eu`     | api.sandbox.eu.tryvital.io |

  By default, the SDK uses the `production` environment. See the snippet below
  for an example on how ot change the environment.

  ```python
  from vital.client import Vital
  from vital.environment import VitalEnvironment

  vital_client = Vital(
    api_key="YOUR_API_KEY",
    environment=VitalEnvironment.Sandbox
  )
  ```



  By default, the client is configured to have a timeout of 60 seconds.
  You can customize this value at client instantiation.

  ```python
  from vital.client import Vital
  from vital.environment import VitalEnvironment

  vital_client = Vital(
    api_key="YOUR_API_KEY",
    environment=VitalEnvironment.Sandbox,
    timeout=15
  )
  ```



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



  While we value open-source contributions to this SDK, this library is generated programmatically. Additions made directly to this library would have to be moved over to our generation code, otherwise they would be overwritten upon the next generated release. Feel free to open a PR as a proof of concept, but know that we will not be able to merge it as-is. We suggest opening an issue first to discuss with us!

  On the other hand, contributions to the README are always very welcome!


pkgId: 7d2aeaa3a14509b21f5a41df3b4aad842ddb22dc66a9b3563739a71580004890
name: python-vivarium-cluster-tools-help
arch: noarch
version: 2.1.1
epoch: 0
release: 1
summary: Development documents and examples for vivarium-cluster-tools
url: https://github.com/ihmeuw/vivarium_cluster_tools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vivarium-cluster-tools-2.1.1-1.src.rpm
location_href: Packages/python-vivarium-cluster-tools-help-2.1.1-1.noarch.rpm
checksum_type: sha256
description:
  Vivarium cluster tools is a python package that makes running ``vivarium``
  simulations at scale on a Slurm cluster easy.


pkgId: aa4951f1af1fdb354c0f04145f5592b1a78bcc120d35b789c3ba698b77a7e2ec
name: python-vivarium-public-health-help
arch: noarch
version: 3.1.4
epoch: 0
release: 1
summary: Development documents and examples for vivarium-public-health
url: https://github.com/ihmeuw/vivarium_public_health
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vivarium-public-health-3.1.4-1.src.rpm
location_href: Packages/python-vivarium-public-health-help-3.1.4-1.noarch.rpm
checksum_type: sha256
description:
  This library contains several components for for modelling diseases and their interventions.
  You can install ``vivarium_public_health`` from PyPI with pip:
    ``> pip install vivarium_public_health``
  or build it from source with
    ``> git clone https://github.com/ihmeuw/vivarium_public_health.git``
    ``> cd vivarium_public_health``
    ``> python setup.py install``


pkgId: 472d7a877ac23037f4e47799d9e4b07d8b3455a6e4bf36fc0ea0b374a3c2b08d
name: python-vizblend-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for vizblend
url: https://github.com/MahmoudHousam/VizBlend
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vizblend-1.0.0-1.src.rpm
location_href: Packages/python-vizblend-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  VizBlend is a Python package that simplifies the process of creating interactive analytical reports by consolidating Plotly figures into a single HTML file. It’s designed to function like a modern PowerPoint presentation but with the power of stunning and interactive data visualizations.

  Whether you’re a data analyst, scientist, or developer, VizBlend streamlines the visualization workflow and enhances collaboration.


  Below is a preview of a report generated with VizBlend:

  ![VizBlend Thumbnail](demo/demo.gif)



  Install vizBlend using pip:
  ```
  pip install vizBlend
  ```



  Besides its main job, this repo intends to teach aspiring data analysts or even data scientists who cannot have full control over their coding cycle. With a simple mission: create visualizations and append them in one interactive report, you can take your learning curve up to include useful skills:
  * Write unit and integration tests with edge cases to ensure your code is not error-prone.

  * Write CI/CD workflows to run on every push or pull request to ensure the newly committed code is compatible enough.

  * Creating, managing and deploying your packaged code to PyPi so that you can simply run `pip install <package_name>` and start using it.


      

      These are the resources that helped this work appear
      * [GitHub Actions for Python Packages: How to Automate Releases to PyPi](https://www.youtube.com/watch?v=NMQwzI9hprg&ab_channel=ArjanCodes)

      * [Automated Python Unit Testing Made Easy with Pytest and GitHub Actions](https://pytest-with-eric.com/integrations/pytest-github-actions/)

      * [Building and testing Python | Official GitHub Actions Docs](https://docs.github.com/en/actions/use-cases-and-examples/building-and-testing/building-and-testing-python)


pkgId: 33099adb827024341ba1437aa6474be11e48a7c5da2f9b58880cceabff539261
name: python-vizro-help
arch: noarch
version: 0.1.30
epoch: 0
release: 1
summary: Development documents and examples for vizro
url: https://pypi.org/project/vizro/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vizro-0.1.30-1.src.rpm
location_href: Packages/python-vizro-help-0.1.30-1.noarch.rpm
checksum_type: sha256
description:
  <br><br>

  <div align="center">

  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/Vizro_Github_Banner_Dark_Mode.png">
    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/Vizro_Github_Banner_Light_Mode.png">
    <img alt="Vizro logo" src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/Vizro_Github_Banner_Dark_Mode.png" width="250">
  </picture>



  [![Python version](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue.svg)](https://pypi.org/project/vizro/) [![PyPI version](https://badge.fury.io/py/vizro.svg)](https://badge.fury.io/py/vizro) [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/mckinsey/vizro/blob/main/LICENSE.md) [![Documentation](https://readthedocs.org/projects/vizro/badge/?version=stable)](https://vizro.readthedocs.io/) [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/7858/badge)](https://www.bestpractices.dev/projects/7858)

  [Documentation](https://vizro.readthedocs.io/en/stable/) | [Get Started](https://vizro.readthedocs.io/en/stable/pages/tutorials/first_dashboard/) | [Vizro examples gallery](http://vizro.mckinsey.com/)

  <img src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/vizro_spash_teaser.gif" width="600"/>
  <br>
  <br>
  <img src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/logo_watermarks.svg" width="300">
  </div>



  Vizro is an open-source Python-based toolkit.

  Use it to build beautiful and powerful data visualization apps quickly and easily, without needing advanced engineering or visual design expertise.

  Then customize and deploy your app to production at scale.

  <div align="center">
  <img src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/code_dashboard.png" width="100%"/>
  Use a few lines of simple low-code configuration, with in-built visual design best practices, to assemble high-quality
  multi-page prototypes.
  </div>
  <br>

  The benefits of the Vizro toolkit include:

  <div align="center">
  <img src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/infographic.svg" width="800"/>
  </div>
  <br>

  Visit our ["How-to guides"](https://vizro.readthedocs.io/en/stable/pages/user-guides/install/) for a more detailed explanation of Vizro features.



  Vizro helps you to build data visualization apps that are:

  **Quick and easy**

  Build apps in minutes. Use a few lines of simple configuration (via Pydantic models, JSON, YAML, or Python dictionaries) in place of thousands of lines of code.

  **Beautiful and powerful**

  Build high-quality multi-page apps without needing advanced engineering or visual design expertise. Use powerful features of production-grade BI tools, with in-built visual design best practices.

  **Flexible**

  Benefit from the capabilities and flexibility of open-source packages. Use the trusted dependencies of Plotly, Dash, and Pydantic.

  **Customizable**

  Almost infinite control for advanced users. Use Python, JavaScript, HTML and CSS code extensions.

  **Scalable**

  Rapidly prototype and deploy to production. Use the in-built production-grade capabilities of Plotly, Dash and Pydantic.

  Visit ["Why should I use Vizro?"](https://vizro.readthedocs.io/en/stable/pages/explanation/faq/#why-should-i-use-vizro) for a more detailed explanation of Vizro use cases.



  Use Vizro when you need to combine the speed and ease of low-code Python tools, with production capabilities of JavaScript and BI tools, and the freedom of open source:

  - Have an app that looks beautiful and professional by default.
  - Enjoy the simplicity of low-code, plus the option to customize with code almost infinitely.
  - Rapidly create prototypes which are production-ready and easy to deploy at scale.





  **Low-code framework for building dashboards.**

  The Vizro framework underpins the entire Vizro toolkit. It is a Python package (called `vizro`).

  Visit the [documentation](https://vizro.readthedocs.io/en/stable/) for more details.



  **Chart examples.**

  The visual vocabulary helps you to decide which chart type to use for your requirements, and offers sample code to create these charts with Plotly or embed them into a Vizro dashboard.

  Visit the [visual vocabulary](https://vizro-demo-visual-vocabulary.hf.space/) to search for charts or get inspiration.

  <a href="https://vizro-demo-visual-vocabulary.hf.space/">
  <img src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/toolkit_visual_vocabulary.png" width="600">
  </a>



  **Dashboard examples.**

  The dashboard examples gallery enables you to explore Vizro in action by viewing interactive example apps. You can copy the code to use as a template or starter for your next dashboard.

  Visit the [dashboard examples gallery](https://vizro.mckinsey.com/) to see the dashboards in action.

  <a href="https://vizro.mckinsey.com/">
  <img src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/toolkit_dashboard_examples.png" width="600">
  </a>



  **Use LLMs to generate charts and dashboards.**

  Vizro-AI is a separate package (called `vizro_ai`) that extends Vizro to incorporate LLMs. Use it to build interactive Vizro charts and dashboards, by simply describing what you need in plain English or other languages.

  Visit the [Vizro-AI documentation](https://vizro.readthedocs.io/projects/vizro-ai/) for more details.

  <img width="600" src="https://raw.githubusercontent.com/mckinsey/vizro/main/.github/images/toolkit_vizro_ai.gif">



  ```console
  pip install vizro
  ```

  See the [installation guide](https://vizro.readthedocs.io/en/stable/pages/user-guides/install/) for more information.

  The [get started documentation](https://vizro.readthedocs.io/en/stable/pages/tutorials/first-dashboard/) explains how to create your first dashboard.



  This repository is a monorepo containing the following packages:

  |           Folder           |                                           Version                                           |                          Documentation                           |
  | :------------------------: | :-----------------------------------------------------------------------------------------: | :--------------------------------------------------------------: |
  | [vizro-core](./vizro-core) |    [![PyPI version](https://badge.fury.io/py/vizro.svg)](https://badge.fury.io/py/vizro)    |      [Vizro Docs](https://vizro.readthedocs.io/en/stable/)       |
  |   [vizro-ai](./vizro-ai)   | [![PyPI version](https://badge.fury.io/py/vizro-ai.svg)](https://badge.fury.io/py/vizro-ai) | [Vizro-AI Docs](https://vizro.readthedocs.io/projects/vizro-ai/) |



  We encourage you to ask and discuss any technical questions via the [GitHub Issues](https://github.com/mckinsey/vizro/issues). This is also the place where you can submit bug reports or request new features.



  The [contributing guide](https://vizro.readthedocs.io/en/stable/pages/explanation/contributing/) explains how you can contribute to Vizro.

  You can also view current and former contributors [here](https://vizro.readthedocs.io/en/stable/pages/explanation/authors/).



  See our [security policy](https://github.com/mckinsey/vizro/security/policy).



  `vizro` is distributed under the terms of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).


pkgId: f16221d0bca9df39452277ed477d52b71afd14850f87618e5b5857b66a152ce0
name: python-vlcishared-help
arch: noarch
version: 2.0.0
epoch: 0
release: 1
summary: Development documents and examples for vlcishared
url: https://pypi.org/project/vlcishared/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vlcishared-2.0.0-1.src.rpm
location_href: Packages/python-vlcishared-help-2.0.0-1.noarch.rpm
checksum_type: sha256
description:
  To make it easy for you to get started with GitLab, here's a list of recommended next steps.

  Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!



  - [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
  - [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:

  ```
  cd existing_repo
  git remote add origin https://gitlab.com/vlci/vlci-integracion/src/python/etls/vlcishared.git
  git branch -M main
  git push -uf origin main
  ```



  - [ ] [Set up project integrations](https://gitlab.com/vlci/vlci-integracion/src/python/etls/vlcishared/-/settings/integrations)



  - [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
  - [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
  - [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
  - [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
  - [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)



  Use the built-in continuous integration in GitLab.

  - [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
  - [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
  - [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
  - [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
  - [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)

  ***



  When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.



  Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.


  Choose a self-explaining name for your project.


  Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.


  On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.


  Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.


  Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.


  Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.


  Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.


  If you have ideas for releases in the future, it is a good idea to list them in the README.


  State if you are open to contributions and what your requirements are for accepting them.

  For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.

  You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.


  Show your appreciation to those who have contributed to the project.


  For open source projects, say how it is licensed.


  If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.


pkgId: cba63820a166b3ebd8fc1cf21efd9083d843b44289cd8e50455ac19ac2c81548
name: python-vlkcli-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for vlkcli
url: https://pypi.org/project/vlkcli/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vlkcli-0.1.0-1.src.rpm
location_href: Packages/python-vlkcli-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  - **Authentication**: Login with username and password to obtain a session token.
  - **Tools Management**: View all tools, fetch tool details, and execute specific tool endpoints.
  - **API Key Management**: Create, list, and delete API keys associated with tools.
  - **Wallet Operations**: Retrieve wallet details and transaction history.


pkgId: 334ee91260a6eeb1215842790d2ce1d12a53fd08aea45493a3e67ce8cde4c8ce
name: python-vllmlp-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for vllmlp
url: https://pypi.org/project/vllmlp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vllmlp-0.0.2-1.src.rpm
location_href: Packages/python-vllmlp-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  `vllmlp` is a collection of Logits Processors for VLLM. Currently, it contains the following processors:

  - `vllmlp/qwen/NoCJKLogitsProcessor`: A Logits Processor that prevents CJK characters from being generated in the output. ONLY works with QWen2.5 models.



  ```bash
  pip install vllmlp
  ```


pkgId: 33543bca0995279576feb2f906c68f3fa552a7b91587177a10785b8fe0c67010
name: python-vmware-reporter
arch: noarch
version: 0.4.1
epoch: 0
release: 1
summary: Interact easily with your VMWare clusters.
url: https://github.com/ipamo/vmware-reporter
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vmware-reporter-0.4.1-1.src.rpm
location_href: Packages/python-vmware-reporter-0.4.1-1.noarch.rpm
checksum_type: sha256
description:
  Interact easily with your VMWare clusters.

  VMWare Reporter package is published [on PyPI](https://pypi.org/project/vmware-reporter/):
  ```sh
  pip install vmware-reporter
  ```
  Optionaly, use specifier `[excel]` to also install dependencies for reading and writing Excel files:
  ```sh
  pip install vmware-reporter[excel]
  ```

  Create file `C:\ProgramData\vmware-reporter\.env` (`/etc/vmware-reporter/.env` on Linux).
  Example:
  ```ini
  VMWARE_HOST = myvcenter.example.org
  VMWARE_USER = reporter@vsphere.local
  VMWARE_PASSWORD = ...
  VMWARE_NO_SSL_VERIFY = False
  ```
  Several scopes may be distinguished. Example for two scopes named `SCOPE1` and `SCOPE2`:
  ```ini
  VMWARE_SCOPES = SCOPE1,SCOPE2
  VMWARE_SCOPE1_HOST = myvcenter1.example.org
  VMWARE_SCOPE1_USER = reporter@vsphere.local
  VMWARE_SCOPE1_PASSWORD = ...
  VMWARE_SCOPE2_HOST = myvcenter2.example.org
  VMWARE_SCOPE2_USER = reporter@vsphere.local
  VMWARE_SCOPE2_PASSWORD = ...
  ```

  See also [full documentation](https://ipamo.net/vmware-reporter) (including [API reference](https://ipamo.net/vmware-reporter/latest/api-reference.html)).
  VMWare Reporter may be used as a library in your Python code:
  ```py
  from vmware_reporter import VCenterClient
  with VCenterClient() as vcenter:
      for vm in vcenter.iterate_objs('vm'):
          print(vm.name)
  ```
  VMWare Reporter may also be invoked as a command-line application (the `vmware-reporter` executable is installed with the package). Examples:
  - Export inventory of VMWare managed objects to a YAML file:
  ```sh
  vmware-reporter inventory
  ```
  - Export all available information about VMWare managed objects to JSON files:
  ```sh
  vmware-reporter export
  ```
  - Reconfigure VMs (mass operation): copy template [vm_reconfigure.xlsx](https://ipamo.net/vmware-reporter/latest/_static/templates/vm_reconfigure.xlsx) to `data/vm_reconfigure.xlsx`, fill-in this file, then:
  ```sh
  vmware-reporter vm reconfigure
  ```
  - If you use several scopes, put files in `data/SCOPE1/` instead of `data/` and specify scope on the command line. Example:
  ```sh
  vmware-reporter -e SCOPE1 vm reconfigure
  ```
  Complete help about command-line usage may be displayed by typing:
  ```sh
  vmware-reporter --help
  ```

  Copy [vmware-reporter.service](https://ipamo.net/vmware-reporter/latest/_static/vmware-reporter.service), [vmware-reporter.timer](https://ipamo.net/vmware-reporter/latest/_static/vmware-reporter.timer) and [notify-email@.service](https://ipamo.net/vmware-reporter/latest/_static/notify-email@.service)
  in `/etc/systemd/system` and adapt them to your configuration.
  Run:
      sudo systemctl daemon-reload
      sudo systemctl enable vmware-reporter.timer
      sudo systemctl start vmware-reporter.timer

  This library leverages [pyvmomi](https://github.com/vmware/pyvmomi), the vSphere API Python bindings provided by VMWare.

  This project is licensed under the terms of the [MIT license](https://raw.githubusercontent.com/ipamo/vmware-reporter/main/LICENSE.txt).
  This project is not affiliated in any way with VMWare or Broadcom.


pkgId: 9420f74242ed772df5809f51e9770af2d3dd06d1be8280d61ba31209ea565086
name: python-vnpy-binance-help
arch: noarch
version: 2024.12.16
epoch: 0
release: 1
summary: Development documents and examples for vnpy-binance
url: https://www.github.com/veighna-global
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vnpy-binance-2024.12.16-1.src.rpm
location_href: Packages/python-vnpy-binance-help-2024.12.16-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src ="https://github.com/veighna-global/vnpy_evo/blob/dev/logo.png" width="300" height="300"/>
  </p>

  <p align="center">
      <img src ="https://img.shields.io/badge/version-2024.9.16-blueviolet.svg"/>
      <img src ="https://img.shields.io/badge/platform-windows|linux|macos-yellow.svg"/>
      <img src ="https://img.shields.io/badge/python-3.10|3.11|3.12-blue.svg"/>
      <img src ="https://img.shields.io/github/license/veighna-global/vnpy_evo.svg?color=orange"/>
  </p>




  This gateway is developed based on Binance's REST and Websocket API, and supports spot, linear contract and inverse contract trading.

  **For derivatives contract trading, please notice:**

  1. Only supports cross margin mode.
  2. Only supports one-way position mode.



  Users can easily install ``vnpy_binance`` by pip according to the following command.

  ```
  pip install vnpy_binance
  ```

  Also, users can install ``vnpy_binance`` using the source code. Clone the repository and install as follows:

  ```
  git clone https://github.com/veighna-global/vnpy_binance.git && cd vnpy_binance

  python setup.py install
  ```



  Save this as run.py.

  ```
  from vnpy_evo.event import EventEngine
  from vnpy_evo.trader.engine import MainEngine
  from vnpy_evo.trader.ui import MainWindow, create_qapp

  from vnpy_binance import (
      BinanceSpotGateway,
      BinanceLinearGateway,
      BinanceInverseGateway
  )


  def main():
      """主入口函数"""
      qapp = create_qapp()

      event_engine = EventEngine()
      main_engine = MainEngine(event_engine)
      main_engine.add_gateway(BinanceSpotGateway)
      main_engine.add_gateway(BinanceLinearGateway)
      main_engine.add_gateway(BinanceInverseGateway)

      main_window = MainWindow(main_engine, event_engine)
      main_window.showMaximized()

      qapp.exec()


  if __name__ == "__main__":
      main()
  ```


pkgId: e5e0744ff05e4a262e93f6f008898d9eaf37264c08653f79e13dedc6eac2c970
name: python-vnpy-evo-help
arch: noarch
version: 0.3.2
epoch: 0
release: 1
summary: Development documents and examples for vnpy-evo
url: https://www.github.com/veighna-global
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vnpy-evo-0.3.2-1.src.rpm
location_href: Packages/python-vnpy-evo-help-0.3.2-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
    <img src ="https://github.com/veighna-global/vnpy_evo/blob/dev/logo.png" width="300" height="300"/>
  </p>

  <p align="center">
      <img src ="https://img.shields.io/badge/version-0.3.2-blueviolet.svg"/>
      <img src ="https://img.shields.io/badge/platform-windows|linux|macos-yellow.svg"/>
      <img src ="https://img.shields.io/badge/python-3.10|3.11|3.12-blue.svg"/>
      <img src ="https://img.shields.io/github/license/veighna-global/vnpy_evo.svg?color=orange"/>
  </p>

  VeighNa Evo (vnpy_evo) is the core module for using [VeighNa (vnpy)](https://github.com/vnpy/vnpy) quant trading platform on the crypto market.



  - <sub>[![Twitter](https://img.shields.io/twitter/follow/veighna.svg?style=social&label=VeighNa%20Global)](https://x.com/veighna_global)</sub>  Follow us on Twitter
  - <sub>[![Telegram Announcements](https://img.shields.io/badge/VeighNa%20Global-Channel-blue?logo=telegram)](https://t.me/veighna_channel)</sub>  Follow our important announcements
  - <sub>[![Telegram Chat](https://img.shields.io/badge/VeighNa%20Global-Chat-blue?logo=telegram)](https://t.me/+8KGF_z35nK03YWE1)</sub>  If you need technical support




  1. Full-featured quantitative trading platform (vnpy_evo.trader)

  2. Gateways which connect to exchanges for receiving market data and sending trading orders:

      * Crypto Market

          * Binance ([binance](https://www.github.com/veighna-global/vnpy_binance)): Spot/Perpetual/Futures/Option

          * OKX ([okx](https://www.github.com/veighna-global/vnpy_okx)): Spot/Perpetual/Futures/Option

          * Bybit ([bybit](https://www.github.com/veighna-global/vnpy_bybit)): Spot/Perpetual/Futures/Option

          * BTSE ([btse](https://www.github.com/veighna-global/vnpy_btse)): Spot/Perpetual/Futures

      * Forex Market

          * MT5 ([mt5](https://www.github.com/veighna-global/vnpy_mt5)): Forex/Gold/Commodity/Crypto

  3. Applications for various quantitative strategies:

      * Nova Strategy ([nova_strategy](https://www.github.com/veighna-global/vnpy_novastrategy)): The quant strategy app module which is designed specifically for crypto markets, supports trend following, pair trading, multi-factor and many other types of quant strategies.

  4. Event processing engine (vnpy_evo.event), which is the core of event-driven trading program

  5. Database adaptors which support most commonly used databases:

      * DuckDB ([duckdb](https://www.github.com/veighna-global/vnpy_duckdb)): The high-performance in-process analytical database which is designed to be fast, reliable, portable, and easy to use.

  6. Standarad RPC solution (vnpy_evo.rpc) for implementing complex trading systems with distributed deployments

  7. High-performance charting widget (vnpy_evo.chart), which supports stream market data update



  **MacOS**

  Please ensure you have installed [XCode](https://developer.apple.com/xcode/) and [Homebrew](https://brew.sh/) before running the following command:

  ```
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/veighna-global/vnpy_evo/HEAD/install_macos.sh)"
  ```

  **Ubuntu**

  ```
  sudo /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/veighna-global/vnpy_evo/HEAD/install_linux.sh)"
  ```



  You can start running VeighNa Evo with only a few lines of code.

  ```Python
  from vnpy_evo.event import EventEngine
  from vnpy_evo.trader.engine import MainEngine
  from vnpy_evo.trader.ui import MainWindow, create_qapp

  from vnpy_binance import BinanceLinearGateway
  from vnpy_novastrategy import NovaStrategyApp

  def main():
      qapp = create_qapp()

      event_engine = EventEngine()
      main_engine = MainEngine(event_engine)

      main_engine.add_gateway(BinanceUsdtGateway)
      main_engine.add_app(CtaStrategyApp)
      main_engine.add_app(NovaStrategyApp)

      main_window = MainWindow(main_engine, event_engine)
      main_window.showMaximized()

      qapp.exec()

  if __name__ == "__main__":
      main()
  ```

  Open a terminal within the directory and run the following command to start VeighNa Trader.

      python run.py



  MIT


pkgId: 4b0f159e651b2b93c1f2b60c4824ac7aaf7e52729a43e87c29c339c6398de946
name: python-vobject-help
arch: noarch
version: 0.9.9
epoch: 0
release: 1
summary: Development documents and examples for vobject
url: https://pypi.org/project/vobject/
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vobject-0.9.9-1.src.rpm
location_href: Packages/python-vobject-help-0.9.9-1.noarch.rpm
checksum_type: sha256
description:
  Parses iCalendar and vCard files into Python data structures, decoding the
  relevant encodings. Also serializes vobject data structures to iCalendar, vCard,
  or (experimentally) hCalendar unicode strings.


pkgId: a51c7db39f143c91c912b6ede822feb1eddd31bcf7ca32b9fae1d905b8111a0a
name: python-vollseg-help
arch: noarch
version: 32.3.3
epoch: 0
release: 1
summary: Development documents and examples for vollseg
url: https://github.com/Kapoorlabs-CAPED/vollseg
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vollseg-32.3.3-1.src.rpm
location_href: Packages/python-vollseg-help-32.3.3-1.noarch.rpm
checksum_type: sha256
description:
  <img src="images/mtrack.png" alt="Logo1" width="150"/>
  <img src="images/kapoorlablogo.png" alt="Logo2" width="150"/>

  This product is a testament to our expertise at KapoorLabs, where we specialize in creating cutting-edge solutions. We offer bespoke pipeline development services, transforming your developmental biology questions into publishable figures with our advanced computer vision and AI tools. Leverage our expertise and resources to achieve end-to-end solutions that make your research stand out.

  **Note:** The tools and pipelines showcased here represent only a fraction of what we can achieve. For tailored and comprehensive solutions beyond what was done in the referenced publication, engage with us directly. Our team is ready to provide the expertise and custom development you need to take your research to the next level. Visit us at [KapoorLabs](https://www.kapoorlabs.org/).


  VollSeg is more than just a single segmentation algorithm; it is a meticulously designed modular segmentation tool tailored to diverse model organisms and imaging methods. While a U-Net might suffice for certain image samples, others might benefit from utilizing StarDist, and some could require a blend of both, potentially coupled with denoising or region of interest models. The pivotal decision left to make is how to select the most appropriate VollSeg configuration for your dataset, a question we comprehensively address in our [documentation website](https://kapoorlabs-caped.github.io/vollseg-napari/).



  [![PyPI version](https://img.shields.io/pypi/v/vollseg.svg?maxAge=2591000)](https://pypi.org/project/vollseg/)
  [![License](https://img.shields.io/pypi/l/napari-metroid.svg?color=green)](https://github.com/kapoorlab/napari-vollseg/raw/main/LICENSE)
  [![Twitter Badge](https://badgen.net/badge/icon/twitter?icon=twitter&label)](https://twitter.com/entracod)
  ![Segmentation](https://github.com/kapoorlab/VollSeg/blob/main/images/Seg_compare-big.png)




  This package can be installed by

  `pip install  vollseg`

  If you are building this from the source, clone the repository and install via

  ```bash
  git clone https://github.com/kapoorlab/vollseg/

  cd vollseg

  pip install -e .


  ```

  ![Algorithm](https://github.com/kapoorlab/VollSeg/blob/main/images/Seg_pipe-git.png)
  - **Algorithm**
    - Schematic representation showing the segmentation approach used in VollSeg.
    - First, we input the raw fluorescent image in 3D (A) and preprocess it to remove noise.
    - Next, we obtain the star convex approximation to the cells using Stardist (B) and the U-Net prediction labeled via connected components (C).
    - We then obtain seeds from the centroids of labeled image in B, for each labeled region of C in order to create bounding boxes and centroids.
    - If there is no seed from B in the bounding box region from U-Net, we add the new centroid (in yellow) to the seed pool (D).
    - Finally, we do a marker controlled watershed in 3D using skimage implementation on the probability map shown in (E) to obtain the final cell segmentation result shown in (F).
    - All images are displayed in Napari viewer with 3D display view.


  - Python 3.7 and above.




  Under MIT license. See [LICENSE](LICENSE).



  - Varun Kapoor <randomaccessiblekapoor@gmail.com>
  - Claudia Carabaña
  - Mari Tolonen


pkgId: 76525ec384bde5929055cd9b4e4ea88844fd749633861da31bf24e782f98cb1e
name: python-votify-help
arch: noarch
version: 1.4.8
epoch: 0
release: 1
summary: Development documents and examples for votify
url: https://pypi.org/project/votify/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-votify-1.4.8-1.src.rpm
location_href: Packages/python-votify-help-1.4.8-1.noarch.rpm
checksum_type: sha256
description:
  A Python CLI app for downloading songs/podcasts/videos from Spotify.

  **Discord Server:** https://discord.gg/aBjMEZ9tnq


  * Download songs in AAC
  * Download podcast in AAC or Vorbis
  * Download podcast videos
  * Download music videos with a premium account
  * Support for artist links to download all of their albums
  * Download synced lyrics
  * Highly configurable


  * Python 3.8 or higher
  * The cookies file of your Spotify browser session in Netscape format (free or premium)
      * To export your cookies, use one of the following browser extensions while signed in to Spotify:
          * Firefox: https://addons.mozilla.org/addon/export-cookies-txt
          * Chromium based browsers: https://chrome.google.com/webstore/detail/gdocmgbfkjnnpapoeobnolbbkoibbcif
  * FFmpeg
      * Add FFmpeg to your system’s PATH or specify its path using command-line arguments or the config file. Old versions may not work.
  * .wvd file
      * A .wvd file contains the Widevine keys from a device and is required to decrypt music videos and songs in AAC. The easiest method of obtaining one is using KeyDive, which extracts it from an Android device. Detailed instructions can be found here: https://github.com/hyugogirubato/KeyDive. **.wvd files extracted from emulated devices may not work**.

  If you plan on only downloading podcasts in Vorbis quality, you can skip the .wvd file and FFmpeg requirements.


  The following tools are optional but required for specific features. Add them to your system’s PATH or specify their paths using command-line arguments or the config file.
  * [MP4Box](https://gpac.io/downloads/gpac-nightly-builds/)
      * Used when setting `mp4box` as remux mode.
  * [Shaka Packager](https://github.com/shaka-project/shaka-packager/releases/latest)
      * Used when setting `webm` as video format and when downloading music videos.
  * [mp4decrypt](https://www.bento4.com/downloads/)
      * Used when setting `mp4box` or `mp4decrypt` as remux mode.
  * [aria2c](https://github.com/aria2/aria2/releases)
      * Used when setting `aria2c` as download mode.


  1. Install the package `votify` using pip
      ```bash
      pip install votify
      ```
  2. Set up the cookies file
      * You can either move to the current directory from which you will be running Votify as `cookies.txt` or specify its path using the command-line arguments/config file.
  3. Set up the .wvd file
      * You can either move to the current directory from which you will be running Votify as `device.wvd` or specify its path using the command-line arguments/config file.


  ```bash
  votify [OPTIONS] URLS...
  ```


  Votify supports the following types of URLs:
  * Song
  * Album
  * Playlist
  * Podcast episode
  * Podcast series
  * Music video
  * Artist


  * Download a song
      ```bash
      votify "https://open.spotify.com/track/18gqCQzqYb0zvurQPlRkpo"
      ```
  * Download an album
      ```bash
      votify "https://open.spotify.com/album/0r8D5N674HbTXlR3zNxeU1"
      ```
  * Download a podcast episode
      ```bash
      votify "https://open.spotify.com/episode/3kwxWnzGH8T6UY2Nq582zx"
      ```
  * Download a podcast series
      ```bash
      votify "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk"
  * Download a music video
      ```bash
      votify "https://open.spotify.com/track/31k4hgHmrbzorLZMvMWuzq" --enable-videos
      ```
  * List and select a related music video to download from a song
      ```bash
      votify "https://open.spotify.com/track/0a0n6u6j3t6m0p4k0t0k0u0" --enable-videos --download-music-videos
      ```
  * Download a podcast video
      ```bash
      votify "https://open.spotify.com/episode/3kwxWnzGH8T6UY2Nq582zx" --enable-videos --download-podcast-videos
      ```
  * Choose which albums to download from an artist
      ```bash
      votify "https://open.spotify.com/artist/0gxyHStUsqpMadRV0Di1Qt"
      ```


  * Arrow keys - Move selection
  * Space - Toggle selection
  * Ctrl + A - Select all
  * Enter - Confirm selection


  Votify can be configured using the command-line arguments or the config file.

  The config file is created automatically when you run Votify for the first time at `~/.votify/config.json` on Linux and `%USERPROFILE%\.votify\config.json` on Windows.

  Config file values can be overridden using command-line arguments.

  | Command-line argument / Config file key                         | Description                                                        | Default value                                  |
  | --------------------------------------------------------------- | ------------------------------------------------------------------ | ---------------------------------------------- |
  | `--wait-interval`, `-w` / `wait_interval`                       | Wait interval between downloads in seconds.                        | `5`                                            |
  | `--enable-videos` / `enable_videos`                             | Enable video downloads when available.                             | `false`                                        |
  | `--download-music-videos` / `download_music_videos`             | List and select a related music video to download from songs.      | `false`                                        |
  | `--download-podcast-videos` / `download_podcast_videos`         | Attempt to download the video version of podcasts.                 | `false`                                        |
  | `--force-premium`, `-f` / `force_premium`                       | Force to detect the account as premium.                            | `false`                                        |
  | `--read-urls-as-txt`, `-r` / -                                  | Interpret URLs as paths to text files containing URLs.             | `false`                                        |
  | `--config-path` / -                                             | Path to config file.                                               | `<home>/.spotify-web-downloader/config.json`   |
  | `--log-level` / `log_level`                                     | Log level.                                                         | `INFO`                                         |
  | `--no-exceptions` / `no_exceptions`                             | Don't print exceptions.                                            | `false`                                        |
  | `--cookies-path` / `cookies_path`                               | Path to cookies file.                                              | `cookies.txt`                                  |
  | `--output-path`, `-o` / `output_path`                           | Path to output directory.                                          | `Spotify`                                      |
  | `--temp-path` / `temp_path`                                     | Path to temporary directory.                                       | `temp`                                         |
  | `--wvd-path` / `wvd_path`                                       | Path to .wvd file.                                                 | `device.wvd`                                   |
  | `--aria2c-path` / `aria2c_path`                                 | Path to aria2c binary.                                             | `aria2c`                                       |
  | `--ffmpeg-path` / `ffmpeg_path`                                 | Path to ffmpeg binary.                                             | `ffmpeg`                                       |
  | `--mp4box-path` / `mp4box_path`                                 | Path to MP4Box binary.                                             | `mp4box`                                       |
  | `--mp4decrypt-path` / `mp4decrypt_path`                         | Path to mp4decrypt binary.                                         | `mp4decrypt`                                   |
  | `--packager-path` / `packager_path`                             | Path to Shaka Packager binary.                                     | `packager`                                     |
  | `--template-folder-album` / `template_folder_album`             | Template folder for tracks that are part of an album.              | `{album_artist}/{album}`                       |
  | `--template-folder-compilation` / `template_folder_compilation` | Template folder for tracks that are part of a compilation album.   | `Compilations/{album}`                         |
  | `--template-file-single-disc` / `template_file_single_disc`     | Template file for the tracks that are part of a single-disc album. | `{track:02d} {title}`                          |
  | `--template-file-multi-disc` / `template_file_multi_disc`       | Template file for the tracks that are part of a multi-disc album.  | `{disc}-{track:02d} {title}`                   |
  | `--template-folder-episode` / `template_folder_episode`         | Template folder for episodes (podcasts).                           | `Podcasts/{album}`                             |
  | `--template-file-episode` / `template_file_episode`             | Template file for music videos.                                    | `{track:02d} {title}`                          |
  | `--template-folder-music-video` / `template_folder_music_video` | Template folder for music videos                                   | `{artist}/Unknown Album`                       |
  | `--template-file-music-video` / `template_file_music_video`     | Template file for the tracks that are not part of an album.        | `{title}`                                      |
  | `--template-file-playlist` / `template_file_playlist`           | Template file for the M3U8 playlist.                               | `Playlists/{playlist_artist}/{playlist_title}` |
  | `--date-tag-template` / `date_tag_template`                     | Date tag template.                                                 | `%Y-%m-%dT%H:%M:%SZ`                           |
  | `--cover-size` / `cover_size`                                   | Cover size.                                                        | `extra-large`                                  |
  | `--save-cover` / `save_cover`                                   | Save cover as a separate file.                                     | `false`                                        |
  | `--save-playlist` / `save_playlist`                             | Save a M3U8 playlist file when downloading a playlist.             | `false`                                        |
  | `--overwrite` / `overwrite`                                     | Overwrite existing files.                                          | `false`                                        |
  | `--exclude-tags` / `exclude_tags`                               | Comma-separated tags to exclude.                                   | `null`                                         |
  | `--truncate` / `truncate`                                       | Maximum length of the file/folder names.                           | `null`                                         |
  | `--audio-quality`, `-a` / `audio_quality`                       | Audio quality for songs and podcasts.                              | `vorbis-medium`                                |
  | `--download-mode`, `-d` / `download_mode`                       | Download mode for songs and podcasts.                              | `ytdlp`                                        |
  | `--remux-mode-audio` / `remux_mode_audio`                       | Remux mode for songs and podcasts.                                 | `ffmpeg`                                       |
  | `--lrc-only`, `-l` / `lrc_only`                                 | Download only the synced lyrics.                                   | `false`                                        |
  | `--no-lrc` / `no_lrc`                                           | Don't download the synced lyrics.                                  | `false`                                        |
  | `--video-format` / `video_format`                               | Video format.                                                      | `mp4`                                          |
  | `--remux-mode-video` / `remux_mode_video`                       | Remux mode for videos.                                             | `ffmpeg`                                       |
  | `--no-config-file`, `-n` / -                                    | Do not use a config file.                                          | `false`                                        |


  The following variables can be used in the template folder/file and/or in the `exclude_tags` list:
  - `album`
  - `album_artist`
  - `artist`
  - `compilation`
  - `composer`
  - `copyright`
  - `cover`
  - `disc`
  - `disc_total`
  - `isrc`
  - `label`
  - `lyrics`
  - `media_type`
  - `playlist_artist`
  - `playlist_title`
  - `playlist_track`
  - `publisher`
  - `producer`
  - `rating`
  - `release_date`
  - `release_year`
  - `title`
  - `track`
  - `track_total`
  - `url`


  The following cover sizes are available:
  * `small`: up to 64px
  * `medium`: up to 300px
  * `large`: up to 640px
  * `extra-large`: up to 2000px


  The following qualities are available:
  * `vorbis-high` (320kbps, requires an active premium subscription)
  * `vorbis-medium` (160kbps)
  * `vorbis-low` (96kbps)
  * `aac-medium` (128kbps)
  * `aac-high` (256kbps, requires an active premium subscription)


  The following video formats are available:
  * `mp4`
  * `webm`
  * `ask`
      * When using this option, Votify will ask you which audio and video codec to use that is available for the video.


  The following modes are available:
  * `ytdlp`
  * `aria2c`
      * Will not be used for downloading videos
      * Faster than `ytdlp`


  The following remux modes for videos are available:
  * `ffmpeg`
  * `mp4box`


  The following remux modes for songs and podcasts are available when downloading in AAC quality:
  * `ffmpeg`
  * `mp4box`
  * `mp4decrypt`


  * [spotify-oggmp4-dl](https://github.com/DevLARLEY/spotify-oggmp4-dl)
  * [spsync](https://github.com/baltitenger/spsync)
  * [unplayplay](https://git.gay/uhwot/unplayplay)


pkgId: 51f7da29367a93524863fd2b64d5e8a53bf414d66c6eddc72d7fe835e7338603
name: python-voxelcity-help
arch: noarch
version: 0.1.80
epoch: 0
release: 1
summary: Development documents and examples for voxelcity
url: https://pypi.org/project/voxelcity/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-voxelcity-0.1.80-1.src.rpm
location_href: Packages/python-voxelcity-help-0.1.80-1.noarch.rpm
checksum_type: sha256
description:
  <br>
  <br>
  <p align="center">
    <a href="https://ual.sg/">
      <img src="https://raw.githubusercontent.com/winstonyym/urbanity/main/images/ualsg.jpeg" width = 55% alt="Logo">
    </a>
  </p>


pkgId: cbbd1c44bcfd423749250ffcfd7b1a61e4c3cb130d097717ca853ba14e11ae91
name: python-vscenv-help
arch: noarch
version: 0.1.2
epoch: 0
release: 1
summary: Development documents and examples for vscenv
url: https://github.com/jugangdae/vscenv
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vscenv-0.1.2-1.src.rpm
location_href: Packages/python-vscenv-help-0.1.2-1.noarch.rpm
checksum_type: sha256
description:
  - Option 1 : Install from pypi
      ```
      pip install vscenv
      ```
  - Option 2 : Install from soruce
      ```
      git clone https://github.com/jugangdae/vscenv
      cd vscenv
      pyhton -m build
      pip install dist/vscenv-0.0.1-py3-none-any.whl
      ```


pkgId: 53a9689f0202c486a370e36cc923169ea6c84a61e8ab9a28408eae11ee2a2d7e
name: python-vtarget-help
arch: noarch
version: 1.0.2
epoch: 0
release: 1
summary: Development documents and examples for vtarget
url: https://pypi.org/project/vtarget/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vtarget-1.0.2-1.src.rpm
location_href: Packages/python-vtarget-help-1.0.2-1.noarch.rpm
checksum_type: sha256
description:
  This is a Python package to run flows generated with the vTarget Dataprep module.



  To install this package, you can use `pip`:

  ```
  pip install vtarget
  ```



  To use this package, you must first import it into your Python script:

  ```python
  import vtarget
  ```

  Then, you can use the `run_flow` function to run a flow generated by vTarget. For example:

  ```python
  nodos = vtarget.run_flow("Flow.json")
  print(nodos["v_output"]["Out"])
  ```



  You can report bugs or suggest improvements through the following [form](https://docs.google.com/forms/d/e/1FAIpQLSfYzPEQsbf-FTtrWpFbjRG2TX3ZrIgNtlMJLhOKteJrhZXUpg/viewform "Soporte vTarget").




  This project is licensed under the BSD license. See the `LICENSE` file for more information.


pkgId: 1910a56dd80723602e7860b68140a947d69b41c8fde14b535534b781928d74c5
name: python-vtexpy-help
arch: noarch
version: 0.0.0b37
epoch: 0
release: 1
summary: Development documents and examples for vtexpy
url: https://github.com/lvieirajr/vtex-python
rpm_license: Apache
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vtexpy-0.0.0b37-1.src.rpm
location_href: Packages/python-vtexpy-help-0.0.0b37-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI Version](https://img.shields.io/pypi/v/vtexpy.svg)](https://pypi.python.org/pypi/vtexpy)



  VTEXPY is an unofficial Python SDK designed to facilitate integration with the VTEX API.

  Even though it is still tagged as beta, vtexpy has been in use by a _SaaS_ company in a
  production environment for over a year, making millions of requests a day to the VTEX
  API. The only reason why it is tagged as beta is that it is still under heavy
  development and breaking changes are expected on the external API.



  - Easy to use Python interface for calling VTEX API endpoints
  - Response format standardization
  - Custom exception handling
  - Automatic request retrying
  - Request logging





  - Python >= 3.9, < 3.14



  ```bash
  pip install vtexpy
  ```



  If the API you want to call is not yet implemented, feel free to create an issue on the
  VTEXPY Github repository and request it to be added.

  ```python
  from vtex import VTEX, VTEXConfig


  vtex_config = VTEXConfig(
      account_name="<ACCOUNT_NAME>",
      app_key="<APP_KEY>",
      app_token="<APP_TOKEN>",
      
  )


  vtex_client = VTEX(config=vtex_config)


  account_response = vtex_client.license_manager.get_account()
  list_sku_ids_response = vtex_client.catalog.list_sku_ids(page=1, page_size=1000)
  list_orders_response = vtex_client.orders.list_orders(page=1, page_size=100)


  response = vtex_client.custom.request(
      method="GET",
      environment="vtexcommercestable",
      endpoint="/api/catalog_system/pvt/commercialcondition/list",
      
  )
  ```


pkgId: 23f2d5e2cb51d8846ae7311a9f942719444a176fb70827bea66b580601923112
name: python-vtjson-help
arch: noarch
version: 2.2.3
epoch: 0
release: 1
summary: Development documents and examples for vtjson
url: https://github.com/vdbergh/vtjson
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vtjson-2.2.3-1.src.rpm
location_href: Packages/python-vtjson-help-2.2.3-1.noarch.rpm
checksum_type: sha256
description:
  `vtjson` is an easy to use validation library compatible with Python type annotations.



  Here is a simple schema:

  ```python
  book_schema = {
      "title": str,
      "authors": [str, ...],
      "editor?": str,
      "year": int,
  }
  ```

  The following conventions were used:

  - As in typescript, a (string) key ending in `?` represents an optional key. The corresponding schema (the item the key points to) will only be used for validation when the key is present in the object that should be validated. A key can also be made optional by wrapping it with `optional_key`.
  - If in a list/tuple the last entry is `...` (ellipsis) it means that the next to last entry will be repeated zero or more times. In this way generic types can be created. For example the schema `[str, ...]` represents a list of strings.

  Let's try to validate some book objects:

  ```python
  good_book = {
      "title": "Gone with the Wind",
      "authors": ["Margaret Mitchell"],
      "year": 1936,
  }

  bad_book = {
      "title": "Gone with the Wind",
      "authors": ["Margaret Mitchell"],
      "year": "1936",
  }

  validate(book_schema, good_book, name="good_book")
  validate(book_schema, bad_book, name="bad_book")
  ```

  As expected `vtjson` throws an exception for the second object:

  ```text
  Traceback (most recent call last):
            ...
      raise ValidationError(message)
  vtjson.vtjson.ValidationError: bad_book['year'] (value:'1936') is not of type 'int'
  ```

  We may also rewrite the `book_schema` as a valid Python type annotation.

  ```python
  class book_schema(TypedDict):
      title: str
      authors: list[str]
      editor: NotRequired[str]
      year: int
  ```

  Attempting to validate the bad book would raise a similar exception as before.

  Schemas can of course be more complicated and in particular they can be nested.
  Here is an example that shows more of the features of `vtjson`.

  ```python
  person_schema = {
      "name": regex("[a-zA-Z. ]*"),
      "email?": email,
      "website?": url,
  }

  book_schema = {
      "title": str,
      "authors": [person_schema, ...],
      "editor?": person_schema,
      "year": intersect(int, ge(1900)),
  }
  ```

  Let's try to validate an object not fitting the schema.

  ```python
  bad_book = {
      "title": "Gone with the Wind",
      "authors": [{"name": "Margaret Mitchell", "email": "margaret@gmailcom"}],
      "year": "1936",
  }
  ```

  ```text
  Traceback (most recent call last):
            ...
      raise ValidationError(message)
  vtjson.vtjson.ValidationError: bad_book['authors'][0]['email'] (value:'margaret@gmailcom') is not of type 'email': The part after the @-sign is not valid. It should have a period.
  ```

  As before we can rewrite the new `book_schema` as a valid type annotation.

  ```python
  class person_schema(TypedDict):
      name: Annotated[str, regex("[a-zA-Z. ]*")]
      email: NotRequired[Annotated[str, email]]
      website: NotRequired[Annotated[str, url]]

  class book_schema(TypedDict):
      title: str
      authors: list[person_schema]
      editor: NotRequired[person_schema]
      year: Annotated[int, ge(1900)]
  ```

  For comprehensive documentation about `vtjson` see [https://www.cantate.be/vtjson](https://www.cantate.be/vtjson) (canonical reference) or [https://vtjson.readthedocs.io](https://vtjson.readthedocs.io).


pkgId: d2645a5a6ad3392719a404c46f0ac15897eaf961b72b950415012415b770ee5b
name: python-vuejspython-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for vuejspython
url: https://github.com/twitwi/vuejs-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-vuejspython-1.0.3-1.src.rpm
location_href: Packages/python-vuejspython-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  If you're looking for "Vuejs-python that brings the concepts of vuejs to Python", see our V0 branch (and readme, and V0.* on pypi).

  The goal of vuejs-python (starting from V1) is to
  - easily run standalone Vue.js components / micro-apps,
  - give them access to the working directory,
  - allow (unsafe) extensions to be written in Python (including numpy, local resource access, etc)




  ~~~
  pip install vuejspython
  ~~~



  ~~~
  vjspy [--trust-python] [--port=...] [--host=...] myfile.vue more arbitrary parameters
  ~~~


  You can run the bundled tools using their `:` prefixed names instead of the vue file, for instance:

  ~~~
  vjspy :create-demo-files demo
  vjspy :view-file demo/file1.txt
  vjspy :edit-file demo/file1.txt
  vjspy --trust-python :file-rotator demo/file*.txt
  vjspy :exam-toggle demo/exam/*
  ~~~


pkgId: e9a1969f070d119d2217ccf33bf05c6c19a422985afdf85ad9ae28d30f440fc5
name: python-wLpylib-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for wLpylib
url: https://github.com/WWX-Team/wL
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wLpylib-1.2.0-1.src.rpm
location_href: Packages/python-wLpylib-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  **wL** is a *markup metalanguage* designed to store arbitrary data in a format that is both human-readable and machine-readable.

  The design goals of wL emphasize elementary simplicity, generality, stability, and usability across all programming language.
  Plus, wL format does not contain no data specialisation or typing, for a linear read.

  Consider checking the [GitHub rep](https://github.com/WWX-Team/wL/) to get a full documentation.


pkgId: 5aa4fdd7b6dfb72d8a82bf40039db89238f35dc4bd93c7010c7db6916caf7235
name: python-wads-help
arch: noarch
version: 0.1.25
epoch: 0
release: 1
summary: Development documents and examples for wads
url: https://github.com/i2mint/wads
rpm_license: Apache Software License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wads-0.1.25-1.src.rpm
location_href: Packages/python-wads-help-0.1.25-1.noarch.rpm
checksum_type: sha256
description:
  Tools for packaging and publishing to pypi for those who just don't want to deal with it

  To install (for example):
  ```
  pip install wads
  ```



  We're going to assume you pointed "pack" to "wads/pack.py" and "populate" to "wads/populate.py",
  because it's convenient for us to do so. You can achieve this in various ways
  (for example, putting the contents:
  `python /Users/Thor.Whalen/Dropbox/dev/p3/proj/i/wads/wads/pack.py "$@"`
  in a file named "pack" contained in your OS's script path.)




  When? When you got a new project and you want to quickly set it up with the packaging goodies.

  Basic usage:

  ```
  populate PKG_DIR
  ```

  or, assuming you're using the terminal and you're in the `PKG_DIR` root folder of the project, you can just do:

  ```
  populate .
  ```

  What that will do is create and populate some files for you.
  Namely, it will ensure your package directory has the following files (if not present already)
  ```
  ./LICENSE
  ./setup.cfg
  ./PKG_NAME/__init__.py
  ./README.md
  ```

  The `PKG_NAME` will be taken to be the same as the name of the `PKG_DIR`.

  That will work, it will be minimal and will choose defaults for you.
  You can overwrite many of these, of course.
  For example,

  ```
  populate -r https:///github.com/i2mint --description "Something about my project..."
  ```

  Here are the following options:

  ```
  positional arguments:
    pkg-dir               -

  optional arguments:
    -h, --help            show this help message and exit
    --description DESCRIPTION
                          "There is a bit of an air of mystery around this project..."
    -r ROOT_URL, --root-url ROOT_URL
                          -
    -a AUTHOR, --author AUTHOR
                          -
    -l LICENSE, --license LICENSE
                          'mit'
    --description-file DESCRIPTION_FILE
                          'README.md'
    -k KEYWORDS, --keywords KEYWORDS
                          -
    --install-requires INSTALL_REQUIRES
                          -
    --include-pip-install-instruction-in-readme
                          True
    -v, --verbose         True
    -o OVERWRITE, --overwrite OVERWRITE
                          ()
    --defaults-from DEFAULTS_FROM
                          -
  ```

  Note that by default, populate will not overwrite files that all already there.
  It will edit the `setup.cfg` file if it's present (and missing some entries).



  Note that `defaults-from` option in the `populate` help.
  That's probably the most convenient argument of all.
  Go check out a file named `wads_confgis.json` in the root directory of the project.
  (If you don't know how to find that file, try this command:
  `python -c "import wads; print(wads)"` to get a clue).

  That `wads_confgis.json` file contains key-value entries that are used in the wads package.
  The `"populate_dflts"` key is used by the populate script.
  If you edit that, you'll get different defaults out of the box.

  But you can also add your own key-value pairs if you work on different kinds of projects that need
  different kinds of defaults.
  For your convenience we added a `"custom_dflts_example_you_should_change"` key to illustrate this.



  The typical sequence of the methodical and paranoid could be something like this:

  ```
  python pack.py current-configs  # see what you got
  python pack.py increment-configs-version  # update (increment the version and write that in setup.cfg
  python pack.py current-configs-version  # see that it worked
  python pack.py current-configs  # ... if you really want to see the whole configs again (you're really paranoid)
  python pack.py run-setup  # see that it worked
  python pack.py twine-upload-dist  # publish

  ```


  If you're are great boilerplate hater you could just do:

  ```
  pack go PKG_DIR
  ```

  (or `pack go --version 0.0.0 PKG_DIR` if it's the very first release).

  But we suggest you get familiar with what the steps are doing, so you can bend them to your liking.





  Sometimes the twine PYPI publishing may fail with such a message:

  ```
  WARNING  Skipping PKGNAME-0.1.4-py3-none-any.whl because it appears to already exist
  WARNING  Skipping PKGNAME-0.1.4.tar.gz because it appears to already exist
  ```

  This often means that your git tags are misaligned with the `setup.cfg` version.
  You can see your git tags here: `https://github.com/ORG/REPO/tags`.

  To repair, do this:

  * go to the https://pypi.org/project/ project page and note the VERSION number
  * enter a VERSION number ABOVE that one in the version key of `setup.cfg`
  * `git tag VERSION`
  * `git push origin VERSION`


pkgId: f0bedb033246bc9bbaae73fcdd89b77d3215a337c56ff356225fa3f64fa2e5de
name: python-wafl-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for wafl
url: http://github.com/fractalego/wafl
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wafl-0.1.3-1.src.rpm
location_href: Packages/python-wafl-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
  WAFL is a framework for personal agents. It integrates Large language models, speech recognition and text to speech.
  This framework combines Large Language Models and rules to create a predictable behavior.
  A set of rules is used to define the behavior of the agent, supporting function calling and a working memory.
  The current version requires the user to specify the rules to follow.


pkgId: a992139a632e4d2041787c11f7f1a5b13f053214f4feddcab4dbf29a7fd6b14b
name: python-wafl-llm-help
arch: noarch
version: 0.1.1
epoch: 0
release: 1
summary: Development documents and examples for wafl-llm
url: https://github.com/fractalego/wafl_llm
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wafl-llm-0.1.1-1.src.rpm
location_href: Packages/python-wafl-llm-help-0.1.1-1.noarch.rpm
checksum_type: sha256
description:
  WAFL is built to run as a two-part system.
  Both can be installed on the same machine.
  This is the LLM side of the [WAFL project](https://github.com/fractalego/wafl).

  ![The two parts of WAFL](images/two-parts.png)




  This is a model server for the speech-to-text model, the LLM, the embedding system, and the text-to-speech model.


  In order to quickly run the LLM side, you can use the following installation commands:
  ```bash
  pip install wafl-llm
  wafl-llm start
  ```
  which will use the default models and start the server on port 8080.

  The installation will require MPI and Java installed on the system.
  One can install both with the following commands
  ```bash
  sudo apt install libopenmpi-dev
  sudo apt install default-jdk
  ```


  A use-case specific configuration can be set by creating a `config.json` file in the path where `wafl-llm start` is executed.
  The file should look like this (the default configuration)
  ```json
  {
    "llm_model": "fractalego/wafl-phi3-mini-4k",
    "speaker_model": "microsoft/speecht5_tts",
    "whisper_model": "fractalego/personal-whisper-distilled-model",
    "sentence_embedder_models": "TaylorAI/gte-tiny",
    "entailer_model": "vectara/hallucination_evaluation_model",
    "device": "cuda",
    "quantization": false
  }

  ```

  The models are downloaded from the HugggingFace repository. Any other compatible model should work.
  The `device` can be set to `cuda` or `cpu`.
  The `quantization` can be set to `true` or `false` and uses the vLLM `fp8` option. This will only work if your GPU supports it.
  Each model can be set to `null` to deactivate it (and save memory).
  This is useful if you only want to use the LLM model, for example.



  Run the following

  ```bash
  docker/build.sh
  docker run -p8080:8080 --env NVIDIA_DISABLE_REQUIRE=1 --gpus all wafl-llm
  ```


pkgId: 3fcfd76b68c9369a16e629ffe63c818c014bcf7f21c78a50a8f33bad17bb7ff2
name: python-wago-api-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for wago-api
url: https://github.com/Ghostopheles/py-wago-api
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wago-api-0.0.1-1.src.rpm
location_href: Packages/python-wago-api-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  An asynchronous Python wrapper for the [wago.tools](https://wago.tools) API



  ```
  pip install git+https://github.com/Ghostopheles/py-wago-api.git
  ```



  All responses are converted from their usual JSON format into Python objects.

  ```py
  from wago import WagoAPI

  async def main():
      client = WagoAPI()

      fdid = 6420120
      file = await client.get_file_by_fdid(fdid)
  ```




  - `WagoAPI.get_all_builds()`: Returns all builds that have been processed by wago.tools
  - `WagoAPI.get_latest_build(product)`: Returns the latest build for the specified product
  - `WagoAPI.get_latest_build_for_all_products()`: Returns the latest build for all products


  - `WagoAPI.get_file_by_fdid(fdid)`: Returns the contents of a CASC file by FileDataID
      - Optionally, provide a version to grab the file for the specified build (i.e. "11.0.7.58187")
  - `WagoAPI.get_file_info_by_fdid(fdid)`: Returns metadata about a given CASC file by FileDataID
  - `WagoAPI.get_all_files()`: Returns all available files in the specified format, or json by default
      - Optionally, specify a version and format

rpm_license:
  This is free and unencumbered software released into the public domain.  Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.  In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.  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 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.  For more information, please refer to <https://unlicense.org>


pkgId: 7ff6d761ac001d1225b2b7961fa0962c4b99a5212c5324499fbdf189592a78f3
name: python-wagtail-airtable-help
arch: noarch
version: 1.0.0
epoch: 0
release: 1
summary: Development documents and examples for wagtail-airtable
url: https://pypi.org/project/wagtail-airtable/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wagtail-airtable-1.0.0-1.src.rpm
location_href: Packages/python-wagtail-airtable-help-1.0.0-1.noarch.rpm
checksum_type: sha256
description:
  An extension for Wagtail allowing content to be transferred between Airtable sheets and your Wagtail/Django models.

  Developed by [Torchbox](https://torchbox.com/) and sponsored by [The Motley Fool](https://www.fool.com/).

  ![Wagtail Airtable demo](examples/preview.gif)



  When you setup a model to "map" to an Airtable sheet, every time you save the model it will attempt to update the row in Airtable. If a row is not found, it will create a new row in your Airtable.

  When you want to sync your Airtable data to your Wagtail website, you can go to `Settings -> Airtable Import`. You can then import entire tables into your Wagtail instance with the click of a button. If you see "_{Your Model}_ is not setup with the correct Airtable settings" you will need to double check your settings. By default the import page can be found at http://yourwebsite.com/admin/airtable-import/, or if you use a custom /admin/ url it'll be http://yourwebsite.com/{custom_admin_url}/airtable-import/.


  This package will attempt to match a model object against row in Airtable using a `record_id`. If a model does not have a record_id value, it will look for a match using the `AIRTABLE_UNIQUE_IDENTIFIER` to try and match a unique value in the Airtable to the unique value in your model. Should that succeed your model object will be "paired" with the row in Airtable. But should the record-search fail, a new row in Airtable will be created when you save your model, or a new model object will attempt to be created when you import a model from Airtable.

  > **Note**: Object creation _can_ fail when importing from Airtable. This is expected behaviour as an Airtable might not have all the data a model requires. For instance, a Wagtail Page uses django-treebeard, with path as a required field. If the page model import settings do not include the path field, or a path column isn't present in Airtable, the page cannot be created. This same rule applies to other required fields on any Django model including other required fields on a Wagtail Page.



  * Install the package with `pip install wagtail-airtable`
  * Add `'wagtail_airtable'` to your project's `INSTALLED_APPS`.
      * On Wagtail 5.x, to enable the snippet-specific import button on the Snippet list view make sure `wagtail_airtable` is above `wagtail.snippets` in your `INSTALLED_APPS`
  * In your settings you will need to map Django models to Airtable settings. Every model you want to map to an Airtable sheet will need:
      * An `AIRTABLE_BASE_KEY`. You can obtain a personal access token at https://airtable.com/create/tokens - from "Create new token", select the scopes `data.records:read` and `data.records:write`, and under Access, select the base you want to work with. Copy the resulting token and paste it as the value of `AIRTABLE_BASE_KEY`.
      * An `AIRTABLE_TABLE_NAME` to determine which table to connect to.
      * An `AIRTABLE_UNIQUE_IDENTIFIER`. This can either be a string or a dictionary mapping the Airtable column name to your unique field in your model.
          * ie. `AIRTABLE_UNIQUE_IDENTIFIER: 'slug',` this will match the `slug` field on your model with the `slug` column name in Airtable. Use this option if your model field and your Airtable column name are identical.
          * ie. `AIRTABLE_UNIQUE_IDENTIFIER: {'Airtable Column Name': 'model_field_name'},` this will map the `Airtable Column Name` to a model field called `model_field_name`. Use this option if your Airtable column name and your model field name are different.
      * An `AIRTABLE_SERIALIZER` that takes a string path to your serializer. This helps map incoming data from Airtable to your model fields. Django Rest Framework is required for this. See the [examples/](examples/) directory for serializer examples.

  * Lastly make sure you enable wagtail-airtable with `WAGTAIL_AIRTABLE_ENABLED = True`. By default this is disabled so data in your Wagtail site and your Airtable sheets aren't accidentally overwritten. Data is hard to recover, this option helps prevent accidental data loss.



  Below is a base configuration or `ModelName` and `OtherModelName` (both are registered Wagtail snippets), along with `HomePage`.

  ```python

  AIRTABLE_API_KEY = 'yourSuperSecretKey'
  WAGTAIL_AIRTABLE_ENABLED = True
  AIRTABLE_IMPORT_SETTINGS = {
      'appname.ModelName': {
          'AIRTABLE_BASE_KEY': 'app3ds912jFam032S',
          'AIRTABLE_TABLE_NAME': 'Your Airtable Table Name',
          'AIRTABLE_UNIQUE_IDENTIFIER': 'slug', # Must match the Airtable Column name
          'AIRTABLE_SERIALIZER': 'path.to.your.model.serializer.CustomModelSerializer'
      },
      'appname.OtherModelName': {
          'AIRTABLE_BASE_KEY': 'app4ds902jFam035S',
          'AIRTABLE_TABLE_NAME': 'Your Airtable Table Name',
          'AIRTABLE_UNIQUE_IDENTIFIER': {
              'Page Slug': 'slug', # 'Page Slug' column name in Airtable, 'slug' field name in Wagtail.
          },
          'AIRTABLE_SERIALIZER': 'path.to.your.model.serializer.OtherCustomModelSerializer'
      },
      'pages.HomePage': {
          'AIRTABLE_BASE_KEY': 'app2ds123jP23035Z',
          'AIRTABLE_TABLE_NAME': 'Wagtail Page Tracking Table',
          'AIRTABLE_UNIQUE_IDENTIFIER': {
              'Wagtail Page ID': 'pk',
          },
          'AIRTABLE_SERIALIZER': 'path.to.your.pages.serializer.PageSerializer',
          
          
          
          
          
          
          'AIRTABLE_IMPORT_ALLOWED': True,
          
          
          
          
          
          'AIRTABLE_BASE_URL': 'https://airtable.com/tblxXxXxXxXxXxXx/viwxXxXxXxXxXxXx',
          
          
          
          
          
          
          
          
          
          
          

          
          
          
          
          
          'PARENT_PAGE_ID': 'path.to.function',
          
          
          
          'AUTO_PUBLISH_NEW_PAGES': False,
      },
      
  }
  ```


  The most common approach will likely be to support a handful of models, in which case using the below example would be faster and cleaner. Write a config dictionary once to prevent config bloat.

  ```python
  AIRTABLE_API_KEY = 'yourSuperSecretKey'
  WAGTAIL_AIRTABLE_ENABLED = True
  CUSTOM_PAGE_SETTINGS = {
      'AIRTABLE_BASE_KEY': 'app3ds912jFam032S',
      'AIRTABLE_TABLE_NAME': 'Your Airtable Table Name',
      'AIRTABLE_UNIQUE_IDENTIFIER': 'slug', # Must match the Airtable Column name
      'AIRTABLE_SERIALIZER': 'path.to.your.model.serializer.CustomModelSerializer'
  },
  AIRTABLE_IMPORT_SETTINGS = {
      'home.HomePage': CUSTOM_PAGE_SETTINGS,
      'blog.BlogPage': CUSTOM_PAGE_SETTINGS,
      'appname.YourModel': CUSTOM_PAGE_SETTINGS,
  }
  ```



  This feature was sponsored by [The Mozilla Foundation](https://foundation.mozilla.org/).

  In `wagtail-airtable` v0.1.6 and up you can create Wagtail Pages from Airtable imports.

  A few settings need to be set for this to work as you would expect. Read through the following code to see which settings are needed:

  ```python
  AIRTABLE_IMPORT_SETTINGS = {
      'pages.HomePage': {
          'AIRTABLE_BASE_KEY': 'app2ds123jP23035Z',
          'AIRTABLE_TABLE_NAME': 'Wagtail Page Tracking Table',
          'AIRTABLE_UNIQUE_IDENTIFIER': {
              'Wagtail Page ID': 'pk',
          },
          'AIRTABLE_SERIALIZER': 'path.to.your.pages.serializer.PageSerializer',
          'AIRTABLE_IMPORT_ALLOWED': True,  # This must be set
          'PARENT_PAGE_ID': 'path.to.function.that.returns.an.integer',  # This must be set
      },
  }
  ```

  Once your settings are ready, you can start creating new Pages in Airtable and import those pages via the Wagtail Admin (found in the setting menu).

  **Caveats**: In the above code we see `{'Wagtail Page ID': 'pk',}`, this means there's a column in Airtable named "Wagtail Page ID" and it mapped to a Page pk. When you create a new Wagtail Page inside of an Airtable sheet, _keep this cell blank in your new row_. It will auto-update when it gets imported. This happens because Airtable (and the editors) likely don't know what the new Page ID is going to be, so we let Wagtail set it, and then update the Airtable again.


  Hooks are a way to execute code once an action has happened. This mimics (and internally uses) Wagtail's hook feature.

  > **Note**: When using hooks it will add processing time to your requests. If you're using Heroku with a 30s timeout you may want to use a management command to avoid hitting a server timeout.


  To take an action when a record is updated, you can write a hook like this in your wagtail_hooks.py file:

  ```python
  @hooks.register('airtable_import_record_updated')
  def airtable_record_updated(instance, is_wagtail_page, record_id):
      
      
      
      pass
  ```



  ```bash
  python manage.py import_airtable appname.ModelName secondapp.SecondModel
  ```

  Optionally you can turn up the verbosity for better debugging with the `--verbosity=2` flag.


  This command will look for any `appname.ModelName`s you provide it and use the mapping settings to find data in the Airtable. See the "Behind the scenes" section for more details on how importing works.


  By default the `import_airtable` command adds an additional attribute to the models being saved called `_skip_signals` - which is set to `True` you can use this to bypass any `post_save` or `pre_save` signals you might have on the models being imported so those don't run. e.g.

  ```
  @receiver(post_save, sender=MyModel)
  def post_save_function(sender, **kwargs):
      if sender._skip_signals:
          
  ```

  if you don't do these checks on your signal, the save will run normally.



  > **Note:** Be careful not to use the production settings as you could overwrite Wagtail or Airtable data.

  Because Airtable doesn't provide a testing environment, you'll need to test against a live table. The best way to do this is to copy your live table to a new table (renaming it will help avoid naming confusion), and update your local settings. With this method, you can test to everything safely against a throw-away Airtable. Should something become broken beyond repair, delete the testing table and re-copy the original one.


  Due to the complexity and fragility of connecting Wagtail and Airtable (because an Airtable column can be almost any value) you may need some help debugging your setup. To turn on higher verbosity output, you can enable the Airtable debug setting `WAGTAIL_AIRTABLE_DEBUG = True`. All this does is increase the default verbosity when running the management command. In a standard Django management command you could run `python manage.py import_airtable appname.ModelName --verbosity=2` however when you import from Airtable using the Wagtail admin import page you won't have access to this verbosity argument. But enabling `WAGTAIL_AIRTABLE_DEBUG` you can manually increase the verbosity.

  > **Note**: This only only work while `DEBUG = True` in your settings as to not accidentally flood your production logs.


  Airtable columns can be one of numerous "types", very much like a Python data type or Django field. You can have email columns, url columns, single line of text, checkbox, etc.

  To help maintain proper data synchronisation between your Django/Wagtail instance and your Airtable Base's, you _should_ set the column types to be as similar to your Django fields as possible.

  For example, if you have a BooleanField in a Django model (or Wagtail Page) and you want to support pushing that data to Airtable amd support importing that same data from Airtable, you should set the column type in Airtable to be a Checkbox (because it can only be on/off, much like how a BooleanField can only be True/False).

  In other cases such as Airtables Phone Number column type: if you are using a 3rd party package to handle phone numbers and phone number validation, you'll want to write a custom serializer to handle the incoming value from Airtable (when you import from Airtable). The data will likely come through to Wagtail as a string and you'll want to adjust the string value to be a proper phone number format for internal Wagtail/Django storage. (You may also need to convert the phone number to a standard string when exporting to Airtable as well)


  Clone the project and cd into the `wagtail-airtable/` directory. Then run `python runtests.py tests`. This project is using standard Django unit tests.

  To target a specific test you can run `python runtests.py tests.test_file.TheTestClass.test_specific_model`

  Tests are written against Wagtail 2.10 and later.


  In some cases you may want to customize how saving works, like making the save to airtable asynchronous for example.

  To do so, set: WAGTAIL_AIRTABLE_SAVE_SYNC=False in your settings.py file.

  This _escapes_ out of the original save method and requires you enable the asynchronous part of this on your own.

  An example of how you might set this up using the signal `after_page_publish` with [django_rq](https://github.com/rq/django-rq)
  ```

  WAGTAIL_AIRTABLE_SAVE_SYNC=False
  WAGTAIL_AIRTABLE_PUSH_MESSAGE="Airtable save happening in background"


  from django.dispatch import receiver
  from wagtail.models import Page

  @job('airtable')
  def async_airtable_save(page_id):
      my_page = Page.objects.get(page_id).specific
      my_page.save_to_airtable()


  @receiver('page_published')
  def upload_page_to_airtable(request, page):
      async_airtable_save.delay(page.pk)

  ```


  The messaging will be off if you do this, so another setting has been made available so you may change the messaging to anything you'd like:
  `WAGTAIL_AIRTABLE_PUSH_MESSAGE` - set this to whatever you'd like the messaging to be e.g. `WAGTAIL_AIRTABLE_PUSH_MESSAGE='Airtable save is happening in the background'`




  As of Wagtail 6.0, the Import action is no longer automatically shown on the snippet listing view (although it is still available through Settings -> Airtable import). To add it back, first ensure that your snippet model is [registered with an explicit viewset](https://docs.wagtail.org/en/stable/topics/snippets/registering.html#using-register-snippet-as-a-function). Then, ensure that the index view for that viewset inherits from `SnippetImportActionMixin`:

  ```python
  from wagtail.snippets.models import register_snippet
  from wagtail.snippets.views.snippets import IndexView, SnippetViewSet
  from wagtail_airtable.mixins import SnippetImportActionMixin
  from .models import Advert


  class AdvertIndexView(SnippetImportActionMixin, IndexView):
      pass


  class AdvertViewSet(SnippetViewSet):
      model = Advert
      index_view_class = AdvertIndexView

  register_snippet(Advert, viewset=AdvertViewSet)
  ```




  Ensure that your serializer matches your field definition *exactly*, and in cases of `CharField`'s that have `blank=True` or `null=True` setting `required=False` on the serializer is also important.

  In some cases 2 Models may get the same Airtable ID. To circumvent this error on imports the first one found will be set as the "real" one and the "impostors" will be set to `""` - this may create duplicate models in your system, if this is happening a lot. Make sure your export method and serializer import are set correctly.


pkgId: 22f06043c88281a645e62abb4593a388134a37b37289ae08b7e7adcbd9b7d6bc
name: python-wagtail-donate-help
arch: noarch
version: 1.9.4
epoch: 0
release: 1
summary: Development documents and examples for wagtail-donate
url: https://pypi.org/project/wagtail-donate/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wagtail-donate-1.9.4-1.src.rpm
location_href: Packages/python-wagtail-donate-help-1.9.4-1.noarch.rpm
checksum_type: sha256
description:
  Copyright (c) 2021 Torchbox

  This is not free software.

  You may not use, copy, modify, merge, publish, distribute, sublicense, and/or
  sell this software and associated documentation files without the express
  consent of Torchbox.


pkgId: 35cf3ea96ad9cd2b4b66534c8c7591527245d093aca14e27527cafe77ed9240e
name: python-wagtail-modeltranslation-help
arch: noarch
version: 0.15.2
epoch: 0
release: 1
summary: Development documents and examples for wagtail-modeltranslation
url: https://github.com/infoportugal/wagtail-modeltranslation
rpm_license: New BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wagtail-modeltranslation-0.15.2-1.src.rpm
location_href: Packages/python-wagtail-modeltranslation-help-0.15.2-1.noarch.rpm
checksum_type: sha256
description:
  This app is built using core features of django-modeltranslation: https://github.com/deschler/django-modeltranslation
  It's an alternative approach for i18n support on Wagtail CMS websites.
  The wagtail-modeltranslation application is used to translate dynamic content of
  existing Wagtail models to an arbitrary number of languages, without having to
  change the original model classes. It uses a registration approach (comparable
  to Django's admin app) to add translations to existing or new projects and is
  fully integrated into the Wagtail admin UI.
  The advantage of a registration approach is the ability to add translations to
  models on a per-app basis. You can use the same app in different projects,
  whether or not they use translations, and without touching the original
  model class.


pkgId: 5f5d468718d748700a239609bbc5ec5c5d76e2631e4ef1b77e1e78c766694f6f
name: python-waldiez-help
arch: noarch
version: 0.1.17
epoch: 0
release: 1
summary: Development documents and examples for waldiez
url: https://pypi.org/project/waldiez/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waldiez-0.1.17-1.src.rpm
location_href: Packages/python-waldiez-help-0.1.17-1.noarch.rpm
checksum_type: sha256
description:
  ![CI Build](https://github.com/waldiez/waldiez/actions/workflows/main.yaml/badge.svg) [![Coverage Status](https://coveralls.io/repos/github/waldiez/waldiez/badge.svg)](https://coveralls.io/github/waldiez/waldiez) [![PyPI version](https://badge.fury.io/py/waldiez.svg?icon=si%3Apython)](https://badge.fury.io/py/waldiez)

  Translate a Waldiez flow:

  ![Flow](https://raw.githubusercontent.com/waldiez/waldiez/refs/heads/main/docs/static/images/overview.webp)

  To a python script or a jupyter notebook with the corresponding [ag2](https://github.com/ag2ai/ag2/) agents and chats.



  - Convert .waldiez flows to .py or .ipynb
  - Run a .waldiez flow
  - Provide a custom [IOSStream](https://ag2ai.github.io/ag2/docs/reference/io/base#iostream) to handle input and output.



  On PyPI:

  ```bash
  python -m pip install waldiez
  ```

  From the repository:

  ```bash
  python -m pip install git+https://github.com/waldiez/waldiez.git
  ```





  ```bash

  waldiez convert --file /path/to/a/flow.waldiez --output /path/to/an/output/flow[.py|.ipynb]

  waldiez run --file /path/to/a/flow.waldiez --output /path/to/an/output/flow[.py] [--force]
  ```



  ```shell
  CONTAINER_COMMAND=docker # or podman

  $CONTAINER_COMMAND pull waldiez/waldiez

  $CONTAINER_COMMAND run \
    --rm \
    -v /path/to/a/flow.waldiez:/flow.waldiez \
    -v /path/to/an/output:/output \
    waldiez/waldiez convert --file /flow.waldiez --output /output/flow[.py|.ipynb] [--force]


  $CONTAINER_COMMAND run \
    --rm \
    -v /path/to/a/flow.waldiez:/flow.waldiez \
    -v /path/to/an/output:/output \
    --userns=keep-id \
    --security-opt label=disable \
    waldiez/waldiez convert --file /flow.waldiez --output /output/flow[.py|.ipynb] [--force]
  ```

  ```shell

  $CONTAINER_COMMAND run \
    --rm \
    -v /path/to/a/flow.waldiez:/flow.waldiez \
    -v /path/to/an/output:/output \
    waldiez/waldiez run --file /flow.waldiez --output /output/output[.py]
  ```



  For creating-only (no exporting or running) waldiez flows, you can use the playground at <https://waldiez.github.io>.
  The repo for the js library is [here](https://github.com/waldiez/react).
  We are currently working on waldiez-studio to provide a visual interface for creating and running Waldiez flows (you can find more [here](https://github.com/waldiez/studio)).
  Until then, you can use our [Jupyter](https://github.com/waldiez/jupyter) or the [VSCode](https://github.com/waldiez/vscode) extension to create and run Waldiez flows.





  ```python

  from waldiez import WaldiezExporter
  flow_path = "/path/to/a/flow.waldiez"
  output_path = "/path/to/an/output.py"  # or .ipynb
  exporter = WaldiezExporter.load(flow_path)
  exporter.export(output_path)
  ```



  ```python

  from waldiez import WaldiezRunner
  flow_path = "/path/to/a/flow.waldiez"
  output_path = "/path/to/an/output.py"
  runner = WaldiezRunner.load(flow_path)
  runner.run(output_path=output_path)
  ```



  ```python


  import time
  import threading

  from typing import Any

  from waldiez import WaldiezRunner
  from waldiez.io import WaldiezIOStream

  flow_path = "/path/to/a/flow.waldiez"
  output_path = "/path/to/an/output.py"


  def custom_print_function(*args: Any, sep: str = " ", **kwargs: Any) -> None:
      """Custom print function."""
      print(*args, sep=sep, **kwargs)



  class InputProcessorWrapper:
      """Wrapper input processor.

      To manage the interaction between the custom input processor and IOStream.
      """

      def __init__(self):
          self.stream = None  # Placeholder for the WaldiezIOStream instance
          self.lock = threading.Lock()  # Ensure thread-safe operations

      def custom_input_processor(self, prompt: str) -> None:
          """Simulate external input and send it back to the IOStream."""
          def external_input_simulation():
              with self.lock:  # Ensure thread-safe access
                  time.sleep(2)  # Simulate delay for network input
                  if self.stream:
                      self.stream.set_input("Simulated external input")
                  else:
                      raise RuntimeError("Stream reference not set!")

          threading.Thread(target=external_input_simulation, daemon=True).start()

      def set_stream(self, stream: "WaldiezIOStream"):
          """Set the WaldiezIOStream instance."""
          with self.lock:  # Ensure thread-safe setting of the stream
              self.stream = stream

  processor_wrapper = InputProcessorWrapper()

  stream = WaldiezIOStream(
      input_timeout=30,
      print_function=
      on_prompt_input=processor_wrapper.custom_input_processor,
  )


  processor_wrapper.set_stream(custom_stream)

  with WaldiezIOStream.set_default(io_stream):
      runner = WaldiezRunner.load(flow_path)
      runner.run(stream=io_stream, output_path=output_path)

  ```



  - [ag2 (formerly AutoGen)](https://github.com/ag2ai/ag2)
  - [juptytext](https://github.com/mwouts/jupytext)
  - [pydantic](https://github.com/pydantic/pydantic)
  - [typer](https://github.com/fastapi/typer)



  - **autogen-agentchat**: This package conflicts with `ag2` / `pyautogen`. Ensure that `autogen-agentchat` is uninstalled before installing `waldiez`. If you have already installed `autogen-agentchat`, you can uninstall it with the following command:

    ```shell
    pip uninstall autogen-agentchat -y
    ```

    If already installed waldiez you might need to reinstall it after uninstalling `autogen-agentchat`:

      ```shell
      pip install --force --no-cache waldiez pyautogen
      ```



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


pkgId: 8257e82b361a97b586262d551a4d54aae99351c6491e3ba545d1407a74a6aa37
name: python-waldur-site-agent-help
arch: noarch
version: 0.5.4
epoch: 0
release: 1
summary: Development documents and examples for waldur-site-agent
url: https://waldur.com
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waldur-site-agent-0.5.4-1.src.rpm
location_href: Packages/python-waldur-site-agent-help-0.5.4-1.noarch.rpm
checksum_type: sha256
description:
  Agent for Mastermind integration with a provider's site.
  The main purpose of the agent is data syncronization between Waldur
  and an application (for example SLURM or MOAB cluster).
  The agent uses order-related information
  from Waldur to manage accounts in the site and
  accounting-related info from the site (backend) to update usage data in Waldur.
  For now, the agent supports only SLURM and MOAB clusters as a site.



  Agent is a stateless application, which is deployed
  on a machine having access to a backend data.
  It consists of three sub-applications:

  - `agent-order-process`, which fetches ordering data from Waldur and updates
    a state of a backend correspondingly;
    (e.g. creates/updates/deletes SLURM accounts);
  - `agent-report`, which reports computing usage and limits info from
    a backend to Waldur (e.g. update of resource usages);
  - `agent-membership-sync`, which syncs membership info between Waldur
    and a backend (e.g. adds users to a SLURM allocation).



  For this, the agent uses [Waldur client](https://github.com/waldur/python-waldur-client)
  based on Python and REST communication with [Waldur backend](https://github.com/waldur/waldur-mastermind).
  `Agent-order-process` application pulls data of orders created
  in Waldur and creates/updates/removes backend resources based on this info.
  `Agent-report` fetches usage data pushes it to Waldur.
  `Agent-membership-sync` fetches associations from
  a backend and syncronizes it with remote ones.





  The agent relies on SLURM command line utilities (e.g. `sacct` and `sacctmgr`)
  and should run on a headnode of the SLURM cluster.



  The agent relies on MOAB command line utilities (e.g. `mam-list-accounts` and `mam-create-account`)
  and should run on a headnode of the MOAB cluster as a root user.



  The application supports the following CLI arguments:

  - `-m`, `--mode` - mode of agent; supported values:
    `order_process`, `report` and `membership_sync`; default is `order_process`.
  - `-c`, `--config-file` - path to the config file with provider settings.

  Optional environment variables:

  - `WALDUR_SITE_AGENT_ORDER_PROCESS_PERIOD_MINUTES` - trigger period for `order_process`
    mode in minutes (default is 5);
  - `WALDUR_SITE_AGENT_REPORT_PERIOD_MINUTES` - trigger period for `report`
    mode in minutes (default is 30);
  - `WALDUR_SITE_AGENT_MEMBERSHIP_SYNC_PERIOD_MINUTES` - trigger period for `membership_sync`
    mode in minutes (default is 5).
  - `REQUESTS_VERIFY_SSL` - flag for SSL verification
    for Waldur client, default is `true`.
  - `SENTRY_ENVIRONMENT` - name of the Sentry environment.

  The primary config for the agent is a `waldur-site-agent-config.yaml`.
  Using it, the agent can serve several offerings
  and setup backend-related data, for example computing component settings.
  File [example](./examples/waldur-site-agent-config.yaml.example) and [reference](#provider-config-file-reference).

  **NB:** for MOAB, the only acceptable component is `deposit`.
  All other specified components are ignored by the agent.



  A user should deploy 3 separate instances of the agent.
  The first one (called agent-order-process) fetches data
  from Waldur with further processing,
  the second one (called agent-report)
  sends usage data from the backend to Waldur
  and the third one syncs membership information between Waldur and the backend.
  All the instances must be configured with CLI variables and provider config file.

  To deploy them, you need to setup and
  start the systemd services.





  The agents require existing offering data in Waldur.
  As a service provider owner, you should create an offering in the marketplace:

  - Go to `Service Provider` section of the organization
    and open offering creation menu
  - Input a name, choose a category, select `SLURM remote allocation`
    from the drop-down list on the bottom and click `Create` button

  ![offering-creation](img/remote-slurm-offering.png)

  - Open the offering page, choose `Edit` tab, click `Accounting` section,
    choose `Accounting plans` from the drop-down list and create a plan:
    click `Add plan` and input the necessary details;

  ![offering-plan](img/offering-plan.png)

  - In the same page, click `Integration` section choose `User management`
    from the drop-down list and set the
    `Service provider can create offering user` option to `Yes`;

  ![offering-user-management](img/offering-user-management.png)

  - Activate the offering using the big green button `Activate`.

  **Note**: You will need to set the offering UUID in the agent config file.
  For this, you can copy the UUID from the `Integration -> Credentials`
  section on the same page:

  ![offering-uuid](img/offering-uuid.png)



  Firstly, install the `waldur-site-agent` module:

  ```bash
  pip install waldur-site-agent
  ```

  Secondly, create the provider config file and adjust the content for your needs.

  ```sh
  cp examples/waldur-site-agent-config.yaml.example /etc/waldur/waldur-site-agent-config.yaml
  ```

  Please use the `waldur_site_load_components` command
  to load computing components into Waldur.

  ```bash
  waldur_site_load_components -c /etc/waldur/waldur-site-agent-config.yaml
  ```

  Thirdly, put systemd unit
  and provider config files to the corresponding locations.

  - agent-order-process systemd unit: [waldur-agent-order-process.service](systemd-conf/agent-order-process/agent.service)

  - agent-report systemd unit: [waldur-agent-report.service](systemd-conf/agent-report/agent.service)

  - agent-membership-sync systemd unit: [waldur-agent-membership-sync.service](systemd-conf/agent-membership-sync/agent.service)

  ```bash

  cp systemd-conf/agent-order-process/agent.service /etc/systemd/system/waldur-agent-order-process.service


  cp systemd-conf/agent-report/agent.service /etc/systemd/system/waldur-agent-report.service


  cp systemd-conf/agent-membership-sync/agent.service /etc/systemd/system/waldur-agent-membership-sync.service
  ```

  After these preparation steps, run the following script to apply the changes.

  ```bash
  systemctl daemon-reload
  systemctl start waldur-agent-order-process.service
  systemctl enable waldur-agent-order-process.service # to start after reboot
  systemctl start waldur-agent-report.service
  systemctl enable waldur-agent-report.service
  systemctl start waldur-agent-membership-sync.service
  systemctl enable waldur-agent-membership-sync.service
  ```



  If you want to deploy the agents on a machine
  with systemd revision older than 240,
  you should use files with legacy configuration:

  - systemd legacy unit file for agent-pull:
    [waldur-site-agent-pull-legacy.service](systemd-conf/agent-pull/waldur-site-agent-pull-legacy.service)
  - systemd legacy unit file for agent-push:
    [waldur-site-agent-push-legacy.service](systemd-conf/agent-push/waldur-site-agent-push-legacy.service)

  ```bash

  cp systemd-conf/agent-order-process/agent-legacy.service /etc/systemd/system/waldur-agent-order-process-legacy.service

  cp systemd-conf/agent-report/agent-legacy.service /etc/systemd/system/waldur-agent-report-legacy.service

  cp systemd-conf/agent-membership-sync/agent-legacy.service /etc/systemd/system/waldur-agent-membership-sync-legacy.service
  ```



  ```yaml
  sentry_dsn: "" # Data Source Name for Sentry (more info https://docs.sentry.io/product/sentry-basics/dsn-explainer/).
  offerings: # Settings for offerings
    - name: "Example SLURM Offering" # offering name
      waldur_api_url: "http://localhost:8081/api/" # URL of Waldur API (e.g. http://localhost:8081/api/).
      waldur_api_token: "" # Token to access the Waldur API.
      waldur_offering_uuid: "" # UUID of the offering in Waldur.
      mqtt_enabled: true # MQTT feature toggler
      websocket_use_tls: true # Whether to use TLS for websocket connection
      backend_type: "slurm" # type of backend, for now only `slurm` and `moab` is supported
      backend_settings: # backend-specific settings
        default_account: "root" # Default parent account name in SLURM cluster
          
        customer_prefix: "hpc_" # Prefix for customer's accounts.
        project_prefix: "hpc_" # Prefix for project's accounts.
        allocation_prefix: "hpc_" # Prefix used for allocation's accounts.
          
        qos_downscaled: "limited" # The QoS set to an account after downscaling
        qos_paused: "paused" # The QoS set to an account after pausing
        qos_default: "normal" # The default QoS for account in the SLURM cluster
        enable_user_homedir_account_creation: true # Whether to create home directories
          
        homedir_umask: "0700" # A umask for created homedirs
      backend_components: # Computing components on backend with accounting data
        cpu: # Type of the component, for example `cpu`
          measured_unit: "k-Hours" # Waldur measured unit for accounting.
            
          unit_factor: 60000 # Factor for conversion from measured unit
            
            
            
          accounting_type: "usage" # Can be either `usage` or `limit`
          label: "CPU" # A label for the component in Waldur
        mem:
          limit: 10 # Amount of measured units for Waldur (SLURM measured unit is MB-minutes)
          measured_unit: 'gb-Hours' # Waldur measured unit for accounting
          unit_factor: 61440 # Unit factor for conversion from measured unit
            
          accounting_type: usage # Can be usage or limit
          label: RAM # A label for a component in Waldur
    - name: "Example MOAB Offering"
      waldur_api_url: "http://localhost:8081/api/"
      waldur_api_token: ""
      waldur_offering_uuid: ""
      backend_type: "moab"
      backend_settings:
        default_account: root
        customer_prefix: "c_"
        project_prefix: "p_"
        allocation_prefix: "a_"
        enable_user_homedir_account_creation: true
      backend_components:
        deposit: # For MOAB backend, only "deposit" is supported
          measured_unit: 'EUR'
          accounting_type: limit
          label: Deposit (EUR)
  ```


pkgId: e7c6e2407badb97633b6a0253d3a31cdcbceb0846ac800f1d47e7efb039e8958
name: python-wandelbots-api-client-help
arch: noarch
version: 24.8.1
epoch: 0
release: 1
summary: Development documents and examples for wandelbots-api-client
url: https://wandelbots.com/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wandelbots-api-client-24.8.1-1.src.rpm
location_href: Packages/python-wandelbots-api-client-help-24.8.1-1.noarch.rpm
checksum_type: sha256
description:
  Interact with robots in an easy and intuitive way.

  - Compatible API version: 1.0.0 beta (can be found at the home screen of your instance -> API)
  - Package version: 24.8.1

  Sign up for our [Wandelbots Developers Beta program](https://www.wandelbots.com/developers-beta) to get access to the Wandelbots API.

  The documentation can be found here: [https://docs.wandelbots.io/24.3/fastapi/quickstart](https://docs.wandelbots.io/24.3/fastapi/quickstart)

  For more information, please visit [https://www.wandelbots.com](https://www.wandelbots.com)


  Python >=3.9, Python < 4.0


  ```
  pip install wandelbots-api-client
  ```

  OR

  pyproject.toml:
  ```
  [tool.poetry.dependencies]
  wandelbots-api-client = "*"
  ```


pkgId: 9bf387d8d51000f6f4773aa78f1e2dcba142fcf437844f52ed02cb43189027e1
name: python-wandelbots-nova-help
arch: noarch
version: 0.2.1
epoch: 0
release: 1
summary: Development documents and examples for wandelbots-nova
url: https://pypi.org/project/wandelbots-nova/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wandelbots-nova-0.2.1-1.src.rpm
location_href: Packages/python-wandelbots-nova-help-0.2.1-1.noarch.rpm
checksum_type: sha256
description:
  This library provides an SDK for the Wandelbots NOVA API.

  The SDK will help you to build your own apps and services on top of NOVA and makes programming a robot as easy as possible.



  This library requires
  * Python >=3.10



  To use the library, first install it using the following command

  ```bash
  pip install wandelbots-nova
  ```

  Then import the library in your code

  ```python
  from nova import Nova, MotionGroup
  ```



  Here is an example of how to use the library to connect to a robot controller and move the robot.

  ```python
  from nova import Nova, pi, jnt, ptp
  import asyncio


  async def main():
    nova = Nova()
    cell = nova.cell()
    controller = await cell.controller("ur")

    
    home_joints = (0, -pi / 4, -pi / 4, -pi / 4, pi / 4, 0)

    
    async with controller:
      motion_group = controller.motion_group()

      
      current_pose = await motion_group.tcp_pose("Flange")
      target_pose = current_pose @ Pose((100, 50, 0, 0, 0, 0))

      actions = [
        jnt(home_joints),
        ptp(target_pose),
        ptp(target_pose @ (200, 0, 0, 0, 0, 0)),
        jnt(home_joints),
      ]

      await motion_group.run(actions, tcp="Flange")


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

  Have a look at the [examples](https://github.com/wandelbotsgmbh/wandelbots-nova/tree/main/examples) directory to see how to use the library.



  To install the development dependencies, run the following command

  ```bash
  poetry install
  ```



  1. **Copy the Template:** Make a copy of the provided `.env.template` file and rename it to `.env` with `cp .env.template .env`.
  2. **Fill in the Values:** Open the `.env` file in a text editor and provide the necessary values for each variable. The table below describes each variable and its usage.

  | Variable            | Description                                                               | Required | Default | Example                    |
  |---------------------|---------------------------------------------------------------------------|----------|---------|----------------------------|
  | `NOVA_HOST`         | The base URL or hostname of the NOVA server instance.                     | Yes      | None    | `https://nova.example.com` |
  | `NOVA_USERNAME`     | The username credential used for authentication with the NOVA service.    | Yes*     | None    | `my_username`              |
  | `NOVA_PASSWORD`     | The password credential used in conjunction with `NOVA_USERNAME`.         | Yes*     | None    | `my_password`              |
  | `NOVA_ACCESS_TOKEN` | A pre-obtained access token for NOVA if using token-based authentication. | Yes*     | None    | `eyJhbGciOi...`            |

  > **Note on Authentication:**
  > You can authenticate with NOVA using either **username/password** credentials or a pre-obtained **access token**, depending on your setup and security model:
  > - If using **username/password**: Ensure both `NOVA_USERNAME` and `NOVA_PASSWORD` are set, and leave `NOVA_ACCESS_TOKEN` unset.
  > - If using an **access token**: Ensure `NOVA_ACCESS_TOKEN` is set, and leave `NOVA_USERNAME` and `NOVA_PASSWORD` unset.
  >
  > **Only one method should be used at a time.** If both methods are set, the token-based authentication (`NOVA_ACCESS_TOKEN`) will typically take precedence.


pkgId: 924d9e06b46cd96a1245c2cef26ad621b4775b22a10f22a9f8b292251fa415cf
name: python-wappalyzer-help
arch: noarch
version: 1.0.5
epoch: 0
release: 1
summary: Development documents and examples for wappalyzer
url: https://github.com/s0md3v/wappalyzer
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wappalyzer-1.0.5-1.src.rpm
location_href: Packages/python-wappalyzer-help-1.0.5-1.noarch.rpm
checksum_type: sha256
description:
  This is [Wappalyzer](https://www.wappalyzer.com/) browser extenstion but as a command line tool and python library. Unlike other projects emerged after discontinuation of the official open source project, this one uses the official browser extension for accurate and up-to-date results.

  If you wish to use it as a command line tool, see the "[For Users](https://github.com/s0md3v/wappalyzer-next?tab=readme-ov-file#for-users)" section.
  To use it a python library, see the "[For Developers](https://github.com/s0md3v/wappalyzer-next?tab=readme-ov-file#for-developers)" section.



  ```bash
  pipx install wappalyzer
  ```

  You will also need to install [Firefox](https://www.mozilla.org/en-US/firefox/windows/) and [geckodriver](https://github.com/mozilla/geckodriver/releases).
  Below are detailed steps for setting up geckodriver but you may use google/youtube for help.

  <details>
  <summary>Setting up geckodriver</summary>


  1. Visit the official GeckoDriver releases page on GitHub:
     [https://github.com/mozilla/geckodriver/releases](https://github.com/mozilla/geckodriver/releases)
  2. Download the version compatible with your system:
     - For Windows: `geckodriver-vX.XX.X-win64.zip`
     - For macOS: `geckodriver-vX.XX.X-macos.tar.gz`
     - For Linux: `geckodriver-vX.XX.X-linux64.tar.gz`
  3. Extract the downloaded file to a folder of your choice.


  To ensure Selenium can locate the GeckoDriver executable:
  - **Windows**:
    1. Move the `geckodriver.exe` to a directory (e.g., `C:\WebDrivers\`).
    2. Add this directory to the system's PATH:
       - Open **Environment Variables**.
       - Under **System Variables**, find and select the `Path` variable, then click **Edit**.
       - Click **New** and enter the directory path where `geckodriver.exe` is stored.
       - Click **OK** to save.
  - **macOS/Linux**:
    1. Move the `geckodriver` file to `/usr/local/bin/` or another directory in your PATH.
    2. Use the following command in the terminal:
       ```bash
       sudo mv geckodriver /usr/local/bin/
       ```
       Ensure `/usr/local/bin/` is in your PATH.
  </details>




  Basic usage:

  ```bash
  wappalyzer -i <url_or_file> [options]
  ```



  Scan a single URL:
  ```bash
  wappalyzer -i https://example.com
  ```

  Scan multiple URLs from a file:
  ```bash
  wappalyzer -i urls.txt -t 10
  ```

  Scan with authentication:
  ```bash
  wappalyzer -i https://example.com -c "sessionid=abc123; token=xyz789"
  ```

  Export results to JSON:
  ```bash
  wappalyzer -i https://example.com -oJ results.json
  ```



  > Note: For accuracy use 'full' scan type (default). 'fast' and 'balanced' do not use browser emulation.

  - `-i`: Input URL or file containing URLs (one per line)
  - `--scan-type`: Scan type (default: 'full')
    - `fast`: Quick HTTP-based scan (sends 1 request)
    - `balanced`: HTTP-based scan with more requests
    - `full`: Complete scan using wappalyzer extension
  - `-t, --threads`: Number of concurrent threads (default: 5)
  - `-oJ`: JSON output file path
  - `-oC`: CSV output file path
  - `-c, --cookie`: Cookie header string for authenticated scans



  The python library is a available on pypi as `wappalyzer` and can be imported with the same name.



  The main function you'll interact with is `analyze()`:

  ```python
  from wappalyzer import analyze


  results = analyze('https://example.com')


  results = analyze(
      url='https://example.com',
      scan_type='full',  # 'fast', 'balanced', or 'full'
      threads=3,
      cookie='sessionid=abc123'
  )
  ```



  - `url` (str): The URL to analyze
  - `scan_type` (str, optional): Type of scan to perform
    - `'fast'`: Quick HTTP-based scan
    - `'balanced'`: HTTP-based scan with more requests
    - `'full'`: Complete scan including JavaScript execution (default)
  - `threads` (int, optional): Number of threads for parallel processing (default: 3)
  - `cookie` (str, optional): Cookie header string for authenticated scans



  Returns a dictionary with the URL as key and detected technologies as value:

  ```json
  {
    "https://github.com": {
      "Amazon S3": {"version": "", "confidence": 100, "categories": ["CDN"], "groups": ["Servers"]},
      "lit-html": {"version": "1.1.2", "confidence": 100, "categories": ["JavaScript libraries"], "groups": ["Web development"]},
      "React Router": {"version": "6", "confidence": 100, "categories": ["JavaScript frameworks"], "groups": ["Web development"]},
    "https://google.com" : {},
    "https://example.com" : {},
  }
  ```




  Firefox extensions are .xpi files which are essentially zip files. This makes it easier to extract data and slightly modify the extension to make this tool work.


  - **fast**: Sends a single HTTP request to the URL. Doesn't use the extension.
  - **balanced**: Sends additional HTTP requests to .js files, /robots.txt annd does DNS queries. Doesn't use the extension.
  - **full**: Uses the official Wappalyzer extension to scan the URL in a headless browser.


pkgId: cd82f5dcae3596e6cb581b5270d45db917350f9af9e41c4856056b9102c7a777
name: python-warn-transformer-help
arch: noarch
version: 1.3.194
epoch: 0
release: 1
summary: Development documents and examples for warn-transformer
url: https://github.com/biglocalnews/warn-transformer
rpm_license: Apache 2.0 license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-warn-transformer-1.3.194-1.src.rpm
location_href: Packages/python-warn-transformer-help-1.3.194-1.noarch.rpm
checksum_type: sha256
description:
  - Documentation: [warn-transformer.readthedocs.io](https://warn-transformer.readthedocs.io)
  - Repository: [github.com/biglocalnews/warn-transformer](https://github.com/biglocalnews/warn-transformer)
  - Packaging: [pypi.org/project/warn-transformer](https://pypi.org/project/warn-transformer/)



  The project is sponsored by [Big Local News](https://biglocalnews.org/#/about), a program at Stanford University that collects data for impactful journalism. The code is maintained by [Ben Welsh](https://palewi.re/who-is-ben-welsh/), a visiting data journalist from the Los Angeles Times.


pkgId: d2d3ab15a84d2ae8747e5bf8dec7156f89eaa0783418d15f18b9b45890b1b84e
name: python-water-column-sonar-processing-help
arch: noarch
version: 0.0.10
epoch: 0
release: 1
summary: Development documents and examples for water-column-sonar-processing
url: https://github.com/CI-CMG/water-column-sonar-processing
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-water-column-sonar-processing-0.0.10-1.src.rpm
location_href: Packages/python-water-column-sonar-processing-help-0.0.10-1.noarch.rpm
checksum_type: sha256
description:
  Processing tool for converting L0 data to L1 and L2 as well as generating geospatial information


  > Python 3.10.12


    1. Install pyenv (https://github.com/pyenv/pyenv#set-up-your-shell-environment-for-pyenv)
       1. ```brew update```
       2. ```arch -arm64 brew install pyenv```
       3. In ~/.bashrc add
          1. ```export PYENV_ROOT="$HOME/.pyenv"```
          2. ```export PATH="$PYENV_ROOT/bin:$PATH"```
          3. ```eval "$(pyenv init -)"```
       4. ```arch -arm64 brew install openssl readline sqlite3 xz zlib tcl-tk```
    2. Install pyenv-virtualenv (https://github.com/pyenv/pyenv-virtualenv)
       1. ```arch -arm64 brew install pyenv-virtualenv```
       2. In ~/.bashrc add
           1. ```eval "$(pyenv virtualenv-init -)"```
    3. Open a new terminal
    4. Install Python version
       1. ```env CONFIGURE_OPTS='--enable-optimizations' arch -arm64 pyenv install 3.10.12```
    5. Create virtual env (to delete 'pyenv uninstall 3.10.12/water-column-sonar-processing')
       1. ```pyenv virtualenv 3.10.12 water-column-sonar-processing```
    6. Set local version of python (if not done already)
       1. change directory to root of project
       2. ```pyenv local 3.10.12 water-column-sonar-processing```
       3. ```pyenv activate water-column-sonar-processing```



    1. Install the IntelliJ Python plugin
    2. Set up pyenv
       1. File -> Project Structure or CMD + ;
       2. SDKs -> + -> Add Python SDK -> Virtual Environment
       3. Select Existing Environment
       4. Choose ~/.pyenv/versions/mocking_aws/bin/python
    3. Set up Python Facet (not sure if this is required)
       1. File -> Project Structure or CMD + ;
       2. Facets -> + -> Python
       3. Set interpreter



    1. Add dependencies with versions to requirements.txt
    2. ```pip install --upgrade pip && pip install -r requirements_dev.txt```



  ```commandline
  pytest --disable-warnings
  ```
  or
  > pytest --cache-clear --cov=src tests/ --cov-report=xml


  Following this tutorial:
  https://packaging.python.org/en/latest/tutorials/packaging-projects/


  ```commandline
  python -m build


  python -m twine upload --repository testpypi dist/*
  pytho -m pip install --index-url https://test.pypi.org/simple/ hello-pypi-rudy-klucik
  python
  ```
  ```
  from water-column-sonar-processing import ZarrManager
  example.add_one(2)
  ```


  ```commandline
  python -m build
  python -m twine upload --repository pypi dist/*
  ```


  see here for installation: https://pre-commit.com/
  https://dev.to/rafaelherik/using-trufflehog-and-pre-commit-hook-to-prevent-secret-exposure-edo
  ```
  pre-commit install --allow-missing-config
  ```


  Ruff
  https://plugins.jetbrains.com/plugin/20574-ruff


  https://colab.research.google.com/drive/1KiLMueXiz9WVB9o4RuzYeGjNZ6PsZU7a#scrollTo=AayVyvpBdfIZ


  20241124
  8 failed, 32 passed, 3 skipped, 1 warning in 6.92s
  20241125
  5 failed, 35 passed, 3 skipped, 1 warning in 9.71s
  3 failed, 38 passed, 3 skipped, 1 warning in 7.24s



  add https://pypi.org/project/setuptools-scm/
  for extracting the version


pkgId: 90efca0409ef611afa9f1b185f58474430b847679f1f544c28a12dd14a3cf63b
name: python-watercrawl-openai-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for watercrawl-openai
url: https://github.com/watercrawl/watercrawl-openai
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-watercrawl-openai-0.0.1-1.src.rpm
location_href: Packages/python-watercrawl-openai-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  __version__: 0.0.1
  __author__: Watercrawl

  [![PyPI version](https://badge.fury.io/py/watercrawl-openai.svg)](https://badge.fury.io/py/watercrawl-plugin)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  This plugin allows you to use OpenAI's LLM to extract information from crawled content.




  You can install this plugin using pip:

  ```bash
  pip install watercrawl-openai
  ```


  To use this plugin in your Watercrawl project, import it as follows:

  ```python
  TODO: complete this section
  ```



  Make sure to set the following environment variables:

  ```env
  OPENAI_API_KEY="Your OpenAI API key"
  EXTRACT_SYSTEM_PROMPT="Your system prompt"
  ```



  Contributions are welcome! Please feel free to submit a Pull Request.



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



  GitHub: https://github.com/watercrawl/watercrawl-openai


pkgId: dc739db48aa1adb9d73d8d179182275f68f0ba16e5779fdde98ba694aa891993
name: python-watertap-help
arch: noarch
version: 1.1.0
epoch: 0
release: 1
summary: Development documents and examples for watertap
url: https://github.com/watertap-org/watertap
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-watertap-1.1.0-1.src.rpm
location_href: Packages/python-watertap-help-1.1.0-1.noarch.rpm
checksum_type: sha256
description:
  This is the WaterTAP development repository.

  WaterTAP is developed as part of the [National Alliance for Water Innovation](https://nawihub.org/) project.



  [![Checks](https://github.com/watertap-org/watertap/actions/workflows/checks.yml/badge.svg)](https://github.com/watertap-org/watertap/actions/workflows/checks.yml)
  [![Documentation Status](https://readthedocs.org/projects/watertap/badge/?version=latest)](https://watertap.readthedocs.io/en/latest/?badge=latest)
  [![codecov](https://codecov.io/gh/watertap-org/watertap/branch/main/graph/badge.svg)](https://codecov.io/gh/watertap-org/watertap)
  [![GitHub contributors](https://img.shields.io/github/contributors/watertap-org/watertap.svg)](https://github.com/watertap-org/watertap/graphs/contributors)
  [![Merged PRs](https://img.shields.io/github/issues-pr-closed-raw/watertap-org/watertap.svg?label=merged+PRs)](https://github.com/watertap-org/watertap/pulls?q=is:pr+is:merged)
  [![Issue stats](http://isitmaintained.com/badge/resolution/watertap-org/watertap.svg)](http://isitmaintained.com/project/watertap-org/watertap)



  To quickly install and start using WaterTAP, head over to the [Getting Started](https://watertap.readthedocs.io/en/stable/getting_started.html) section of the documentation.

  If you wish to use the **WaterTAP UI**, you can [download and install](https://watertap-org.github.io) it from this page: https://watertap-org.github.io.

  To run the WaterTAP tutorials online (no installation required), refer to [this guide](https://watertap.readthedocs.io/en/stable/how_to_guides/notebooks.html#online-using-binder-org).



  The WaterTAP documentation is available online at <https://watertap.readthedocs.io>.



  If you want to clone the repository and work directly with the code, please
  refer to the [Getting Started for Developers](https://watertap.readthedocs.io/en/stable/getting_started.html#for-watertap-developers) section of the documentation.



  To cite this work, use the "Cite this repository" feature available on the right side of this repository page or use the reference text given below.

  > WaterTAP contributors. WaterTAP: An open-source water treatment model library. Version 0.6. Sponsored by California Energy Commission, National Alliance for Water Innovation, and USDOE. Available at https://github.com/watertap-org/watertap.



  This work is being conducted as part of the [National Alliance for Water Innovation
  (NAWI)](https://www.nawihub.org/) with support through the U.S. Department of Energy’s [Advanced
  Manufacturing Office](https://www.energy.gov/eere/amo/advanced-manufacturing-office).


pkgId: 025f95bc1860daf40a38ce14522b5d577bb232c24bace717ef6e7443c99aa94f
name: python-wauo-help
arch: noarch
version: 0.6.6
epoch: 0
release: 1
summary: Development documents and examples for wauo
url: https://github.com/markadc/wauo
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wauo-0.6.6-1.src.rpm
location_href: Packages/python-wauo-help-0.6.6-1.noarch.rpm
checksum_type: sha256
description:
  - 新增`jsonp2json`静态方法
  - 爬虫默认保持会话状态
  - 新增`get_uuid`、`base64`加解密的静态方法
  - 删除`download_text`、`download_bdata`，合并为`download`
  - 新增`update_default_headers`方法
  - `make_md5`支持字符串、二进制参数，并且可以加盐
  - `send`方法加入`delay`参数，请求时可以设置延迟
  - 新增`tools`包、`spiders`包
  - 线程池管理者加入上下文，可以使用`with`了
  - 新增`get_results`方法，获取所有`fs`的返回值
  - 可以提前在send方法之前自定义延迟、超时
  - 线程池管理者新增`running`方法，可以用于判断任务状态
  - `send`方法加入详细注释
  - 新增`todos`方法、tools改为utils
  - `done`加入func_name参数，可以定位到具体是哪一个`线程函数`出现异常
  - `WaitPool`、`SpeedPool`
  - 一些参数的变化（改名、补充注解）
  - 加入了一些装饰器函数
  - 补充`send`方法中`**kwargs`的说明
  - 新增`block`方法，可以进行阻塞
  - 一些优化



  - 基于requests封装的一个爬虫类



  - python3.10+





  ```python
  from wauo import WauoSpider

  spider = WauoSpider()
  ```





  - 默认是get请求

  ```python
  url = 'https://github.com/markadc'
  resp = spider.send(url)
  print(resp.text)
  ```



  - 使用了`data`或者`json`参数，则是post请求

  ```python
  api = 'https://github.com/markadc'
  payload = {
      'key1': 'value1',
      'key2': 'value2'
  }
  resp = spider.send(api, data=payload)  # 使用data参数
  resp = spider.send(api, json=payload)  # 使用json参数
  ```







  - 如果响应码不在codes范围里则抛弃响应（此时`send`返回`None`）

  ```python
  resp = spider.send('https://github.com/markadc', codes=[200, 301, 302])
  ```



  - 如果checker返回False则抛弃响应（此时`send`返回`None`）

  ```python
  def is_ok(response):
      html = response.text
      if html.find('验证码') != -1:
          return False


  resp = spider.send('https://github.com/markadc', checker=is_ok)
  ```



  - 给headers设置Cookie
  - 给headers设置代理
  - 给headers设置认证信息
  - ...



  - 每一次请求的headers都带上`cookie`

  ```python
  from wauo import WauoSpider

  cookie = 'Your Cookies'
  spider = WauoSpider(default_headers={'Cookie': cookie})
  resp1 = spider.send('https://github.com/markadc')
  resp2 = spider.send('https://github.com/markadc/wauo')
  print(resp1.request.headers)
  print(resp2.request.headers)
  ```


pkgId: 601525652205977aa05676e8e5a747c9245ca1b47ed4afc410052bfb94d38109
name: python-waveformtools-help
arch: noarch
version: 2024.12.19
epoch: 0
release: 1
summary: Development documents and examples for waveformtools
url: https://gitlab.com/vaishakp/waveformtools
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waveformtools-2024.12.19-1.src.rpm
location_href: Packages/python-waveformtools-help-2024.12.19-1.noarch.rpm
checksum_type: sha256
description:
  [[Project landing page]](https://sites.google.com/view/waveformtools/home)
  [![pipeline status](https://gitlab.com/vaishakp/waveformtools/badges/main/pipeline.svg)](https://gitlab.com/vaishakp/waveformtools/commits/main)
  [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://gitlab.com/vaishakp/waveformtools/commits/main/LICENSE)
  [![Documentation Status](https://readthedocs.org/projects/waveformtools/badge/?version=latest)](https://waveformtools.readthedocs.io/en/latest/?badge=latest)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![PyPI version](docs/vers_badge.svg)](https://pypi.org/project/waveformtools/)



  This is a python module for the handling and analysis of waveforms and data from Numerical Relativity codes, and for carrying out gravitational wave data analysis.

  waveformtools is a numerical relativity data handling package that was written to aid the handling and analysis of numerical relativity data.

  This package contains implementations of customized algorithms and techniques.  Some of these contain the usage of existing python based library functions from pycbc, scipy, etc but effort has been made to keep these to a minimum.


  * Handling of numerical relativity data, and retreiving specific information about the physical system. Presently, this supports the EinsteinToolkit data.

      The class container and methods "sim" can load NR data into convenient lists and dictionaries, which can be used to     retrieve specific data/ information about the numerical simulation.

      This offers the following functionality, like retreiving:

      * Horizon masses, mass-ratios, and areas.

      * Horizon multipole moments.

      * Merger time/ formation time of common horizon.

      * The strain waveform.

      * The shear data of the dynamical horizons.

  	* And computing/ extracting the Frequency, amplitude and phase of waveforms, etc.

  * Handling of waveforms.

      A  basic class container for handling numerical waveforms.

      This offers functionality like:

      * loading data from hdf5 files.

      * basic information such as time step, time axis, data axis, etc.

      * extrapolating a numerical waveform recorded at a finite radius to null infinity (to be added soon).

      * integrating and differentiating waveforms in the frequency domain (to be added soon).



  * Tools for preparation/handling of numerical relativity data, like:

      * checking for discontinuity, removal of duplicated rows, and interpolating for missing rows in the data.

      * integration, differentiation of numerical data.

      * equalizing lengths of waveforms.

      * resampling

      * computing the norm, shifting/ rolling the data, etc.

      * Smoothening, tapering.

      * Extrapolation of waveforms to null infinity.

      * Center of Mass corrections to waveforms.

      * BMS Supertranslations of waveforms.


  * Tools for basic data analysis.

      * A match algorithms for matching two waveforms.

      * Binning and interpolation of data.

      * Smooth derivatives: spectral and finite difference derivatives.

  * Miscellaneous tools:

      * Progress bar to display progress of loops.

      * A custom print function with message prioritization.

      * Saving data to disk with protocol support (binary, text, etc.)





  Please cite the latest version of this code if used in your work. This code was developed for use in the following works:

  1. [News from Horizons in Binary Black Hole Mergers](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.121101)
  2. [Tidal deformation of dynamical horizons in binary black hole mergers](https://journals.aps.org/prd/abstract/10.1103/PhysRevD.105.044019)

  We request you to also cite these. Thanks!









  This module has the following dependencies:

  * Standard packages (come with full anaconda installation)
      * [`numpy`](http://www.numpy.org/)
      * [`scipy`](http://scipy.org/)
      * [`statistics`](https://docs.python.org/3/library/statistics.html)
      * [`matplotlib`](http://matplotlib.org/)
      * [`h5py`](http://www.h5py.org/)
      * [`termcolor`](https://pypi.org/project/termcolor/)
      *
  * Optional dependencies (labelled [EXT])
      * For use with PyCBC data analysis packages.
          * [`pyCBC`](https://pycbc.org/)
          * [`lalsuite`](https://git.ligo.org/lscsoft/lalsuite)
          * [`ligo-common`](https://git.ligo.org/lscsoft/ligo-common)
      * [`gmpy2`](https://gmpy2.readthedocs.io/en/latest/)




  I recommend installing this module through pypi:
  ```sh
  pip install waveformtools
  ```


  Manual install directly from gitlab:

  ```pip install git+https://gitlab.com/vaishakp/waveformtools@main```

  Or from a clone:

  * First, clone this repository:

  ```sh
  git clone https://gitlab.com/vaishakp/waveformtools.git

  ```
  * Second, run python setup from the `waveformtools` directory:
  ```sh
  cd waveformtools
  python setup.py install --prefix="<path to your preferred installation dir>"
  ```



  * To create an environment with automatic dependency resolution and activate it, run
  ```sh
  conda create env -f docs/environment.yml
  conda activate wftools
  ```



  ```
  >>> from waveformtools.waveforms import modes_array
  >>> fdir = "<path to data dir>"
  >>> fname = 'ExtrapStrain_RIT-BBH-0001-n100.h5'
  >>> wf1 = modes_array(label='RIT001', spin_weight=-2)
  >>> wf1.file_name = fname
  >>> wf1.data_dir = fdir
  >>> wf1.load_modes(ftype='RIT', var_type='Strain', ell_max='auto', resam_type='auto')
  >>> wf1.get_metadata()
  {'label': 'RIT001',
   'data_dir': '/home/vaishakprasad/Downloads/',
   'file_name': 'ExtrapStrain_RIT-BBH-0001-n100.h5',
   'key_format': None,
   'ell_max': 4,
   'modes_list': [[2, [-2, -1, 0, 1, 2]],
    [3, [-3, -2, -1, 0, 1, 2, 3]],
    [4, [-4, -3, -2, -1, 0, 1, 2, 3, 4]]],
   'r_ext': 500,
   'frequency_axis': None,
   'out_file_name': None,
   'maxtime': None,
   'date': '2023-04-26',
   'time': '17:37:20',
   'key_ex': None,
   'spin_weight': -2}
  ```

  To access the individual modes, use the :math:`\ell, m` notation.
  ```
  >>> ell = 2
  >>> emm = 2
  >>> wf1.mode(ell, emm)
  array([-5.82188926e-17-2.09534621e-18j, -5.96136537e-17-2.06759459e-18j,
         -6.10007697e-17-2.04743540e-18j, ...,
         -7.23538504e-18+4.65415462e-33j, -3.62788145e-18-4.11078069e-33j,
          0.00000000e+00+0.00000000e+00j])
  ```

  To plot the modes
  ```
  >>> import matplotlib.pyplot as plt
  >>> plt.plot(wf1.time_axis, wf1.mode(ell, emm).real, label='+')
  >>> plt.plot(wf1.time_axis, wf1.mode(ell, emm).imag, label='X')
  >>> plt.legend()
  >>> plt.grid(alpha=0.4)
  >>> plt.xlabel(r'$t/M$')
  >>> plt.ylabel(f'$rh/M$')
  >>> plt.show()
  ```
  ![](./docs/images/RIT-BBH-001.png){: .shadow}



  The documentation for this module is available at [Link to the Documentation](https://waveformtools.readthedocs.io/en/latest/). This was built automatically using Read the Docs.

  In some case where the repo has run out of gitlab CI minutes, the documentation is not automatically built. In such cases, we request the user to access the documentation through the `index.html` file in `docs` directory.



  If you run into any issues while using this package, please report the issue on the [issue tracker](https://gitlab.com/vaishakp/waveformtools/-/issues).




  This project has been hosted, as you can see, on gitlab. Several gitlab tools are used in the deployment of the code, its testing, version control.

  The work of this was developed in aiding my PhD work at Inter-University Centre for Astronomy and Astrophysics (IUCAA, Pune, India)](https://www.iucaa.in/). The PhD is in part supported by the [Shyama Prasad Nukherjee Fellowship](https://csirhrdg.res.in/Home/Index/1/Default/2006/59) awarded to me by the [Council of Scientific and Industrial Research (CSIR, India)](https://csirhrdg.res.in/). Resources of the [Inter-University Centre for Astronomy and Astrophysics (IUCAA, Pune, India)](https://www.iucaa.in/) were are used in part.


pkgId: abfc4cc5995362e86f36b3205f63a40aa708315365831ad0cb4412a516247786
name: python-wavesurfer-help
arch: noarch
version: 0.1.0
epoch: 0
release: 1
summary: Development documents and examples for wavesurfer
url: https://github.com/pengzhendong/wavesurfer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-wavesurfer-0.1.0-1.src.rpm
location_href: Packages/python-wavesurfer-help-0.1.0-1.noarch.rpm
checksum_type: sha256
description:
  ``` bash
  $ pip install wavesurfer
  ```

  - display wave file

  ``` python
  from wavesurfer import display

  display("data/test_16k.wav")
  ```

  - display waveform

  ``` python
  import torchaudio
  from wavesurfer import display

  waveform, rate = torchaudio.load("data/test_16k.wav")
  display(waveform, rate, enable_minimap=True, enable_spectrogram=True)
  ```

  ![](images/test_16k.png)

  - display streaming waveform

  ``` python
  import time
  import torchaudio
  from wavesurfer import display

  def audio_generator():
      waveform, rate = torchaudio.load("data/test_16k.wav")
      chunk_size_s = 0.3
      chunk_size = int(chunk_size_s * rate)
      for i in range(0, waveform.size(1), chunk_size):
          time.sleep(0.1)  # RTF: 0.1/0.3 < 1
          yield waveform[:, i:i + chunk_size]

  display(audio_generator(), rate=16000)
  ```


pkgId: 2e8c74623a8c11cd76e8a6c256fbfaa9187f927af7cee830b69755bc81ee42e4
name: python-waylay-sdk-alarms-help
arch: noarch
version: 1.13.1.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-alarms
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-alarms-1.13.1.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-alarms-help-1.13.1.20241025-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  This Python package is automatically generated based on the
  Waylay Alarms OpenAPI specification (API version: 1.13.1)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/alarms.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Alarms api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-alarms-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-alarms` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-alarms]` will additionally install the types package `waylay-sdk-alarms-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _alarms_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-alarms` to only install api support for _alarms_.
  - `pip install waylay-sdk-alarms[types]` to additionally install type support for _alarms_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.alarms.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.alarms.about.get(
      )
      print("The response of alarms.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling alarms.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

rpm_license:
  ISC License (ISC) Copyright 2024, Waylay  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 7a558f6b2279902609e5b4e66d06f84031351603c57febf461cce63ecc0ec719
name: python-waylay-sdk-alarms-types-help
arch: noarch
version: 1.13.1.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-alarms-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-alarms-types-1.13.1.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-alarms-types-help-1.13.1.20241025-1.noarch.rpm
checksum_type: sha256
description:
  No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)

  This Python package is automatically generated based on the
  Waylay Alarms OpenAPI specification (API version: 1.13.1)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/alarms.html).

  It is considered an extension of the waylay-sdk-alarms package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-alarms`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-alarms` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-alarms]` will additionally install the types package `waylay-sdk-alarms-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _alarms_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-alarms` to only install api support for _alarms_.
  - `pip install waylay-sdk-alarms[types]` to additionally install type support for _alarms_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.alarms.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.alarms.about.get(
      )
      print("The response of alarms.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling alarms.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

rpm_license:
  ISC License (ISC) Copyright 2024, Waylay  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: ed82cc3533fb7c6a339ddb938dc1305ed0df9f9fdfe70317c43db45bdbc20833
name: python-waylay-sdk-data-help
arch: noarch
version: 2.18.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-data
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-data-2.18.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-data-help-2.18.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  Data is ingested into the platform by the Waylay Broker.

  This Python package is automatically generated based on the
  Waylay Data OpenAPI specification (API version: 2.18.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/data.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Data api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-data-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-data` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-data]` will additionally install the types package `waylay-sdk-data-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _data_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-data` to only install api support for _data_.
  - `pip install waylay-sdk-data[types]` to additionally install type support for _data_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.data.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.data.about.get(
      )
      print("The response of data.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling data.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

rpm_license:
  ISC License (ISC) Copyright 2024, Waylay  Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


pkgId: 308500aad394e9d52450feabc2c4f9778f8b9aac62e1994c8cf6370271ac5769
name: python-waylay-sdk-data-types-help
arch: noarch
version: 2.18.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-data-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-data-types-2.18.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-data-types-help-2.18.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  Data is ingested into the platform by the Waylay Broker.

  This Python package is automatically generated based on the
  Waylay Data OpenAPI specification (API version: 2.18.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/data.html).

  It is considered an extension of the waylay-sdk-data package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-data`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-data` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-data]` will additionally install the types package `waylay-sdk-data-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _data_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-data` to only install api support for _data_.
  - `pip install waylay-sdk-data[types]` to additionally install type support for _data_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.data.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.data.about.get(
      )
      print("The response of data.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling data.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: bd1a8c727f142502cdce8607900659b17a89f74c23d57ffe514533ae77122a66
name: python-waylay-sdk-help
arch: noarch
version: 2024.10.25
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk
url: https://www.waylay.io/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-2024.10.25-1.src.rpm
location_href: Packages/python-waylay-sdk-help-2024.10.25-1.noarch.rpm
checksum_type: sha256
description:
  Python SDK for the Waylay Platform.

  This `waylay-sdk` umbrella package is the main entrypoint to install the python SDK client for the [Waylay REST apis](https://docs.waylay.io/#/api/?id=openapi-docs).

  It includes api support for the most relevant services, as extensions for the [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/) base SDK client.

  Alternatively:
  * use the [`waylay-sdk-core`](https://pypi.org/project/waylay-sdk-core) package for a minimal SDK client
  * use any of the [waylay-sdk-{service}](https://pypi.org/search/?q=waylay-sdk-&o=) packages to install an SDK client that has api support for the selected service(s) only.

  See [Waylay Docs](https://docs.waylay.io/#/api/sdk/python) for extensive documentation.



  This package requires a python runtime `3.9` or higher.

  The basic client with api support for the [common services](#service-packages), can be installed with
  ```bash
  pip install waylay-sdk
  ```

  To additionally [typing](#service-packages) support for a given service, e.g. for the `alarms` service:
  ```bash
  pip install waylay-sdk[types-alarms]
  ```
  ... or for all services:
  ```bash
  pip install waylay-sdk[types]
  ```



  Support for a specific Waylay REST api comes as a separate _service package_.
  Each _service_ provides two packages:
  * an _api_ package `waylay-<service>-sdk` that describes all resources and actions for that service. JSON request and responses are represented as basic python data (_dict_, _list_, primitives)
  * a _types_ package `waylay-<service>-sdk-types` that provides [pydantic](https://docs.pydantic.dev/) models to represent JSON request and responses.

  The _types_ package is optional. When installed, its _pydantic_ models are used to serialize requests and deserialize responses. When used in a python IDE, code completion will help you navigate the attributes of request and responses.
  This makes it easier to interact with the API as a developer.
  But as the underlying REST api evolves, the _types_ package might require regular dependency updates.

  Use the _types_ package for interactive cases (python notebooks), or solutions that are regularly tested and maintained.

  When not installed, the SDK client does not interfere with the json representations of requests and responses, and you should check the [API documentation](https://docs.waylay.io/#/api/?id=openapi-docs) of the service for exact specifications.

  The Service plugs are _generated_ from their [openapi description](https://docs.waylay.io/#/api/?id=openapi-docs).



  This release of `waylay-sdk` includes the following _api_ and (optional) _types_ packages

  | name | package | api endpoint | docs | types package
  | ------- | ------------------ | ------- | --| --|
  | `alarms` | [`waylay-sdk-alarms`](https://pypi.org/project/waylay-sdk-alarms) | `/alarms/v1` | [doc](https://docs.waylay.io/#/api/alarms/) [openapi](https://docs.waylay.io/openapi/public/redocly/alarms.html) | [`waylay-sdk-alarms-types`](https://pypi.org/project/waylay-sdk-alarms-types/) |
  | `data` | [`waylay-sdk-data`](https://pypi.org/project/waylay-sdk-data) | `/data/v1` | [doc](https://docs.waylay.io/#/api/broker/) [openapi](https://docs.waylay.io/openapi/public/redocly/data.html) | [`waylay-sdk-data-types`](https://pypi.org/project/waylay-sdk-data-types/) |
  | `registry` | [`waylay-sdk-registry`](https://pypi.org/project/waylay-sdk-registry) | `/registry/v2` | [doc](https://docs.waylay.io/#/api/registry/) [openapi](https://docs.waylay.io/openapi/public/redocly/registry.html) | [`waylay-sdk-registry-types`](https://pypi.org/project/waylay-sdk-registry-types/) |
  | `resources` | [`waylay-resources-alarms`](https://pypi.org/project/waylay-sdk-resources) | `/resources/v1` | [doc](https://docs.waylay.io/#/api/resources/) [openapi](https://docs.waylay.io/openapi/public/resources/alarms.html) | [`waylay-sdk-resources-types`](https://pypi.org/project/waylay-sdk-resources-types/) |
  | `rules` | [`waylay-sdk-rules`](https://pypi.org/project/waylay-sdk-rules) | `/rules/v1` | [doc](https://docs.waylay.io/#/api/rules/) [openapi](https://docs.waylay.io/openapi/public/redocly/rules.html) | [`waylay-sdk-rules-types`](https://pypi.org/project/waylay-sdk-rules-types/) |
  | `storage` | [`waylay-sdk-storage`](https://pypi.org/project/waylay-sdk-storage) | `/storage/v1` | [doc](https://docs.waylay.io/#/api/storage/) [openapi](https://docs.waylay.io/openapi/public/redocly/storage.html) | [`waylay-sdk-storage-types`](https://pypi.org/project/waylay-sdk-storage-types/) |
  | `queries` | [`waylay-sdk-queries`](https://pypi.org/project/waylay-sdk-queries) | `/queries/v1` | [doc](https://docs.waylay.io/#/api/queries/) [openapi](https://docs.waylay.io/openapi/public/redocly/queries.html) | [`waylay-sdk-queries-types`](https://pypi.org/project/waylay-sdk-queries-types/) |







  The SDK client can be used in the _python_ webscripts and plugins of the Waylay platform.

  In that case, the webscript or plugin _runtime_ will configure and authenticate a client, and
  provide it as a `waylay` parameter to the _webscript_ or _plugin_ callback function.

  You just need to state the `waylay-sdk` dependency when authoring the _webscript_ or _plugin_.



  ```python
  async def execute(request: Request, waylay: WaylayClient):
      
      template_query = request.json()
      templates = await waylay.rules.templates.list(query=template_query)
      return templates
  ```


  ```python
  from csv import DictReader
  from io import StringIO
  async def execute(path: str, waylay: WaylayClient):
      """Return the CSV data from a file in assets storage."""
      
      sign_resp = await waylay.storage.objects.list('assets', path, query={"sign": "GET"})
      content_url = sign_resp._links.get_object.href
      
      csv_data = await waylay.api_client.request('GET', content_url, auth=None)
      
      return ('OK', data=[
          record for record in DictReader(StringIO(csv_data))
      ])
  ```


  When used outside the Waylay platform (e.g. in a _python notebook_) the client requires you to provide
  * the gateway endpoint: `api.waylay.io` for Enterprise users,
  * an API key-secret pair: see [Waylay Console](console.waylay.io) at _>Settings>Authentication keys_.

  ```python
  from waylay.sdk import WaylayClient


  client = WaylayClient.from_profile()


  client.services


  resp = await client.api_client.request('GET', '/registry/v2')
  ```

  Credentials and endpoints are stored in a local _profile_ file (you can have multiple such profiles).
  Other authentication methods are available (JWToken, pass apiKey/Secret directly)


pkgId: dad6464cede0ad8e6754b21f75bcb119c1846f57e9c1afa726a0fc89acb40a91
name: python-waylay-sdk-queries-help
arch: noarch
version: 0.5.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-queries
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-queries-0.5.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-queries-help-0.5.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  Execute and store queries on the Waylay timeseries.

  Protocol version: v1.

  This Python package is automatically generated based on the
  Waylay Queries OpenAPI specification (API version: 0.5.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/queries.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Queries api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-queries-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-queries` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-queries]` will additionally install the types package `waylay-sdk-queries-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _queries_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-queries` to only install api support for _queries_.
  - `pip install waylay-sdk-queries[types]` to additionally install type support for _queries_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.queries.models.query_input import QueryInput
  from waylay.services.queries.models.query_result import QueryResult
  try:
      
      
      api_response = await waylay_client.queries.execute.execute(
          
          query = {
              'resource': '13efb488-75ac-4dac-828a-d49c5c2ebbfc'
              'metric': 'temperature'
          },
          
          json = waylay.services.queries.QueryInput() # QueryInput |
          headers = {
              'accept': 'accept_example',
          },
      )
      print("The response of queries.execute.execute:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling queries.execute.execute: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 1fa453a4cab7429aae46d6319d794e1622ab08781bc978bd11b16dcfc641b1ff
name: python-waylay-sdk-queries-types-help
arch: noarch
version: 0.5.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-queries-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-queries-types-0.5.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-queries-types-help-0.5.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  Execute and store queries on the Waylay timeseries.

  Protocol version: v1.

  This Python package is automatically generated based on the
  Waylay Queries OpenAPI specification (API version: 0.5.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/queries.html).

  It is considered an extension of the waylay-sdk-queries package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-queries`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-queries` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-queries]` will additionally install the types package `waylay-sdk-queries-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _queries_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-queries` to only install api support for _queries_.
  - `pip install waylay-sdk-queries[types]` to additionally install type support for _queries_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.queries.models.query_input import QueryInput
  from waylay.services.queries.models.query_result import QueryResult
  try:
      
      
      api_response = await waylay_client.queries.execute.execute(
          
          query = {
              'resource': '13efb488-75ac-4dac-828a-d49c5c2ebbfc'
              'metric': 'temperature'
          },
          
          json = waylay.services.queries.QueryInput() # QueryInput |
          headers = {
              'accept': 'accept_example',
          },
      )
      print("The response of queries.execute.execute:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling queries.execute.execute: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: d5cded90f0e365b0d0155e2ecb4a20086d4f4de52f3aac9cc8ed32af152eb90a
name: python-waylay-sdk-registry-help
arch: noarch
version: 2.17.1.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-registry
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-registry-2.17.1.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-registry-help-2.17.1.20241025-1.noarch.rpm
checksum_type: sha256
description:
  V2 API to build and deploy Waylay functions (plugs, webscripts, BYOML models).

  This Python package is automatically generated based on the
  Waylay Registry OpenAPI specification (API version: 2.17.1)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/registry.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Registry api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-registry-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-registry` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-registry]` will additionally install the types package `waylay-sdk-registry-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _registry_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-registry` to only install api support for _registry_.
  - `pip install waylay-sdk-registry[types]` to additionally install type support for _registry_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.registry.models.root_page_response import RootPageResponse
  try:
      
      
      api_response = await waylay_client.registry.about.get(
      )
      print("The response of registry.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling registry.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 12376137fb1739b85c5a90930b495caa616245ff5a55c7b4fd9a68c65efa115b
name: python-waylay-sdk-registry-types-help
arch: noarch
version: 2.17.1.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-registry-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-registry-types-2.17.1.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-registry-types-help-2.17.1.20241025-1.noarch.rpm
checksum_type: sha256
description:
  V2 API to build and deploy Waylay functions (plugs, webscripts, BYOML models).

  This Python package is automatically generated based on the
  Waylay Registry OpenAPI specification (API version: 2.17.1)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/registry.html).

  It is considered an extension of the waylay-sdk-registry package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-registry`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-registry` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-registry]` will additionally install the types package `waylay-sdk-registry-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _registry_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-registry` to only install api support for _registry_.
  - `pip install waylay-sdk-registry[types]` to additionally install type support for _registry_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.registry.models.root_page_response import RootPageResponse
  try:
      
      
      api_response = await waylay_client.registry.about.get(
      )
      print("The response of registry.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling registry.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 6ce4ad4afdfceb1aa3368b2fb58b15b49a48149cd3c20138d02630145d358c0b
name: python-waylay-sdk-resources-help
arch: noarch
version: 8.5.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-resources
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-resources-8.5.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-resources-help-8.5.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  This service manages
  [Waylay Resources](/#/features/resources/?id=resource) and related entities.

  A _Waylay Resource_ models a real-world device or abstract entity of your IoT solution,
  and provides a context when processing data in the Rule Engine.

  You'll interact with the _Waylay Resources_ API to create this _Digital Twin_ model,
  a process that's also called _resource provisioning_.

  This Python package is automatically generated based on the
  Waylay Resources OpenAPI specification (API version: 8.5.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/resources.html).

  It consists of a plugin for the waylay-sdk-core package, and contains the Resources api methods.
  Note that the typed model classes for all path params, query params, body params and responses for each of the api methods are contained in a separate package called waylay-sdk-resources-types.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-resources` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-resources]` will additionally install the types package `waylay-sdk-resources-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _resources_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-resources` to only install api support for _resources_.
  - `pip install waylay-sdk-resources[types]` to additionally install type support for _resources_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.resources.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.resources.about.get(
      )
      print("The response of resources.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling resources.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


pkgId: 7c9a881f621a48dc9d4a8a8a42caf9ac0730d7a61b30b3d49f98ef7d4487b1e9
name: python-waylay-sdk-resources-types-help
arch: noarch
version: 8.5.0.20241025
epoch: 0
release: 1
summary: Development documents and examples for waylay-sdk-resources-types
url: https://www.waylay.io/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-waylay-sdk-resources-types-8.5.0.20241025-1.src.rpm
location_href: Packages/python-waylay-sdk-resources-types-help-8.5.0.20241025-1.noarch.rpm
checksum_type: sha256
description:
  This service manages
  [Waylay Resources](/#/features/resources/?id=resource) and related entities.

  A _Waylay Resource_ models a real-world device or abstract entity of your IoT solution,
  and provides a context when processing data in the Rule Engine.

  You'll interact with the _Waylay Resources_ API to create this _Digital Twin_ model,
  a process that's also called _resource provisioning_.

  This Python package is automatically generated based on the
  Waylay Resources OpenAPI specification (API version: 8.5.0)
  For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/resources.html).

  It is considered an extension of the waylay-sdk-resources package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-resources`.


  This package requires Python 3.9+.



  Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
  * `pip install waylay-sdk` will install `waylay-sdk-resources` together with the SDK api packages for other services.
  * `pip install waylay-sdk[types-resources]` will additionally install the types package `waylay-sdk-resources-types`.
  * `pip install waylay-sdk[types]` will install the types packages for this and all other services.

  Alternatively, you can install support for this _resources_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):

  - `pip install waylay-sdk-resources` to only install api support for _resources_.
  - `pip install waylay-sdk-resources[types]` to additionally install type support for _resources_.



  ```python
  from pprint import pprint


  from waylay.sdk.client import WaylayClient
  from waylay.sdk.api.api_exceptions import ApiError


  waylay_client = WaylayClient.from_profile()


  from waylay.services.resources.models.version_response import VersionResponse
  try:
      
      
      api_response = await waylay_client.resources.about.get(
      )
      print("The response of resources.about.get:\n")
      pprint(api_response)
  except ApiError as e:
      print("Exception when calling resources.about.get: %s\n" % e)
  ```


  For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).

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


